Implement better err and nil checks in dirListHandler issue #2122

Improved flag completers

.github/workflows/autorelease.yml

@@ -2,136 +2,90 @@ name: Release
 
 on:
   push:
-    branches: [master]
+    branches:
+      - master
+
+permissions:
+  contents: write
 
 jobs:
-  servers-build:
-    name: Release Build Server
-    if: startsWith( github.ref, 'refs/tags/v')
+  tag-check:
+    name: Check Release Tag
     runs-on: ubuntu-latest
+    timeout-minutes: 30
+    outputs:
+      tag: ${{ steps.tag.outputs.tag }}
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Find Semver Tag
+        id: tag
+        run: |
+          git fetch --prune --tags -f
+          tag=$(git tag --points-at "$GITHUB_SHA" | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | head -n 1)
+          echo "tag=$tag" >> "$GITHUB_OUTPUT"
+
+  release:
+    name: Release
+    needs: tag-check
+    if: needs.tag-check.outputs.tag != ''
+    runs-on: ubuntu-latest
+    environment: release
     timeout-minutes: 45
     steps:
+      - name: Check Out Code
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
       - name: Go 1.25
         uses: actions/setup-go@v6
         with:
           go-version: "^1.25"
 
-      - name: OS Packages
+      - name: Install Minisign
+        run: sudo apt-get update --fix-missing && sudo apt-get -y install minisign
+
+      - name: Build Clients
         run: |
-          sudo apt-get update --fix-missing && sudo apt-get -y install \
-          git build-essential zlib1g zlib1g-dev wget zip unzip
+          make clients
+          mkdir -p artifacts
+          mv sliver-client_* artifacts/
 
-      - name: Check Out Code
-        uses: actions/checkout@v5
-
-      - name: Git Fetch Tags
-        run: git fetch --prune --unshallow --tags -f
-
-      - name: Make
-        run: make servers
-
-      - name: Server Artifacts
-        uses: actions/upload-artifact@v5
-        with:
-          name: servers
-          path: ./sliver-server_*
-
-  clients-build:
-    name: Release Build Client
-    if: startsWith( github.ref, 'refs/tags/v')
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    steps:
-      - name: Go 1.25
-        uses: actions/setup-go@v6
-        with:
-          go-version: "^1.25"
-
-      - name: Check Out Code
-        uses: actions/checkout@v5
-
-      - name: Git Fetch Tags
-        run: git fetch --prune --unshallow --tags -f
-
-      - name: Make
-        run: make clients
-
-      - name: Client Artifacts
-        uses: actions/upload-artifact@v5
-        with:
-          name: clients
-          path: ./sliver-client_*
-
-  tagged-release:
-    needs: [servers-build, clients-build]
-
-    name: "Tagged Release"
-    if: startsWith( github.ref, 'refs/tags/v')
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-
-    steps:
-      - run: mkdir -p ./builds
-      - uses: actions/download-artifact@v6
-        with:
-          path: ./builds
-
-      - name: Extract Artifacts
+      - name: Build Servers
         run: |
-          mkdir -p ./artifacts
-          cp ./builds/clients/* ./artifacts
-          cp ./builds/servers/* ./artifacts
+          make servers
+          mv sliver-server_* artifacts/
 
-      - name: GPG Key(s)
+      - name: Sign Artifacts
+        env:
+          MINISIGN_KEY: ${{ secrets.MINISIGN_SLIVER_RELEASE_KEY }}
         run: |
-          cat <(echo -e "${{ secrets.SLIVER_GPG }}") | gpg --batch --import
-          gpg --list-secret-keys --keyid-format LONG
+          echo "$MINISIGN_KEY" | base64 -d > minisign.key
+          echo "minisign.key bytes: $(wc -c < minisign.key | tr -d ' ')"
+          echo "minisign.key sha256: $(sha256sum minisign.key | awk '{print $1}')"
+          chmod 600 minisign.key
+          for file in artifacts/sliver-*; do
+            [ -f "$file" ] || continue
+            minisign -S -s minisign.key -m "$file" -x "$file.minisig" -W
+          done
+          rm -f minisign.key
 
-      # Linux
-      - name: Linux 386 (Client Only)
+      - name: Create Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         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
+          tag="${{ needs.tag-check.outputs.tag }}"
+          if gh release view "$tag" >/dev/null 2>&1; then
+            echo "Release $tag already exists."
+            exit 0
+          fi
+          gh release create "$tag" --generate-notes
 
-      # 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
-
-      # MacOS
-      - 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
-      - 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:
-          files: |
-            ./artifacts/*
+      - name: Upload Artifacts
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh release upload "${{ needs.tag-check.outputs.tag }}" artifacts/* --clobber

.github/workflows/codeql-scanning.yml

@@ -22,7 +22,7 @@ jobs:
           go-version: "^1.25"
 
       - name: Checkout repository
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         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.
@@ -36,7 +36,7 @@ jobs:
           git build-essential zlib1g zlib1g-dev wget zip unzip
 
       - name: Check Out Code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v4

.github/workflows/docs.yml

@@ -35,7 +35,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Detect package manager
         id: detect-package-manager
@@ -66,7 +66,7 @@ jobs:
         uses: actions/configure-pages@v5
 
       - name: Restore cache
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: |
             .next/cache

.github/workflows/unit-tests.yml

@@ -34,7 +34,7 @@ jobs:
           git build-essential zlib1g zlib1g-dev wget zip unzip
 
       - name: Check Out Code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Git Fetch Tags
         run: git fetch --prune --unshallow --tags -f
@@ -63,7 +63,7 @@ jobs:
           go-version: "^1.25"
 
       - name: Check Out Code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Git Fetch Tags
         run: git fetch --prune --unshallow --tags -f
@@ -88,7 +88,7 @@ jobs:
           go-version: "^1.25"
 
       - name: Check Out Code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Git Fetch Tags
         run: git fetch --prune --unshallow --tags -f

.gitignore

@@ -2,6 +2,11 @@
 /.devcontainer
 /.idea
 
+/artifacts
+/artifacts/**
+
+*.rc
+
 /Dockerfile.*
 /*.sdk.tar.xz
 

AGENTS.md

@@ -1,23 +1,41 @@
 # Repository Guidelines
 
 ## Project Structure & Module Organization
-Sliver is a Go monorepo. Core client code lives in `client/` (CLI, assets, transports) and server code in `server/` (C2 services, assets, configs). `implant/` holds implant payload sources, while `util/` provides shared helpers that must stay server-side. Protocol buffers live under `protobuf/`, and documentation assets are in `docs/`. Keep generated artifacts (e.g., `sliver-client`, `sliver-server`, `.downloaded_assets`) out of commits.
+- `client/` holds the CLI client and interactive commands.
+- `server/` contains the server runtime, C2 logic, configs, and web assets.
+- `implant/` is the implant runtime and transport implementations.
+- `protobuf/` stores protobuf definitions and generated Go types.
+- `util/` is shared helpers (crypto, encoders, minisign, etc.).
+- `docs/sliver-docs/` is the Next.js documentation site and prebuild scripts.
+- `vendor/` is the vendored Go dependency tree used by builds.
+- Build outputs land in the repo root as `sliver-client*` and `sliver-server*`.
 
 ## Build, Test, and Development Commands
-Use `make` targets to stay consistent:
-- `make` (or `make default`) compiles client/server binaries with vendored modules and tag defaults.
-- `make client` and `make linux-amd64` build platform-specific emitters; prefer `GOOS/GOARCH` env vars over editing sources.
-- `./go-assets.sh` refreshes client asset bundles; rerun when static files change.
-Regenerate protobuf bindings with `make pb`. For quick checks, `GOFLAGS="-tags client" go build ./client/...` is acceptable, but ensure the matching `server` build also succeeds.
+- `make` builds server + client using vendored modules and runs `go-assets.sh`.
+- `make client` builds a CGO-free client; `make debug` keeps symbols.
+- `make pb` regenerates protobuf stubs from `protobuf/`.
+- `./go-tests.sh` runs the curated Go test suite with build tags.
+- Docs site: `cd docs/sliver-docs && npm install && npm run dev` for local dev; `npm run build` for a static build.
+- Go toolchain: the Makefile enforces Go >= 1.24.
 
 ## Coding Style & Naming Conventions
-Target Go 1.22+ (see `Makefile` validation). Format code with `gofmt` or `goimports` before committing. Keep package imports segregated (stdlib, third-party, internal). Use lower_snake filenames for assets, PascalCase for exported Go symbols, and prefer explicit names (`sessionID`, `operatorConfig`) over abbreviations. Never import `server` packages inside `client`. Avoid introducing CGO unless justified for cross-platform support.
+- Run `gofmt` on all Go code; keep package names lowercase and idiomatic.
+- Avoid `CGO` and empty interfaces; prefer explicit types and interfaces.
+- Do not import `server` packages from `client`.
+- If `math/rand` is required, import it as `insecureRand` and avoid security use.
 
 ## Testing Guidelines
-Run targeted unit tests with Go’s tooling and project tags, e.g. `go test -tags=client,go_sqlite ./client/command/...`. Full coverage uses `./build.py`; expect long runtimes and ensure ample CPU/RAM. Add tests beside code (`*_test.go`) and mirror package paths. When adding transports or implants, verify integration logs under `~/.sliver/logs/` for regressions and clean up fixtures.
+- Go tests follow standard `_test.go` naming within each package.
+- Prefer `docker build --target test --build-arg GO_TESTS_FLAGS=--skip-generate .` 
+- Add or update tests when behavior changes; some server packages run longer tests.
 
 ## Commit & Pull Request Guidelines
-Sign every commit (`git commit -S`) and write imperative, scoped messages ("Fix DNS canary retry" rather than status updates). Keep vendor updates isolated in their own commit. Pull requests should describe the intent, affected modules, testing performed, and reference GitHub issues. Include before/after screenshots only when UI behavior changes (client console). Ensure CI passes and note any required follow-up.
+- Commits must be signed for PRs to `master`; work in a feature branch.
+- Commit subjects are short and imperative (e.g., "Fix ...", "Add ...", "Update ...", "Bump ...").
+- Changes to `vendor/` should be in a distinct commit.
+- PRs should link the tracking issue, note tests run, and confirm `gofmt` plus unit tests as applicable.
 
-## Security & Configuration Tips
-Default to secure settings: avoid `math/rand` for secrets, prefer vetted crypto (AES-GCM, Curve25519) per `CONTRIBUTING.md`. Lock down file permissions for generated assets and redact secrets from logs. When touching configuration, favor secure defaults even if it means additional setup for operators.
+## Security Notes
+- Default to secure configuration; fail closed rather than open.
+- Avoid insecure algorithms (MD5/SHA1/AES-ECB); prefer AES-GCM and modern curves.
+- Treat user input as untrusted: canonicalize paths and use restrictive file permissions.

Dockerfile

@@ -5,6 +5,7 @@
 #
 # For unit testing:
 #   docker build --target test .
+#   docker build --target test --build-arg GO_TESTS_FLAGS=--skip-generate .
 #
 
 # STAGE: base
@@ -31,6 +32,9 @@ RUN cp -vv sliver-server /opt/sliver-server
 ## Use `--target test` in the docker build command to run this stage
 FROM base AS test
 
+ARG GO_TESTS_FLAGS=""
+ENV GO_TESTS_FLAGS="${GO_TESTS_FLAGS}"
+
 RUN apt-get update --fix-missing \
     && apt-get -y upgrade \
     && apt-get -y install \
@@ -39,7 +43,7 @@ RUN apt-get update --fix-missing \
 RUN /opt/sliver-server unpack --force 
 
 ### Run unit tests
-RUN /go/src/github.com/bishopfox/sliver/go-tests.sh
+RUN /go/src/github.com/bishopfox/sliver/go-tests.sh ${GO_TESTS_FLAGS}
 
 # STAGE: production
 ## Final dockerized form of Sliver

Makefile

@@ -16,49 +16,29 @@ endif
 # Prerequisites 
 #
 # https://stackoverflow.com/questions/5618615/check-if-a-program-exists-from-a-makefile
-EXECUTABLES = uname sed git zip date cut $(GO)
+EXECUTABLES = uname sed git date cut $(GO)
 K := $(foreach exec,$(EXECUTABLES),\
         $(if $(shell which $(exec)),some string,$(error "No $(exec) in PATH")))
 
 #
-# Version Information
+# Build Information
 #
-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 = 24
 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_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
 
-GIT_DIRTY = $(shell git diff --quiet|| echo 'Dirty')
-GIT_COMMIT = $(shell git rev-parse HEAD)
-
 LDFLAGS = -ldflags "-s -w \
-	-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).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
 
 # Debug builds shouldn't be stripped (-s -w flags)
-LDFLAGS_DEBUG = -ldflags "-X $(VERSION_PKG).Version=$(VERSION) \
-	-X \"$(VERSION_PKG).GoVersion=$(GO_VERSION)\" \
-	-X $(VERSION_PKG).CompiledAt=$(COMPILED_AT) \
-	-X $(VERSION_PKG).GithubReleasesURL=$(RELEASES_URL) \
-	-X $(VERSION_PKG).GitCommit=$(GIT_COMMIT) \
-	-X $(VERSION_PKG).GitDirty=$(GIT_DIRTY) \
-	-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) \
+LDFLAGS_DEBUG = -ldflags "-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) \
 	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
 
 SED_INPLACE := sed -i
@@ -83,7 +63,9 @@ endif
 # If no target is specified, determine GOARCH
 ifeq ($(UNAME_P),arm)
 	ifeq ($(MAKECMDGOALS), )
-		ENV += GOARCH=arm64
+		ifeq ($(origin GOARCH), undefined)
+			ENV += GOARCH=arm64
+		endif
 	endif
 endif
 
@@ -91,12 +73,6 @@ ifeq ($(MAKECMDGOALS), linux)
 	# Redefine LDFLAGS to add the static part
 	LDFLAGS = -ldflags "-s -w \
 		-extldflags '-static' \
-		-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).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
 endif
@@ -105,9 +81,10 @@ 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
+default: clean validate-go-version
+	env -u GOOS -u GOARCH $(MAKE) GOOS= GOARCH= .downloaded_assets
+	$(ENV) $(if $(GOOS),GOOS=$(GOOS)) $(if $(GOARCH),GOARCH=$(GOARCH)) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	$(ENV) $(if $(GOOS),GOOS=$(GOOS)) $(if $(GOARCH),GOARCH=$(GOARCH)) CGO_ENABLED=0 $(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.
@@ -154,8 +131,9 @@ clients: clean .downloaded_assets validate-go-version
 	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: 
+servers: clean .downloaded_assets validate-go-version
 	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=windows GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_windows-arm64$(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
@@ -199,5 +177,5 @@ clean:
 	rm -f sliver-client sliver-client_* sliver-server sliver-server_* sliver-*.exe
 
 .downloaded_assets:
-	./go-assets.sh
+	$(ENV) $(GO) run -mod=vendor ./util/cmd/assets
 	touch ./.downloaded_assets

README.md

@@ -6,12 +6,6 @@ The server and client support MacOS, Windows, and Linux. Implants are supported
 
 [![Release](https://github.com/BishopFox/sliver/actions/workflows/autorelease.yml/badge.svg)](https://github.com/BishopFox/sliver/actions/workflows/autorelease.yml) [![Go Report Card](https://goreportcard.com/badge/github.com/BishopFox/sliver)](https://goreportcard.com/report/github.com/BishopFox/sliver) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 
-# v1.6.0 / `master`
-
-**NOTE:** You are looking at the latest master branch of Sliver v1.6.0; new PRs should target this branch. However, this branch is NOT RECOMMENDED for production use yet. Please use release tagged versions for the best experience.
-
-For PRs containing bug fixes specific to Sliver v1.5, please target the [`v1.5.x/master` branch](https://github.com/BishopFox/sliver/tree/v1.5.x/master).
-
 ### Features
 
 - Dynamic code generation
@@ -21,7 +15,7 @@ For PRs containing bug fixes specific to Sliver v1.5, please target the [`v1.5.x
 - [Procedurally generated C2](https://sliver.sh/docs?name=HTTPS+C2) over HTTP(S)
 - [DNS canary](https://sliver.sh/docs?name=DNS+C2) blue team detection
 - [Secure C2](https://sliver.sh/docs?name=Transport+Encryption) over mTLS, WireGuard, HTTP(S), and DNS
-- Fully scriptable using [JavaScript/TypeScript](https://github.com/moloch--/sliver-script) or [Python](https://github.com/moloch--/sliver-py)
+- Fully scriptable using [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
@@ -39,16 +33,14 @@ Download the latest [release](https://github.com/BishopFox/sliver/releases) and
 
 ### Help!
 
-Please checkout the [wiki](https://sliver.sh/), or start a [GitHub discussion](https://github.com/BishopFox/sliver/discussions). We also tend to hang out in the #golang Slack channel on the [Bloodhound Gang](https://bloodhoundgang.herokuapp.com/) server.
+Please checkout the [wiki](https://sliver.sh/), or start a [GitHub discussion](https://github.com/BishopFox/sliver/discussions).
 
 ### Compile From Source
 
 See the [wiki](https://sliver.sh/docs?name=Compile+from+Source).
 
-### Feedback
-
-Please take a moment and fill out [our survey](https://forms.gle/SwVsHFNh24ChG58C6).
-
 ### 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.
+
+

build.py

@@ -1,135 +0,0 @@
-#!/usr/bin/env python3
-"""
-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 os
-import sys
-import argparse
-
-INFO = "\033[1m\033[36m[*]\033[0m "
-WARN = "\033[1m\033[31m[!]\033[0m "
-BOLD = "\033[1m"
-NORM = "\033[0m"
-
-
-def exec_cmd(cmd, ignore_status=False):
-    """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":
-            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 --target test .")
-    if status == 0:
-        print("\n\n" + INFO + "Build successful")
-
-
-def main(args):
-    """Execute the respective task(s) based on cli args"""
-    if args.rm_images:
-        docker_rm_images()
-    if args.rm_containers:
-        docker_rm_containers()
-    if args.rm_volumes:
-        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")
-
-    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",
-    )
-    try:
-        main(parser.parse_args())
-    except KeyboardInterrupt:
-        print("\n\n" + WARN + "User stopped process")

client/assets/assets.go

@@ -73,6 +73,18 @@ func GetConsoleLogsDir() string {
 	return consoleLogsDir
 }
 
+// GetMCPLogsDir - Get the Sliver client MCP logs dir ~/.sliver-client/logs/mcp/
+func GetMCPLogsDir() string {
+	mcpLogsDir := filepath.Join(GetClientLogsDir(), "mcp")
+	if _, err := os.Stat(mcpLogsDir); os.IsNotExist(err) {
+		err = os.MkdirAll(mcpLogsDir, 0700)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return mcpLogsDir
+}
+
 func assetVersion() string {
 	appDir := GetRootAppDir()
 	data, err := os.ReadFile(filepath.Join(appDir, versionFileName))

client/cli/cli.go

@@ -51,6 +51,7 @@ func init() {
 	defer logFile.Close()
 
 	rootCmd.TraverseChildren = true
+	rootCmd.Flags().String(RCFlagName, "", "path to rc script file")
 
 	// 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
@@ -69,6 +70,9 @@ func init() {
 	// other command trees below, such as the implant one.
 	rootCmd.AddCommand(consoleCmd(con))
 
+	// MCP stdio server.
+	rootCmd.AddCommand(mcpCmd(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

client/cli/config.go

@@ -23,7 +23,7 @@ import (
 	"sort"
 
 	"github.com/bishopfox/sliver/client/assets"
-	"gopkg.in/AlecAivazis/survey.v1"
+	"github.com/bishopfox/sliver/client/forms"
 )
 
 func selectConfig() *assets.ClientConfig {
@@ -39,32 +39,18 @@ func selectConfig() *assets.ClientConfig {
 		}
 	}
 
-	answer := struct{ Config string }{}
-	qs := getPromptForConfigs(configs)
-	err := survey.Ask(qs, &answer)
+	keys := make([]string, 0, len(configs))
+	for key := range configs {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	selection := keys[0]
+	err := forms.Select("Select a server:", keys, &selection)
 	if err != nil {
 		fmt.Println(err.Error())
 		return nil
 	}
 
-	return configs[answer.Config]
-}
-
-func getPromptForConfigs(configs map[string]*assets.ClientConfig) []*survey.Question {
-	keys := []string{}
-	for k := range configs {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	return []*survey.Question{
-		{
-			Name: "config",
-			Prompt: &survey.Select{
-				Message: "Select a server:",
-				Options: keys,
-				Default: keys[0],
-			},
-		},
-	}
+	return configs[selection]
 }

client/cli/console.go

@@ -40,6 +40,7 @@ func consoleCmd(con *console.SliverClient) *cobra.Command {
 		Short: "Start the sliver client console",
 	}
 
+	consoleCmd.Flags().String(RCFlagName, "", "path to rc script file")
 	consoleCmd.RunE, consoleCmd.PersistentPostRunE = consoleRunnerCmd(con, true)
 	return consoleCmd
 }
@@ -47,7 +48,7 @@ func consoleCmd(con *console.SliverClient) *cobra.Command {
 func consoleRunnerCmd(con *console.SliverClient, run bool) (pre, post func(cmd *cobra.Command, args []string) error) {
 	var ln *grpc.ClientConn
 
-	pre = func(_ *cobra.Command, _ []string) error {
+	pre = func(cmd *cobra.Command, _ []string) error {
 
 		configs := assets.GetConfigs()
 		if len(configs) == 0 {
@@ -59,13 +60,18 @@ func consoleRunnerCmd(con *console.SliverClient, run bool) (pre, post func(cmd *
 			return nil
 		}
 
+		rcScript, err := ReadRCScript(cmd)
+		if err != nil {
+			fmt.Printf("Failed to read rc script: %s\n", err)
+			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 {
@@ -76,7 +82,7 @@ func consoleRunnerCmd(con *console.SliverClient, run bool) (pre, post func(cmd *
 		// Wait for any connection state changes and exit if the connection is lost.
 		go handleConnectionLost(ln)
 
-		return console.StartClient(con, rpc, command.ServerCommands(con, nil), command.SliverCommands(con), run)
+		return console.StartClient(con, rpc, command.ServerCommands(con, nil), command.SliverCommands(con), run, rcScript)
 	}
 
 	// Close the RPC connection once exiting

client/cli/mcp.go

@@ -0,0 +1,94 @@
+package cli
+
+/*
+	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 (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/console"
+	clientmcp "github.com/bishopfox/sliver/client/mcp"
+	"github.com/bishopfox/sliver/client/transport"
+	"github.com/spf13/cobra"
+)
+
+func mcpCmd(con *console.SliverClient) *cobra.Command {
+	mcpCmd := &cobra.Command{
+		Use:   "mcp",
+		Short: "Start the MCP stdio server",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runMCP(cmd, con)
+		},
+	}
+	mcpCmd.Flags().String("config", "", "path to client config file")
+	return mcpCmd
+}
+
+func runMCP(cmd *cobra.Command, con *console.SliverClient) error {
+	configPath, _ := cmd.Flags().GetString("config")
+	config, err := loadMCPClientConfig(configPath)
+	if err != nil {
+		fmt.Printf("%s\n", err)
+		return nil
+	}
+
+	rpc, ln, err := transport.MTLSConnect(config)
+	if err != nil {
+		fmt.Printf("Connection to server failed %s\n", err)
+		return nil
+	}
+	defer ln.Close()
+
+	con.Rpc = rpc
+	go handleConnectionLost(ln)
+
+	cfg := clientmcp.DefaultConfig()
+	if err := clientmcp.ServeStdio(cfg, con.Rpc); err != nil {
+		fmt.Printf("MCP server error: %s\n", err)
+		return nil
+	}
+	return nil
+}
+
+func loadMCPClientConfig(path string) (*assets.ClientConfig, error) {
+	if path != "" {
+		configPath := path
+		if !filepath.IsAbs(configPath) {
+			if _, err := os.Stat(configPath); err != nil {
+				configPath = filepath.Join(assets.GetConfigDir(), configPath)
+			}
+		}
+		return assets.ReadConfig(configPath)
+	}
+
+	configs := assets.GetConfigs()
+	switch len(configs) {
+	case 0:
+		return nil, fmt.Errorf("no config files found at %s (use --config)", assets.GetConfigDir())
+	case 1:
+		for _, config := range configs {
+			return config, nil
+		}
+	default:
+		return nil, fmt.Errorf("multiple configs found; use --config to select one")
+	}
+	return nil, fmt.Errorf("no config files found")
+}

client/cli/rc.go

@@ -0,0 +1,31 @@
+package cli
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+const RCFlagName = "rc"
+
+func ReadRCScript(cmd *cobra.Command) (string, error) {
+	if cmd == nil {
+		return "", nil
+	}
+	if cmd.Flags().Lookup(RCFlagName) == nil {
+		return "", nil
+	}
+	rcPath, err := cmd.Flags().GetString(RCFlagName)
+	if err != nil {
+		return "", err
+	}
+	if rcPath == "" {
+		return "", nil
+	}
+	data, err := os.ReadFile(rcPath)
+	if err != nil {
+		return "", fmt.Errorf("read rc script %q: %w", rcPath, err)
+	}
+	return string(data), nil
+}

client/command/README.md

@@ -8,7 +8,7 @@ Shared registration glue, scaffolding, and helpers for Sliver client console com
 
 - `command.go` – Provides helpers for binding Cobra commands, flag sets, and visibility filters into the client command tree.
 - `server.go` – Defines the server menu composition, wiring each server-side command group onto the root console structure at runtime.
-- `sliver.go` – Builds the implant/Sliver menu, attaching per-target command groups and loading alias/extension manifests before exposure.
+- `main.go` – Builds the implant/Sliver menu, attaching per-target command groups and loading alias/extension manifests before exposure.
 
 ## Sub-packages
 
@@ -40,6 +40,7 @@ Shared registration glue, scaffolding, and helpers for Sliver client console com
 - `licenses/` – Implements the 'licenses' command group for the Sliver client console.
 - `loot/` – Implements the 'loot' command group for the Sliver client console.
 - `monitor/` – Implements the 'monitor' command group for the Sliver client console.
+- `mcp/` – Implements the 'mcp' command group for the Sliver client console.
 - `network/` – Implements the 'network' command group for the Sliver client console.
 - `operators/` – Implements the 'operators' command group for the Sliver client console.
 - `pivots/` – Implements the 'pivots' command group for the Sliver client console.

client/command/aka/README.md

@@ -0,0 +1,23 @@
+# client/command/aka
+
+## Overview
+
+Implements the 'aka' command group for the Sliver client console. "Aka"s are
+command aliases (like 'alias' in 'bash') that allow operators to specify
+shorthand commands and default arguments for commonly used commands.
+
+### Examples:
+
+- `aka create bg background`: Allows an operator to run `bg` from the implant 
+menu to quickly move back to the server menu
+- `aka create execw execute -o "C:\Windows\System32\cmd.exe" /c`: Shorthand for
+  executing binaries on Windows targets like: `execw arp -a`
+
+## Go Files
+
+- `commands.go` – Wires Cobra commands for listing, creating, and deleting command aliases in the client console.
+- `create.go` – Handles creating command aliases to use by the client.
+- `delete.go` – Removes command aliases currently tracked by the client. 
+- `hook.go` – The main hooking logic to intercept commands ran by the client console. The hook will intercept processing before hitting the Cobra tree to transform the command alias to a full command with default arguments from the command alias and user-provided arguments to the alias.
+- `list.go` - Lists the current command aliases tracked by the client.
+- `storage.go` - Supports the saving of aliases to disk to keep between runs of the client. 

client/command/aka/commands.go

@@ -0,0 +1,59 @@
+package aka
+
+import (
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/constants"
+	"github.com/spf13/cobra"
+)
+
+func ServerCommands(con *console.SliverClient) []*cobra.Command {
+	return commands(con, constants.GenericHelpGroup)
+}
+
+func ImplantCommands(con *console.SliverClient) []*cobra.Command {
+	return commands(con, constants.SliverCoreHelpGroup)
+}
+
+func commands(con *console.SliverClient, group string) []*cobra.Command {
+	akaCommand := &cobra.Command{
+		Use:   "aka",
+		Short: "Manage command aliases (aka's)",
+		Run: func(cmd *cobra.Command, args []string) {
+			AkaListCmd(cmd, con, args)
+		},
+		GroupID: group,
+	}
+
+	createAka := &cobra.Command{
+		Use:                   "create <alias> <command> [args...]",
+		Short:                 "Create a new command alias (aka)",
+		Args:                  cobra.MinimumNArgs(2),
+		DisableFlagParsing:    true, // No flags with aka create so we capture flags to other commands
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			AkaCreateCmd(cmd, con, args)
+		},
+	}
+	createAka.InitDefaultHelpFlag()
+	createAka.Flags().Lookup("help").Hidden = true
+	akaCommand.AddCommand(createAka)
+
+	deleteAka := &cobra.Command{
+		Use:   "delete <alias>",
+		Short: "Delete a command alias (aka)",
+		Args:  cobra.MinimumNArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			AkaDeleteCmd(cmd, con, args)
+		},
+	}
+	akaCommand.AddCommand(deleteAka)
+
+	con.App.PreCmdRunLineHooks = append(con.App.PreCmdRunLineHooks, Cmdhook)
+
+	err := LoadAkaAliases()
+	if err != nil {
+		con.PrintErrorf("Failed to load aka alises: %s\n", err)
+	}
+
+	return []*cobra.Command{akaCommand}
+}

client/command/aka/create.go

@@ -0,0 +1,46 @@
+package aka
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/spf13/cobra"
+)
+
+func AkaCreateCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	aliasName := args[0]
+	command := args[1]
+	defaultArgs := args[2:] // anything else is going to be the default args to the alias
+
+	if _, exists := akaAliases[aliasName]; exists {
+		con.PrintErrorf("Alias '%s' already exists\n", aliasName)
+		return
+	}
+
+	var desc string
+	if len(defaultArgs) == 0 {
+		desc = fmt.Sprintf("%s", command)
+	} else {
+		desc = fmt.Sprintf("%s %s", command, strings.Join(defaultArgs, " "))
+	}
+
+	alias := &AkaAlias{
+		Name:        aliasName,
+		Command:     command,
+		DefaultArgs: defaultArgs,
+		Description: desc,
+	}
+
+	akaAliases[aliasName] = alias
+
+	// save this new alias to disk
+	err := SaveAkaAliases()
+	if err != nil {
+		con.PrintErrorf("Failed to save alias '%s' to disk: %s\n", aliasName, err)
+		// we still technically added it to the map, so the alias did get created in
+		// memory so we should still print the Info message below
+	}
+
+	con.PrintInfof("Create alias for '%s' -> '%v'\n", aliasName, alias.Description)
+}

client/command/aka/delete.go

@@ -0,0 +1,25 @@
+package aka
+
+import (
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/spf13/cobra"
+)
+
+func AkaDeleteCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	aliasName := args[0]
+	if _, exists := akaAliases[aliasName]; !exists {
+		con.PrintErrorf("Alias '%s' does not exist\n", aliasName)
+		return
+	}
+
+	delete(akaAliases, aliasName)
+
+	// Save updated map to disk
+	err := SaveAkaAliases()
+	if err != nil {
+		con.PrintErrorf("Failed to save aliases to disk: %s\n", err)
+		return
+	}
+
+	con.PrintInfof("Deleted alias '%s'\n", aliasName)
+}

client/command/aka/hook.go

@@ -0,0 +1,27 @@
+package aka
+
+import (
+	"strings"
+)
+
+func Cmdhook(args []string) ([]string, error) {
+	if len(args) == 0 {
+		return args, nil
+	}
+
+	if aliasArgs, exists := akaAliases[args[0]]; exists {
+		var expandedArgs []string
+
+		expandedArgs = append(expandedArgs, aliasArgs.Command)
+		expandedArgs = append(expandedArgs, aliasArgs.DefaultArgs...)
+		// join the user passed args so the shell processes it without flags if
+		// available
+		if len(args[1:]) > 0 {
+			expandedArgs = append(expandedArgs, strings.Join(args[1:], " "))
+		}
+
+		return expandedArgs, nil
+	}
+
+	return args, nil
+}

client/command/aka/list.go

@@ -0,0 +1,31 @@
+package aka
+
+import (
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+)
+
+func AkaListCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	if len(akaAliases) == 0 {
+		con.PrintInfof("No command aliases created. Use `aka create` to create one.\n")
+		return
+	}
+
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Alias",
+		"Command",
+	})
+
+	for alias, cmd := range akaAliases {
+		tw.AppendRow(table.Row{
+			alias,
+			cmd.Description,
+		})
+	}
+
+	con.Printf("%s\n", tw.Render())
+}

client/command/aka/storage.go

@@ -0,0 +1,68 @@
+package aka
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+
+	"github.com/bishopfox/sliver/client/assets"
+)
+
+type AkaAlias struct {
+	Name        string   `json:"name"`         // alias Name
+	Command     string   `json:"command"`      // command being aliased
+	DefaultArgs []string `json:"default_args"` // args passed by the user
+	Description string   `json:"description"`
+}
+
+var akaAliases = make(map[string]*AkaAlias)
+
+const (
+	akaAliasFileName = "aka-aliases.json"
+)
+
+func GetAkaAliasesFilePath() string {
+	return filepath.Join(assets.GetRootAppDir(), akaAliasFileName)
+}
+
+func LoadAkaAliases() error {
+	filepath := GetAkaAliasesFilePath()
+	data, err := os.ReadFile(filepath)
+	if err != nil {
+		// if file hasn't been created yet, we fail gracefully
+		if os.IsNotExist(err) {
+			return nil
+		}
+		// otherwise, return the actual error; something else went wrong
+		return err
+	}
+
+	aliases := []AkaAlias{}
+	err = json.Unmarshal(data, &aliases)
+	if err != nil {
+		return err
+	}
+
+	akaAliases = make(map[string]*AkaAlias)
+
+	for _, alias := range aliases {
+		akaAliases[alias.Name] = &alias
+	}
+
+	return nil
+}
+
+func SaveAkaAliases() error {
+	filepath := GetAkaAliasesFilePath()
+	aliases := make([]*AkaAlias, 0, len(akaAliases))
+	for _, alias := range akaAliases {
+		aliases = append(aliases, alias)
+	}
+
+	data, err := json.MarshalIndent(aliases, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(filepath, data, 0o600)
+}

client/command/alias/install.go

@@ -24,9 +24,9 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/util"
 	"github.com/spf13/cobra"
 )
@@ -62,8 +62,7 @@ func installFromDir(aliasLocalPath string, con *console.SliverClient) {
 	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
 		con.PrintInfof("Alias '%s' already exists", manifest.CommandName)
 		confirm := false
-		prompt := &survey.Confirm{Message: "Overwrite current install?"}
-		survey.AskOne(prompt, &confirm)
+		_ = forms.Confirm("Overwrite current install?", &confirm)
 		if !confirm {
 			return
 		}
@@ -122,8 +121,7 @@ func InstallFromFile(aliasGzFilePath string, aliasName string, promptToOverwrite
 		if promptToOverwrite {
 			con.PrintInfof("Alias '%s' already exists\n", manifest.CommandName)
 			confirm := false
-			prompt := &survey.Confirm{Message: "Overwrite current install?"}
-			survey.AskOne(prompt, &confirm)
+			_ = forms.Confirm("Overwrite current install?", &confirm)
 			if !confirm {
 				return nil
 			}

client/command/alias/load.go

@@ -27,15 +27,16 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/packages"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util"
+	"github.com/carapace-sh/carapace"
 	app "github.com/reeflective/console"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -76,6 +77,16 @@ type AliasFile struct {
 	Path string `json:"path"`
 }
 
+// AliasArgument - An argument for an alias command.
+type AliasArgument struct {
+	Name     string      `json:"name"`
+	Type     string      `json:"type"`
+	Desc     string      `json:"desc"`
+	Optional bool        `json:"optional"`
+	Default  interface{} `json:"default,omitempty"`
+	Choices  []string    `json:"choices,omitempty"`
+}
+
 // AliasManifest - The manifest for an alias, contains metadata.
 type AliasManifest struct {
 	Name           string `json:"name"`
@@ -89,6 +100,7 @@ type AliasManifest struct {
 	Entrypoint   string                 `json:"entrypoint"`
 	AllowArgs    bool                   `json:"allow_args"`
 	DefaultArgs  string                 `json:"default_args"`
+	Arguments    []*AliasArgument       `json:"arguments"`
 	Files        []*AliasFile           `json:"files"`
 	IsReflective bool                   `json:"is_reflective"`
 	IsAssembly   bool                   `json:"is_assembly"`
@@ -158,15 +170,60 @@ func LoadAlias(manifestPath string, cmd *cobra.Command, con *console.SliverClien
 	}
 	aliasManifest.RootPath = filepath.Dir(manifestPath)
 
+	// Build usage string including arguments
+	usage := strings.Builder{}
+	usage.WriteString(aliasManifest.CommandName)
+	for _, arg := range aliasManifest.Arguments {
+		usage.WriteString(" ")
+		if arg.Optional {
+			usage.WriteString("[")
+		}
+		usage.WriteString(strings.ToUpper(arg.Name))
+		if arg.Optional {
+			usage.WriteString("]")
+		}
+	}
+
+	// Build long help message
+	longHelp := strings.Builder{}
+	longHelp.WriteString("[[.Bold]]Command:[[.Normal]]")
+	longHelp.WriteString(usage.String())
+	longHelp.WriteString("\n")
+	if len(aliasManifest.Help) > 0 || len(aliasManifest.LongHelp) > 0 {
+		longHelp.WriteString("[[.Bold]]About:[[.Normal]]")
+		if len(aliasManifest.Help) > 0 {
+			longHelp.WriteString(aliasManifest.Help)
+			longHelp.WriteString("\n")
+		}
+		if len(aliasManifest.LongHelp) > 0 {
+			longHelp.WriteString(aliasManifest.LongHelp)
+			longHelp.WriteString("\n")
+		}
+	}
+	if len(aliasManifest.Arguments) > 0 {
+		longHelp.WriteString("[[.Bold]]Arguments:[[.Normal]]")
+		for _, arg := range aliasManifest.Arguments {
+			longHelp.WriteString("\n\t")
+			optStr := ""
+			if arg.Optional {
+				optStr = "[OPTIONAL]"
+			}
+			aType := arg.Type
+			if aType == "wstring" {
+				aType = "string"
+			}
+			longHelp.WriteString(fmt.Sprintf("%s (%s):\t%s%s", strings.ToUpper(arg.Name), aType, optStr, arg.Desc))
+		}
+	}
+	longHelp.WriteString("\n\n⚠️  If you're having issues passing arguments to the alias please read:\n")
+	longHelp.WriteString("https://github.com/BishopFox/sliver/wiki/Aliases-&-Extensions#aliases-command-parsing")
+
 	// for each alias command, add a new app command
 	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,
+		Use:   usage.String(),
 		Short: helpMsg,
-		Long:  longHelpMsg,
+		Long:  help.FormatHelpTmpl(longHelp.String()),
 		Run: func(cmd *cobra.Command, args []string) {
 			runAliasCommand(cmd, con, args)
 		},
@@ -196,6 +253,10 @@ func LoadAlias(manifestPath string, cmd *cobra.Command, con *console.SliverClien
 	f.IntP("timeout", "t", defaultTimeout, "command timeout in seconds")
 	addAliasCmd.Flags().AddFlagSet(f)
 
+	// Setup completions for alias arguments
+	comps := carapace.Gen(addAliasCmd)
+	makeAliasArgCompleter(aliasManifest, comps)
+
 	cmd.AddCommand(addAliasCmd)
 
 	// Have to use a global map here, as passing the aliasCmd
@@ -313,8 +374,7 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverClient, args []strin
 		}
 		con.PrintWarnf("%s", msgStr)
 		confirm := false
-		prompt := &survey.Confirm{Message: "Do you want to continue?"}
-		survey.AskOne(prompt, &confirm, nil)
+		_ = forms.Confirm("Do you want to continue?", &confirm)
 		if !confirm {
 			return
 		}
@@ -590,3 +650,105 @@ func makeAliasPlatformFilters(alias *AliasManifest) map[string]string {
 		app.CommandFilterKey: strings.Join(all, ","),
 	}
 }
+
+// makeAliasArgCompleter builds the positional and dash arguments completer for the alias.
+// It provides completion for:
+// 1. Positional arguments (before --)
+// 2. Flag-style arguments after -- (e.g., --target, --port)
+func makeAliasArgCompleter(alias *AliasManifest, comps *carapace.Carapace) {
+	if len(alias.Arguments) == 0 {
+		return
+	}
+
+	var actions []carapace.Action
+
+	for _, arg := range alias.Arguments {
+		var action carapace.Action
+
+		// If choices are defined, use them for completion
+		if len(arg.Choices) > 0 {
+			action = carapace.ActionValues(arg.Choices...).Tag("choices")
+		} else {
+			// Fall back to type-based completion
+			switch arg.Type {
+			case "file":
+				action = carapace.ActionFiles().Tag("alias data")
+			default:
+				action = carapace.ActionValues()
+			}
+		}
+
+		usage := fmt.Sprintf("(%s) %s", arg.Type, arg.Desc)
+		if arg.Optional {
+			usage += " (optional)"
+		}
+
+		actions = append(actions, action.Usage("%s", usage))
+	}
+
+	comps.PositionalCompletion(actions...)
+
+	// Add dash completion for flag-style arguments after --
+	// Pre-build the flag completions at registration time (not in a callback)
+	flagCompletion := makeAliasFlagNameCompletion(alias)
+
+	// Build value completions for each argument type
+	valueCompletions := make(map[string]carapace.Action)
+	for _, arg := range alias.Arguments {
+		// If choices are defined, use them for completion
+		if len(arg.Choices) > 0 {
+			valueCompletions[arg.Name] = carapace.ActionValues(arg.Choices...).Tag("choices")
+		} else {
+			// Fall back to type-based completion
+			switch arg.Type {
+			case "file":
+				valueCompletions[arg.Name] = carapace.ActionFiles().Tag("file path")
+			case "bool":
+				valueCompletions[arg.Name] = carapace.ActionValues("true", "false").Tag("boolean")
+			default:
+				valueCompletions[arg.Name] = carapace.ActionValues()
+			}
+		}
+	}
+
+	// Use DashAnyCompletion with a smart action that determines context
+	comps.DashAnyCompletion(
+		carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+			// If typing a flag (starts with -)
+			if strings.HasPrefix(c.Value, "-") {
+				return flagCompletion
+			}
+
+			// If previous arg was a flag, complete its value
+			if len(c.Args) > 0 {
+				lastArg := c.Args[len(c.Args)-1]
+				if strings.HasPrefix(lastArg, "-") {
+					flagName := strings.TrimLeft(lastArg, "-")
+					if action, ok := valueCompletions[flagName]; ok {
+						return action
+					}
+				}
+			}
+
+			// Default: show flag names
+			return flagCompletion
+		}),
+	)
+}
+
+// makeAliasFlagNameCompletion creates completion for flag names
+func makeAliasFlagNameCompletion(alias *AliasManifest) carapace.Action {
+	var results []string
+
+	for _, arg := range alias.Arguments {
+		flagName := fmt.Sprintf("--%s", arg.Name)
+		desc := arg.Desc
+		if arg.Optional {
+			desc = fmt.Sprintf("[optional] %s", desc)
+		}
+		desc = fmt.Sprintf("(%s) %s", arg.Type, desc)
+		results = append(results, flagName, desc)
+	}
+
+	return carapace.ActionValuesDescribed(results...).Tag("alias arguments")
+}

client/command/alias/remove.go

@@ -24,9 +24,9 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/spf13/cobra"
 )
 
@@ -39,8 +39,7 @@ func AliasesRemoveCmd(cmd *cobra.Command, con *console.SliverClient, args []stri
 		return
 	}
 	confirm := false
-	prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' alias?", name)}
-	survey.AskOne(prompt, &confirm)
+	_ = forms.Confirm(fmt.Sprintf("Remove '%s' alias?", name), &confirm)
 	if !confirm {
 		return
 	}

client/command/armory/commands.go

@@ -37,7 +37,7 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		Use:   consts.InstallStr,
 		Short: "Install an alias or extension",
 		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.InstallStr}),
-		Args:  cobra.ExactArgs(1),
+		Args:  cobra.RangeArgs(0, 1),
 		Run: func(cmd *cobra.Command, args []string) {
 			ArmoryInstallCmd(cmd, con, args)
 		},

client/command/armory/install.go

@@ -26,8 +26,9 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
+	"sort"
+	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/spf13/cobra"
 
 	"github.com/bishopfox/sliver/client/assets"
@@ -35,6 +36,7 @@ import (
 	"github.com/bishopfox/sliver/client/command/extensions"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/util"
 	"github.com/bishopfox/sliver/util/minisign"
 )
@@ -51,10 +53,9 @@ const (
 // ArmoryInstallCmd - The armory install command
 func ArmoryInstallCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	var promptToOverwrite bool
-	name := args[0]
-	if name == "" {
-		con.PrintErrorf("A package or bundle name is required")
-		return
+	names := []string{}
+	if len(args) > 0 {
+		names = []string{args[0]}
 	}
 	forceInstallation, err := cmd.Flags().GetBool("force")
 	if err != nil {
@@ -83,51 +84,92 @@ func ArmoryInstallCmd(cmd *cobra.Command, con *console.SliverClient, args []stri
 
 	clientConfig := parseArmoryHTTPConfig(cmd)
 	refresh(clientConfig)
-	if name == "all" {
-		aliases, extensions := packageManifestsInCache()
-		aliasCount, extCount := countUniqueCommandsFromManifests(aliases, extensions)
-		confirm := false
-		pluralAliases := "es"
-		if aliasCount == 1 {
-			pluralAliases = ""
+
+	if len(names) == 0 {
+		armoryFilterName := ""
+		if armoryPK != "" {
+			armoryFilterName = armoryName
 		}
-		pluralExtensions := "s"
-		if extCount == 1 {
-			pluralExtensions = ""
-		}
-		prompt := &survey.Confirm{
-			Message: fmt.Sprintf("Install %d alias%s and %d extension%s?",
-				aliasCount, pluralAliases, extCount, pluralExtensions,
-			),
-		}
-		survey.AskOne(prompt, &confirm)
-		if !confirm {
+		options := armoryInstallOptions(armoryPK, armoryFilterName)
+		if len(options) == 0 {
+			con.PrintInfof("No packages or bundles found\n")
 			return
 		}
-		promptToOverwrite = false
-	}
-	err = installPackageByName(name, armoryPK, forceInstallation, promptToOverwrite, clientConfig, con)
-	if err == nil {
-		return
-	}
-	if errors.Is(err, ErrPackageNotFound) {
-		bundles := bundlesInCache()
-		for _, bundle := range bundles {
-			if bundle.Name == name {
-				installBundle(bundle, armoryPK, forceInstallation, clientConfig, con)
+		result, err := forms.ArmoryInstallForm(options)
+		if err != nil {
+			if errors.Is(err, forms.ErrUserAborted) {
 				return
 			}
+			con.PrintErrorf("Armory install form failed: %s\n", err)
+			return
 		}
-		// If we have made it here, then there was not a bundle or package that matched the provided name
-		if armoryPK == "" {
-			con.PrintErrorf("No package or bundle named %q was found\n", name)
+		if len(result.SelectedNames) == 0 {
+			return
+		}
+		names = result.SelectedNames
+	}
+	if len(names) == 0 {
+		con.PrintErrorf("A package or bundle name is required")
+		return
+	}
+	if slices.Contains(names, "all") {
+		names = []string{"all"}
+	}
+
+	for _, name := range names {
+		if name == "" {
+			continue
+		}
+
+		promptOverwrite := promptToOverwrite
+		if name == "all" {
+			aliases, extensions := packageManifestsInCache()
+			aliasCount, extCount := countUniqueCommandsFromManifests(aliases, extensions)
+			confirm := false
+			pluralAliases := "es"
+			if aliasCount == 1 {
+				pluralAliases = ""
+			}
+			pluralExtensions := "s"
+			if extCount == 1 {
+				pluralExtensions = ""
+			}
+			forms.Confirm(fmt.Sprintf("Install %d alias%s and %d extension%s?",
+				aliasCount, pluralAliases, extCount, pluralExtensions,
+			), &confirm)
+			if !confirm {
+				return
+			}
+			promptOverwrite = false
+		}
+
+		err = installPackageByName(name, armoryPK, forceInstallation, promptOverwrite, clientConfig, con)
+		if err == nil {
+			continue
+		}
+		if errors.Is(err, ErrPackageNotFound) {
+			bundles := bundlesInCache()
+			for _, bundle := range bundles {
+				if bundle.Name == name {
+					installBundle(bundle, armoryPK, forceInstallation, clientConfig, con)
+					err = nil
+					break
+				}
+			}
+			if err == nil {
+				continue
+			}
+			// If we have made it here, then there was not a bundle or package that matched the provided name
+			if armoryPK == "" {
+				con.PrintErrorf("No package or bundle named %q was found\n", name)
+			} else {
+				con.PrintErrorf("No package or bundle named %q was found in armory %s\n", name, armoryName)
+			}
+		} else if errors.Is(err, ErrPackageAlreadyInstalled) {
+			con.PrintErrorf("Package %q is already installed - use the force option to overwrite it\n", name)
 		} else {
-			con.PrintErrorf("No package or bundle named %q was found in armory %s\n", name, armoryName)
+			con.PrintErrorf("Could not install package: %s\n", err)
 		}
-	} else if errors.Is(err, ErrPackageAlreadyInstalled) {
-		con.PrintErrorf("Package %q is already installed - use the force option to overwrite it\n", name)
-	} else {
-		con.PrintErrorf("Could not install package: %s\n", err)
 	}
 
 }
@@ -232,19 +274,22 @@ func getInstalledPackageNames() []string {
 }
 
 // This is a convenience function to get the names of the commands in the cache
-func getCommandsInCache() []string {
+func getCommandsInCache(armoryPK string) []string {
 	commandNames := []string{}
 
 	pkgCache.Range(func(key, value interface{}) bool {
 		cacheEntry := value.(pkgCacheEntry)
 		if cacheEntry.LastErr == nil {
+			if armoryPK != "" && cacheEntry.ArmoryConfig.PublicKey != armoryPK {
+				return true
+			}
 			if cacheEntry.Pkg.IsAlias {
-				if !slices.Contains(commandNames, cacheEntry.Alias.CommandName) {
+				if cacheEntry.Alias.CommandName != "" && !slices.Contains(commandNames, cacheEntry.Alias.CommandName) {
 					commandNames = append(commandNames, cacheEntry.Alias.CommandName)
 				}
 			} else {
 				for _, command := range cacheEntry.Extension.ExtCommand {
-					if !slices.Contains(commandNames, command.CommandName) {
+					if command.CommandName != "" && !slices.Contains(commandNames, command.CommandName) {
 						commandNames = append(commandNames, command.CommandName)
 					}
 				}
@@ -296,11 +341,7 @@ func getPackageIDFromUser(name string, options map[string]string) string {
 	// Add a cancel option
 	optionKeys = append(optionKeys, doNotInstallOption)
 	options[doNotInstallOption] = doNotInstallPackageName
-	prompt := &survey.Select{
-		Message: fmt.Sprintf("More than one package contains the command %s. Please choose an option from the list below:", name),
-		Options: optionKeys,
-	}
-	survey.AskOne(prompt, &selectedPackageKey)
+	forms.Select(fmt.Sprintf("More than one package contains the command %s. Please choose an option from the list below:", name), optionKeys, &selectedPackageKey)
 	selectedPackageID := options[selectedPackageKey]
 
 	return selectedPackageID
@@ -360,7 +401,7 @@ func buildInstallList(name, armoryPK string, forceInstallation bool, pendingPack
 	var requestedPackageList []string
 	if name == "all" {
 		requestedPackageList = []string{}
-		allCommands := getCommandsInCache()
+		allCommands := getCommandsInCache(armoryPK)
 		for _, cmdName := range allCommands {
 			if !slices.Contains(installedPackages, cmdName) || forceInstallation {
 				// Check to see if there is a package pending with that name
@@ -420,6 +461,15 @@ func installPackageByName(name, armoryPK string, forceInstallation, promptToOver
 	if err != nil {
 		return err
 	}
+	if len(packageInstallList) == 0 && name == "all" {
+		availableCommands := getCommandsInCache(armoryPK)
+		if len(availableCommands) == 0 {
+			con.PrintInfof("No packages or bundles found\n")
+		} else {
+			con.PrintInfof("All available packages are already installed\n")
+		}
+		return nil
+	}
 	if len(packageInstallList) > 0 {
 		for _, packageID := range packageInstallList {
 			entry := packageCacheLookupByID(packageID)
@@ -444,12 +494,114 @@ func installPackageByName(name, armoryPK string, forceInstallation, promptToOver
 
 	if name == "all" {
 		con.Printf("\n")
-		con.PrintInfof("Operation complete\n")
+		con.PrintSuccessf("Operation complete\n")
 	}
 
 	return nil
 }
 
+func armoryInstallOptions(armoryPK, armoryName string) []forms.ArmoryInstallOption {
+	options := []forms.ArmoryInstallOption{}
+	seen := make(map[string]bool)
+	packageCount := 0
+
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry, ok := value.(pkgCacheEntry)
+		if !ok {
+			return true
+		}
+		if cacheEntry.LastErr != nil {
+			return true
+		}
+		if armoryPK != "" && cacheEntry.ArmoryConfig.PublicKey != armoryPK {
+			return true
+		}
+
+		if cacheEntry.Pkg.IsAlias {
+			name := cacheEntry.Alias.CommandName
+			if name == "" {
+				return true
+			}
+			if seen[name] {
+				return true
+			}
+			label := formatArmoryInstallLabel("alias", name, cacheEntry.Alias.Help)
+			options = append(options, forms.ArmoryInstallOption{
+				Value: name,
+				Label: label,
+			})
+			seen[name] = true
+			packageCount++
+			return true
+		}
+
+		for _, command := range cacheEntry.Extension.ExtCommand {
+			name := command.CommandName
+			if name == "" {
+				continue
+			}
+			if seen[name] {
+				continue
+			}
+			label := formatArmoryInstallLabel("extension", name, command.Help)
+			options = append(options, forms.ArmoryInstallOption{
+				Value: name,
+				Label: label,
+			})
+			seen[name] = true
+			packageCount++
+		}
+
+		return true
+	})
+
+	for _, bundle := range bundlesInCache() {
+		if bundle.Name == "" {
+			continue
+		}
+		if armoryName != "" && bundle.ArmoryName != armoryName {
+			continue
+		}
+		if seen[bundle.Name] {
+			continue
+		}
+		label := fmt.Sprintf("bundle: %s (%d packages)", bundle.Name, len(bundle.Packages))
+		options = append(options, forms.ArmoryInstallOption{
+			Value: bundle.Name,
+			Label: label,
+		})
+		seen[bundle.Name] = true
+	}
+
+	if len(options) == 0 {
+		return options
+	}
+
+	sort.Slice(options, func(i, j int) bool {
+		return options[i].Label < options[j].Label
+	})
+
+	if packageCount > 0 {
+		options = append([]forms.ArmoryInstallOption{
+			{
+				Value: "all",
+				Label: "all packages (aliases + extensions)",
+			},
+		}, options...)
+	}
+
+	return options
+}
+
+func formatArmoryInstallLabel(kind, name, help string) string {
+	help = strings.TrimSpace(help)
+	if help == "" {
+		return fmt.Sprintf("%s: %s", kind, name)
+	}
+	help = strings.Join(strings.Fields(help), " ")
+	return fmt.Sprintf("%s: %s - %s", kind, name, help)
+}
+
 func installAliasPackage(entry *pkgCacheEntry, promptToOverwrite bool, clientConfig ArmoryHTTPConfig, con *console.SliverClient) error {
 	if entry == nil {
 		return errors.New("package not found")

client/command/armory/manage.go

@@ -8,10 +8,10 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
 )
@@ -602,8 +602,7 @@ func ModifyArmoryCmd(cmd *cobra.Command, con *console.SliverClient, args []strin
 	if err != nil {
 		con.PrintErrorf("could not modify armory: %s\n", err)
 		confirm := false
-		prompt := &survey.Confirm{Message: "Would you like to revert the properties of the armory back to their previous values?"}
-		survey.AskOne(prompt, &confirm, nil)
+		_ = forms.Confirm("Would you like to revert the properties of the armory back to their previous values?", &confirm)
 		if !confirm {
 			return
 		} else {

client/command/armory/update.go

@@ -19,13 +19,11 @@ package armory
 */
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"sort"
-	"strconv"
-	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
 
@@ -34,6 +32,7 @@ import (
 	"github.com/bishopfox/sliver/client/command/extensions"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/util"
 )
 
@@ -87,16 +86,19 @@ func ArmoryUpdateCmd(cmd *cobra.Command, con *console.SliverClient, args []strin
 	if len(aliasUpdates) > 0 || len(extUpdates) > 0 {
 		updateKeys := sortUpdateIdentifiers(aliasUpdates, extUpdates)
 		displayAvailableUpdates(con, updateKeys, aliasUpdates, extUpdates)
-		selectedUpdates, err = getUpdatesFromUser(con, updateKeys)
+		selectedUpdates, err = getUpdatesFromUser(updateKeys)
 		if err != nil {
-			con.PrintErrorf(err.Error() + "\n")
+			if errors.Is(err, forms.ErrUserAborted) {
+				return
+			}
+			con.PrintErrorf("%s\n", err.Error())
 			return
 		}
 		if len(selectedUpdates) == 0 {
 			return
 		}
 	} else {
-		con.PrintSuccessf("All packages are up to date")
+		con.PrintSuccessf("All packages are up to date\n")
 		return
 	}
 
@@ -299,76 +301,35 @@ func displayAvailableUpdates(con *console.SliverClient, updateKeys []UpdateIdent
 	con.Printf("%s\n\n", tw.Render())
 }
 
-func getUpdatesFromUser(con *console.SliverClient, updateKeys []UpdateIdentifier) (chosenUpdates []UpdateIdentifier, selectionError error) {
-	chosenUpdates = []UpdateIdentifier{}
+func getUpdatesFromUser(updateKeys []UpdateIdentifier) ([]UpdateIdentifier, error) {
+	options := make([]forms.ArmoryUpdateOption, 0, len(updateKeys))
+	optionIndex := make(map[string]UpdateIdentifier, len(updateKeys))
 
-	var updateResponse string
+	for _, key := range updateKeys {
+		packageType := "Alias"
+		if key.Type == ExtensionPackage {
+			packageType = "Extension"
+		}
+		optionID := fmt.Sprintf("%d:%s", key.Type, key.Name)
+		optionLabel := fmt.Sprintf("%s (%s)", key.Name, packageType)
+		options = append(options, forms.ArmoryUpdateOption{
+			ID:    optionID,
+			Label: optionLabel,
+		})
+		optionIndex[optionID] = key
+	}
 
-	con.Println("You can apply all, none, or some updates.\nTo apply some updates, specify the number of a single update, a range (1-3), or a combination of the two (1, 3-5, 7)\n")
-	err := survey.AskOne(&survey.Input{
-		Message: "Which updates would you like to apply? [A]ll, [N]one, or some:",
-	}, &updateResponse)
+	result, err := forms.ArmoryUpdateForm(options)
 	if err != nil {
-		// We do not need to set selectionError because an error here means the same thing as responding with "none"
-		return
+		return nil, err
 	}
 
-	updateResponse = strings.ToLower(updateResponse)
-	updateResponse = strings.Replace(updateResponse, " ", "", -1)
-	if updateResponse == "n" || updateResponse == "none" {
-		return
-	}
-
-	if updateResponse == "a" || updateResponse == "all" {
-		chosenUpdates = updateKeys
-		return
-	}
-
-	selections := strings.Split(updateResponse, ",")
-
-	for _, selection := range selections {
-		// Handle a range
-		if strings.Contains(selection, "-") {
-			rangeParts := strings.Split(selection, "-")
-			start, err := strconv.Atoi(rangeParts[0])
-			if err != nil {
-				selectionError = fmt.Errorf("%s is not a valid range", rangeParts[0])
-				return
-			}
-			end, err := strconv.Atoi(rangeParts[1])
-			if err != nil {
-				selectionError = fmt.Errorf("%s is not a valid range", rangeParts[1])
-				return
-			}
-			// Adjust for the 0 indexed slice we are working with
-			start -= 1
-			end -= 1
-			if start < 0 {
-				start = 0
-			}
-			if start > end {
-				selectionError = fmt.Errorf("%s is not a valid range", selection)
-				return
-			}
-			if end >= len(updateKeys) {
-				end = len(updateKeys) - 1
-			}
-
-			for i := start; i <= end; i++ {
-				chosenUpdates = append(chosenUpdates, updateKeys[i])
-			}
-		} else {
-			// Single entry
-			index, err := strconv.Atoi(selection)
-			if err != nil {
-				selectionError = fmt.Errorf("%s is not a valid range", selection)
-				return
-			}
-			index -= 1
-			if index >= 0 && index < len(updateKeys) {
-				chosenUpdates = append(chosenUpdates, updateKeys[index])
-			}
+	chosenUpdates := make([]UpdateIdentifier, 0, len(result.SelectedIDs))
+	for _, selectedID := range result.SelectedIDs {
+		if update, ok := optionIndex[selectedID]; ok {
+			chosenUpdates = append(chosenUpdates, update)
 		}
 	}
-	return
+
+	return chosenUpdates, nil
 }

client/command/beacons/beacons.go

@@ -39,6 +39,7 @@ import (
 func BeaconsCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	killFlag, _ := cmd.Flags().GetString("kill")
 	killAll, _ := cmd.Flags().GetBool("kill-all")
+	interact, _ := cmd.Flags().GetString("interact")
 
 	// Handle kill
 	if killFlag != "" {
@@ -72,6 +73,18 @@ func BeaconsCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 			con.PrintInfof("Killed %s (%s)\n", beacon.Name, beacon.ID)
 		}
 	}
+
+	if interact != "" {
+		beacon, err := GetBeacon(con, interact)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.ActiveTarget.Set(nil, beacon)
+		con.PrintInfof("Active beacon %s (%s)\n", beacon.Name, strings.Split(beacon.ID, "-")[0])
+		return
+	}
+
 	filter, _ := cmd.Flags().GetString("filter")
 	var filterRegex *regexp.Regexp
 	if filterRe, _ := cmd.Flags().GetString("filter-re"); filterRe != "" {

client/command/beacons/commands.go

@@ -33,6 +33,7 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	flags.Bind("beacons", false, beaconsCmd, func(f *pflag.FlagSet) {
 		f.StringP("kill", "k", "", "kill the designated beacon")
 		f.BoolP("kill-all", "K", false, "kill all beacons")
+		f.StringP("interact", "i", "", "interact with a beacon")
 		f.BoolP("force", "F", false, "force killing the beacon")
 
 		f.StringP("filter", "f", "", "filter beacons by substring")
@@ -40,7 +41,9 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	})
 	flags.BindFlagCompletions(beaconsCmd, func(comp *carapace.ActionMap) {
 		(*comp)["kill"] = BeaconIDCompleter(con)
+		(*comp)["interact"] = BeaconIDCompleter(con)
 	})
+	registerBeaconIDFlagCompletion(beaconsCmd, "interact", con)
 	beaconsRmCmd := &cobra.Command{
 		Use:   consts.RmStr,
 		Short: "Remove a beacon",
@@ -81,22 +84,74 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 // BeaconIDCompleter completes beacon IDs
 func BeaconIDCompleter(con *console.SliverClient) carapace.Action {
 	callback := func(_ carapace.Context) carapace.Action {
-		results := make([]string, 0)
-
-		beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
-		if err == nil {
-			for _, b := range beacons.Beacons {
-				link := fmt.Sprintf("[%s <- %s]", b.ActiveC2, b.RemoteAddress)
-				id := fmt.Sprintf("%s (%d)", b.Name, b.PID)
-				userHost := fmt.Sprintf("%s@%s", b.Username, b.Hostname)
-				desc := strings.Join([]string{id, userHost, link}, " ")
-
-				results = append(results, b.ID[:8])
-				results = append(results, desc)
-			}
-		}
-		return carapace.ActionValuesDescribed(results...).Tag("beacons")
+		return carapace.ActionValuesDescribed(beaconCompletionPairs(con)...).Tag("beacons")
 	}
 
 	return carapace.ActionCallback(callback)
 }
+
+func registerBeaconIDFlagCompletion(cmd *cobra.Command, name string, con *console.SliverClient) {
+	if cmd == nil {
+		return
+	}
+	if _, ok := cmd.GetFlagCompletionFunc(name); ok {
+		return
+	}
+	if cmd.Flags().Lookup(name) == nil && cmd.PersistentFlags().Lookup(name) == nil {
+		return
+	}
+	_ = cmd.RegisterFlagCompletionFunc(name, func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		values := describedValuesToTabs(beaconCompletionPairs(con))
+		return filterCompletionValues(values, toComplete), cobra.ShellCompDirectiveNoFileComp
+	})
+}
+
+func beaconCompletionPairs(con *console.SliverClient) []string {
+	results := make([]string, 0)
+	if con == nil || con.Rpc == nil {
+		return results
+	}
+
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return results
+	}
+
+	for _, b := range beacons.Beacons {
+		link := fmt.Sprintf("[%s <- %s]", b.ActiveC2, b.RemoteAddress)
+		id := fmt.Sprintf("%s (%d)", b.Name, b.PID)
+		userHost := fmt.Sprintf("%s@%s", b.Username, b.Hostname)
+		desc := strings.Join([]string{id, userHost, link}, " ")
+
+		results = append(results, b.ID[:8], desc)
+	}
+
+	return results
+}
+
+func describedValuesToTabs(values []string) []string {
+	tabbed := make([]string, 0, len(values)/2)
+	for i := 0; i+1 < len(values); i += 2 {
+		tabbed = append(tabbed, fmt.Sprintf("%s\t%s", values[i], values[i+1]))
+	}
+	return tabbed
+}
+
+func filterCompletionValues(values []string, prefix string) []string {
+	if prefix == "" {
+		return values
+	}
+
+	filtered := make([]string, 0, len(values))
+	for _, value := range values {
+		candidate := value
+		if tab := strings.IndexByte(value, '\t'); tab >= 0 {
+			candidate = value[:tab]
+		}
+		if strings.HasPrefix(candidate, prefix) {
+			filtered = append(filtered, value)
+		}
+	}
+
+	return filtered
+}

client/command/beacons/helpers.go

@@ -26,9 +26,8 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/AlecAivazis/survey/v2"
-
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
@@ -83,12 +82,8 @@ func SelectBeacon(con *console.SliverClient) (*clientpb.Beacon, error) {
 
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
-	prompt := &survey.Select{
-		Message: "Select a beacon:",
-		Options: options,
-	}
 	selected := ""
-	survey.AskOne(prompt, &selected)
+	_ = forms.Select("Select a beacon:", options, &selected)
 	if selected == "" {
 		return nil, ErrNoSelection
 	}

client/command/beacons/prune.go

@@ -21,10 +21,10 @@ package beacons
 import (
 	"time"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/spf13/cobra"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
@@ -71,8 +71,7 @@ func BeaconsPruneCmd(cmd *cobra.Command, con *console.SliverClient, args []strin
 	}
 	con.Println()
 	confirm := false
-	prompt := &survey.Confirm{Message: "Prune these beacons?"}
-	survey.AskOne(prompt, &confirm)
+	_ = forms.Confirm("Prune these beacons?", &confirm)
 	if !confirm {
 		return
 	}

client/command/c2profiles/c2profiles.go

@@ -21,6 +21,7 @@ package c2profiles
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/url"
@@ -29,7 +30,6 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
 	"golang.org/x/exp/slices"
@@ -38,10 +38,15 @@ import (
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
 
+var (
+	ErrNoSelection = errors.New("no selection")
+)
+
 // C2ProfileCmd list available http profiles
 func C2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	profileName, _ := cmd.Flags().GetString("name")
@@ -53,7 +58,11 @@ func C2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string)
 			return
 		}
 		if len(httpC2Profiles.Configs) != 1 {
-			profileName = selectC2Profile(httpC2Profiles.Configs)
+			profileName, err = selectC2Profile(httpC2Profiles.Configs)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				return
+			}
 		}
 	}
 
@@ -124,7 +133,11 @@ func ExportC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []st
 			return
 		}
 		if len(httpC2Profiles.Configs) != 1 {
-			profileName = selectC2Profile(httpC2Profiles.Configs)
+			profileName, err = selectC2Profile(httpC2Profiles.Configs)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				return
+			}
 		}
 	}
 
@@ -540,20 +553,20 @@ func PrintC2Profiles(profile *clientpb.HTTPC2Config, con *console.SliverClient)
 	con.Println("\n")
 }
 
-func selectC2Profile(c2profiles []*clientpb.HTTPC2Config) string {
+func selectC2Profile(c2profiles []*clientpb.HTTPC2Config) (string, error) {
 	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)
+	_ = forms.Select("Select a c2 profile", choices, &c2profile)
 
-	return c2profile
+	if c2profile == "" {
+		return "", ErrNoSelection
+	}
+
+	return c2profile, nil
 }
 
 func updateC2Profile(template *assets.HTTPC2Config, urls []string) (*assets.HTTPC2Config, error) {

client/command/clean/clean.go

@@ -21,10 +21,10 @@ package clean
 import (
 	"context"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/flags"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
@@ -35,8 +35,7 @@ import (
 func CleanCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	con.Printf("This command will kill and remove all sessions, beacons and profiles \n")
 	confirm := false
-	prompt := &survey.Confirm{Message: "Are you sure you want to destroy everything?"}
-	survey.AskOne(prompt, &confirm)
+	_ = forms.Confirm("Are you sure you want to destroy everything?", &confirm)
 	if !confirm {
 		return
 	}

client/command/creds/select.go

@@ -8,8 +8,8 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
@@ -55,11 +55,7 @@ func SelectCredential(plaintext bool, hashType clientpb.HashType, con *console.S
 	}
 
 	selected := ""
-	prompt := &survey.Select{
-		Message: "Select a credential:",
-		Options: options,
-	}
-	err = survey.AskOne(prompt, &selected)
+	err = forms.Select("Select a credential:", options, &selected)
 	if err != nil {
 		return nil, err
 	}

client/command/cursed/cursed-chrome.go

@@ -27,9 +27,9 @@ import (
 	"strings"
 	"time"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/overlord"
 	"github.com/bishopfox/sliver/client/tcpproxy"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
@@ -123,7 +123,7 @@ func avadaKedavraChrome(session *clientpb.Session, cmd *cobra.Command, con *cons
 		con.PrintWarnf("Sliver will attempt to restore the user's session, however %sDATA LOSS MAY OCCUR!%s\n", console.Bold, console.Normal)
 		con.Printf("\n")
 		confirm := false
-		err = survey.AskOne(&survey.Confirm{Message: "Kill and restore existing Chrome process?"}, &confirm)
+		err = forms.Confirm("Kill and restore existing Chrome process?", &confirm)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return nil

client/command/cursed/cursed-console.go

@@ -26,9 +26,9 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/overlord"
 	"github.com/reeflective/readline"
 	"github.com/spf13/cobra"
@@ -71,12 +71,8 @@ func selectDebugTarget(targets []overlord.ChromeDebugTarget, con *console.Sliver
 	table.Flush()
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
-	prompt := &survey.Select{
-		Message: "Select a debug target:",
-		Options: options,
-	}
 	selected := ""
-	err := survey.AskOne(prompt, &selected)
+	err := forms.Select("Select a debug target:", options, &selected)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return nil

client/command/cursed/cursed-edge.go

@@ -23,9 +23,9 @@ import (
 	"os"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/overlord"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
@@ -106,7 +106,7 @@ func avadaKedavraEdge(session *clientpb.Session, cmd *cobra.Command, con *consol
 		con.PrintWarnf("Sliver will attempt to restore the user's session, however %sDATA LOSS MAY OCCUR!%s\n", console.Bold, console.Normal)
 		con.Printf("\n")
 		confirm := false
-		err = survey.AskOne(&survey.Confirm{Message: "Kill and restore existing Edge process?"}, &confirm)
+		err = forms.Confirm("Kill and restore existing Edge process?", &confirm)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return nil

client/command/cursed/cursed-electron.go

@@ -25,9 +25,9 @@ import (
 	"path"
 	"time"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/overlord"
 	"github.com/bishopfox/sliver/client/tcpproxy"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
@@ -88,7 +88,7 @@ func avadaKedavraElectron(electronExe string, session *clientpb.Session, cmd *co
 		con.PrintWarnf("%sDATA LOSS MAY OCCUR!%s\n", console.Bold, console.Normal)
 		con.Printf("\n")
 		confirm := false
-		err = survey.AskOne(&survey.Confirm{Message: "Kill and restart the process?"}, &confirm)
+		err = forms.Confirm("Kill and restart the process?", &confirm)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return nil

client/command/cursed/cursed-rm.go

@@ -22,9 +22,9 @@ import (
 	"context"
 	"strconv"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/spf13/cobra"
 )
@@ -44,7 +44,7 @@ func CursedRmCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	core.CloseCursedProcessesByBindPort(session.ID, bindPort)
 	if kill {
 		confirm := false
-		err := survey.AskOne(&survey.Confirm{Message: "Kill the cursed process?"}, &confirm)
+		err := forms.Confirm("Kill the cursed process?", &confirm)
 		if err != nil {
 			con.PrintErrorf("%s", err)
 			return

client/command/cursed/cursed.go

@@ -25,10 +25,10 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/util"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
@@ -95,12 +95,8 @@ func selectCursedProcess(con *console.SliverClient) *core.CursedProcess {
 	table.Flush()
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
-	prompt := &survey.Select{
-		Message: "Select a curse:",
-		Options: options,
-	}
 	selected := ""
-	err := survey.AskOne(prompt, &selected)
+	err := forms.Select("Select a curse:", options, &selected)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return nil

client/command/exec/commands.go

@@ -25,12 +25,14 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	}
 	flags.Bind("", false, executeCmd, func(f *pflag.FlagSet) {
 		f.BoolP("token", "T", false, "execute command with current token (Windows only)")
-		f.BoolP("output", "o", false, "capture command output")
+		f.BoolP("output", "o", true, "capture command output")
 		f.BoolP("save", "s", false, "save output to a file")
 		f.BoolP("loot", "X", false, "save output as loot")
 		f.BoolP("ignore-stderr", "S", false, "don't print STDERR output")
 		f.StringP("stdout", "O", "", "remote path to redirect STDOUT to")
 		f.StringP("stderr", "E", "", "remote path to redirect STDERR to")
+		f.Bool("env-inheritance", true, "inherit environment variables from the current process")
+		f.StringArray("env", nil, "set an environment variable for the child process (key=value)")
 		f.StringP("name", "n", "", "name to assign loot (optional)")
 		f.Uint32P("ppid", "P", 0, "parent process id (optional, Windows only)")
 		f.BoolP("hidden", "H", false, "hide the window of the spawned process (Windows only)")

client/command/exec/execute-assembly.go

@@ -24,8 +24,8 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/spf13/cobra"
@@ -82,8 +82,7 @@ func ExecuteAssemblyCmd(cmd *cobra.Command, con *console.SliverClient, args []st
 	if len(assemblyArgsStr) > 256 && !inProcess {
 		con.PrintWarnf(" Injected .NET assembly arguments are limited to 256 characters when using the default fork/exec model.\nConsider using the --in-process flag to execute the .NET assembly in-process and work around this limitation.\n")
 		confirm := false
-		prompt := &survey.Confirm{Message: "Do you want to continue?"}
-		survey.AskOne(prompt, &confirm, nil)
+		_ = forms.Confirm("Do you want to continue?", &confirm)
 		if !confirm {
 			return
 		}

client/command/exec/execute.go

@@ -49,6 +49,13 @@ func ExecuteCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	saveLoot, _ := cmd.Flags().GetBool("loot")
 	saveOutput, _ := cmd.Flags().GetBool("save")
 	ppid, _ := cmd.Flags().GetUint32("ppid")
+	envInheritance, _ := cmd.Flags().GetBool("env-inheritance")
+	envPairs, _ := cmd.Flags().GetStringArray("env")
+	envVars, err := parseEnvPairs(envPairs)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
 	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
@@ -59,15 +66,19 @@ func ExecuteCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	}
 
 	var exec *sliverpb.Execute
-	var err error
 
 	ctrl := make(chan bool)
+	con.PrintInfof("Execute: %s [%s]\n", cmdPath, strings.Join(args, " "))
 	con.SpinUntil(fmt.Sprintf("Executing %s %s ...", cmdPath, strings.Join(args, " ")), ctrl)
 	if token || hidden || ppid != 0 {
 		if (session != nil && session.OS != "windows") || (beacon != nil && beacon.OS != "windows") {
 			con.PrintErrorf("The token, hide window, and ppid options are not valid on %s\n", session.OS)
 			return
 		}
+		if envInheritance || len(envVars) > 0 {
+			con.PrintErrorf("The env and env-inheritance options are not supported with token, hidden, or ppid\n")
+			return
+		}
 		exec, err = con.Rpc.ExecuteWindows(context.Background(), &sliverpb.ExecuteWindowsReq{
 			Request:    con.ActiveTarget.Request(cmd),
 			Path:       cmdPath,
@@ -81,12 +92,14 @@ func ExecuteCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 		})
 	} else {
 		exec, err = con.Rpc.Execute(context.Background(), &sliverpb.ExecuteReq{
-			Request: con.ActiveTarget.Request(cmd),
-			Path:    cmdPath,
-			Args:    args,
-			Output:  captureOutput,
-			Stderr:  stderr,
-			Stdout:  stdout,
+			Request:        con.ActiveTarget.Request(cmd),
+			Path:           cmdPath,
+			Args:           args,
+			Output:         captureOutput,
+			Stderr:         stderr,
+			Stdout:         stdout,
+			EnvInheritance: envInheritance,
+			Env:            envVars,
 		})
 	}
 	ctrl <- true
@@ -179,6 +192,21 @@ func getHostname(session *clientpb.Session, beacon *clientpb.Beacon) string {
 	return ""
 }
 
+func parseEnvPairs(envPairs []string) (map[string]string, error) {
+	if len(envPairs) == 0 {
+		return nil, nil
+	}
+	envVars := make(map[string]string, len(envPairs))
+	for _, pair := range envPairs {
+		parts := strings.SplitN(pair, "=", 2)
+		if len(parts) != 2 || parts[0] == "" {
+			return nil, fmt.Errorf("invalid --env value %q, expected key=value", pair)
+		}
+		envVars[parts[0]] = parts[1]
+	}
+	return envVars, nil
+}
+
 func determineCommandName(command string) string {
 	commandName := strings.ReplaceAll(command, "\\", "/")
 

client/command/exec/ssh.go

@@ -23,8 +23,8 @@ import (
 	"os"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/spf13/cobra"
@@ -145,8 +145,7 @@ func tryCredsFromLoot(con *console.SliverClient) (string, string, []byte) {
 		privKey  []byte
 	)
 	confirm := false
-	prompt := &survey.Confirm{Message: "No credentials provided, use from loot?"}
-	survey.AskOne(prompt, &confirm, nil)
+	_ = forms.Confirm("No credentials provided, use from loot?", &confirm)
 	if confirm {
 		// cred, err := loot.SelectCredentials(con)
 		// if err != nil {

client/command/exit/exit.go

@@ -20,39 +20,36 @@ package exit
 
 import (
 	"context"
-	"fmt"
 	"os"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/spf13/cobra"
 )
 
 // ExitCmd - Exit the console.
 func ExitCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
-	fmt.Println("Exiting...")
 	if con.IsServer {
 		sessions, err := con.Rpc.GetSessions(context.Background(), &commonpb.Empty{})
 		if err != nil {
-			os.Exit(1)
+			flushAndExit(con, 1)
 		}
 		beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
 		if err != nil {
-			os.Exit(1)
+			flushAndExit(con, 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)
+			forms.Confirm("Are you sure you want to exit?", &confirm)
 			if !confirm {
 				return
 			}
 		}
 	}
-	os.Exit(0)
+	flushAndExit(con, 0)
 }
 
 // Commands returns the `exit` command.
@@ -66,3 +63,12 @@ func Command(con *console.SliverClient) []*cobra.Command {
 		GroupID: constants.GenericHelpGroup,
 	}}
 }
+
+func flushAndExit(con *console.SliverClient, code int) {
+	if con != nil {
+		con.FlushOutput()
+	} else {
+		os.Stdout.Sync()
+	}
+	os.Exit(code)
+}

client/command/extensions/install.go

@@ -24,9 +24,9 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/util"
 	"github.com/spf13/cobra"
 )
@@ -92,8 +92,7 @@ func InstallFromDir(extLocalPath string, promptToOverwrite bool, con *console.Sl
 		if promptToOverwrite {
 			con.PrintInfof("Extension '%s' already exists", manifestF.Name)
 			confirm := false
-			prompt := &survey.Confirm{Message: "Overwrite current install?"}
-			survey.AskOne(prompt, &confirm)
+			_ = forms.Confirm("Overwrite current install?", &confirm)
 			if !confirm {
 				return
 			}

client/command/extensions/load.go

@@ -30,21 +30,20 @@ import (
 	"os"
 	"path"
 	"path/filepath"
-	"strconv"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/packages"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util"
+	"github.com/carapace-sh/carapace"
 	appConsole "github.com/reeflective/console"
-	"github.com/rsteube/carapace"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"google.golang.org/protobuf/proto"
@@ -121,6 +120,7 @@ type extensionArgument struct {
 	Desc     string      `json:"desc"`
 	Optional bool        `json:"optional"`
 	Default  interface{} `json:"default,omitempty"`
+	Choices  []string    `json:"choices,omitempty"`
 }
 
 func (e *ExtCommand) getFileForTarget(targetOS string, targetArch string) (string, error) {
@@ -171,8 +171,7 @@ func ExtensionLoadCmd(cmd *cobra.Command, con *console.SliverClient, args []stri
 		if CmdExists(extCmd.CommandName, sliverMenu.Command) {
 			con.PrintErrorf("%s command already exists\n", extCmd.CommandName)
 			confirm := false
-			prompt := &survey.Confirm{Message: "Overwrite current command?"}
-			survey.AskOne(prompt, &confirm)
+			_ = forms.Confirm("Overwrite current command?", &confirm)
 			if !confirm {
 				return
 			}
@@ -690,94 +689,6 @@ func PrintExtOutput(extName string, commandName string, outputSchema *packages.O
 	}
 }
 
-func getExtArgs(_ *cobra.Command, args []string, _ string, ext *ExtCommand) ([]byte, error) {
-	var err error
-	argsBuffer := core.BOFArgsBuffer{
-		Buffer: new(bytes.Buffer),
-	}
-
-	// Parse BOF arguments from grumble
-	missingRequiredArgs := make([]string, 0)
-
-	// If we have an extension that expects a single string, but more than one has been parsed, combine them
-	if len(ext.Arguments) == 1 && strings.Contains(ext.Arguments[0].Type, "string") && len(args) > 0 {
-		// The loop below will only read the first element of args because ext.Arguments is 1
-		args[0] = strings.Join(args, " ")
-	}
-
-	for _, arg := range ext.Arguments {
-		// If we don't have any positional words left to consume,
-		// add the remaining required extension arguments in the
-		// error message.
-		if len(args) == 0 {
-			if !arg.Optional {
-				missingRequiredArgs = append(missingRequiredArgs, "`"+arg.Name+"`")
-			}
-			continue
-		}
-
-		// Else pop a word from the list
-		word := args[0]
-		args = args[1:]
-
-		switch arg.Type {
-		case "integer":
-			fallthrough
-		case "int":
-			val, err := strconv.Atoi(word)
-			if err != nil {
-				return nil, err
-			}
-			err = argsBuffer.AddInt(uint32(val))
-			if err != nil {
-				return nil, err
-			}
-		case "short":
-			val, err := strconv.Atoi(word)
-			if err != nil {
-				return nil, err
-			}
-			err = argsBuffer.AddShort(uint16(val))
-			if err != nil {
-				return nil, err
-			}
-		case "string":
-			err = argsBuffer.AddString(word)
-			if err != nil {
-				return nil, err
-			}
-		case "wstring":
-			err = argsBuffer.AddWString(word)
-			if err != nil {
-				return nil, err
-			}
-		// Adding support for filepaths so we can
-		// send binary data like shellcodes to BOFs
-		case "file":
-			data, err := os.ReadFile(word)
-			if err != nil {
-				return nil, err
-			}
-			err = argsBuffer.AddData(data)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	// Return if we have missing required arguments
-	if len(missingRequiredArgs) > 0 {
-		return nil, fmt.Errorf("required arguments %s were not provided", strings.Join(missingRequiredArgs, ", "))
-	}
-
-	parsedArgs, err := argsBuffer.GetBuffer()
-	if err != nil {
-		return nil, err
-	}
-
-	return parsedArgs, nil
-}
-
 func getBOFArgs(cmd *cobra.Command, args []string, binPath string, ext *ExtCommand) ([]byte, error) {
 	var extensionArgs []byte
 	binData, err := os.ReadFile(binPath)
@@ -838,16 +749,27 @@ func checkExtensionArgs(extCmd *ExtCommand) error {
 	return nil
 }
 
-// makeExtensionArgCompleter builds the positional arguments completer for the extension.
+// makeExtensionArgCompleter builds the positional and dash arguments completer for the extension.
+// It provides completion for:
+// 1. Positional arguments (before --)
+// 2. Flag-style arguments after -- (e.g., --process, --shellcode)
 func makeExtensionArgCompleter(extCmd *ExtCommand, _ *cobra.Command, comps *carapace.Carapace) {
 	var actions []carapace.Action
 
 	for _, arg := range extCmd.Arguments {
 		var action carapace.Action
 
-		switch arg.Type {
-		case "file":
-			action = carapace.ActionFiles().Tag("extension data")
+		// If choices are defined, use them for completion
+		if len(arg.Choices) > 0 {
+			action = carapace.ActionValues(arg.Choices...).Tag("choices")
+		} else {
+			// Fall back to type-based completion
+			switch arg.Type {
+			case "file":
+				action = carapace.ActionFiles().Tag("extension data")
+			default:
+				action = carapace.ActionValues()
+			}
 		}
 
 		usage := fmt.Sprintf("(%s) %s", arg.Type, arg.Desc)
@@ -859,6 +781,72 @@ func makeExtensionArgCompleter(extCmd *ExtCommand, _ *cobra.Command, comps *cara
 	}
 
 	comps.PositionalCompletion(actions...)
+
+	// Add dash completion for flag-style arguments after --
+	// The extension arguments are parsed as flags (--name value) by argparser.go
+	if len(extCmd.Arguments) > 0 {
+		// Pre-build the flag completions at registration time (not in a callback)
+		// This ensures the values are captured correctly
+		flagCompletion := makeExtensionFlagNameCompletion(extCmd)
+
+		// Build value completions for each argument type
+		valueCompletions := make(map[string]carapace.Action)
+		for _, arg := range extCmd.Arguments {
+			// If choices are defined, use them for completion
+			if len(arg.Choices) > 0 {
+				valueCompletions[arg.Name] = carapace.ActionValues(arg.Choices...).Tag("choices")
+			} else {
+				// Fall back to type-based completion
+				switch arg.Type {
+				case "file":
+					valueCompletions[arg.Name] = carapace.ActionFiles().Tag("file path")
+				default:
+					valueCompletions[arg.Name] = carapace.ActionValues()
+				}
+			}
+		}
+
+		// Use DashAnyCompletion with a smart action that determines context
+		comps.DashAnyCompletion(
+			carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+				// If typing a flag (starts with -)
+				if strings.HasPrefix(c.Value, "-") {
+					return flagCompletion
+				}
+
+				// If previous arg was a flag, complete its value
+				if len(c.Args) > 0 {
+					lastArg := c.Args[len(c.Args)-1]
+					if strings.HasPrefix(lastArg, "-") {
+						flagName := strings.TrimLeft(lastArg, "-")
+						if action, ok := valueCompletions[flagName]; ok {
+							return action
+						}
+					}
+				}
+
+				// Default: show flag names
+				return flagCompletion
+			}),
+		)
+	}
+}
+
+// makeExtensionFlagNameCompletion creates completion for flag names
+func makeExtensionFlagNameCompletion(extCmd *ExtCommand) carapace.Action {
+	var results []string
+
+	for _, arg := range extCmd.Arguments {
+		flagName := fmt.Sprintf("--%s", arg.Name)
+		desc := arg.Desc
+		if arg.Optional {
+			desc = fmt.Sprintf("[optional] %s", desc)
+		}
+		desc = fmt.Sprintf("(%s) %s", arg.Type, desc)
+		results = append(results, flagName, desc)
+	}
+
+	return carapace.ActionValuesDescribed(results...).Tag("extension arguments")
 }
 
 func makeCommandPlatformFilters(extCmd *ExtCommand) map[string]string {

client/command/extensions/remove.go

@@ -25,9 +25,9 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/util"
 	"github.com/spf13/cobra"
 )
@@ -40,8 +40,7 @@ func ExtensionsRemoveCmd(cmd *cobra.Command, con *console.SliverClient, args []s
 		return
 	}
 	confirm := false
-	prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' extension?", name)}
-	survey.AskOne(prompt, &confirm)
+	_ = forms.Confirm(fmt.Sprintf("Remove '%s' extension?", name), &confirm)
 	if !confirm {
 		return
 	}
@@ -104,8 +103,7 @@ func RemoveExtensionByManifestName(manifestName string, con *console.SliverClien
 		// If path is outside extensions directory, prompt for confirmation
 		if !strings.HasPrefix(extPath, assets.GetExtensionsDir()) {
 			confirm := false
-			prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' extension directory from filesystem?", manifestName)}
-			survey.AskOne(prompt, &confirm)
+			_ = forms.Confirm(fmt.Sprintf("Remove '%s' extension directory from filesystem?", manifestName), &confirm)
 			if !confirm {
 				// Skip the forceRemoveAll but continue with the rest
 				delete(loadedManifests, manifestName)

client/command/filesystem/download.go

@@ -30,12 +30,12 @@ import (
 
 	"github.com/bishopfox/sliver/client/command/loot"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util/encoders"
 	"github.com/spf13/cobra"
 	"google.golang.org/protobuf/proto"
-	"gopkg.in/AlecAivazis/survey.v1"
 )
 
 func DownloadCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
@@ -189,8 +189,7 @@ func HandleDownloadResponse(download *sliverpb.Download, cmd *cobra.Command, arg
 
 		if _, err := os.Stat(dst); err == nil {
 			overwrite := false
-			prompt := &survey.Confirm{Message: "Overwrite local file?"}
-			survey.AskOne(prompt, &overwrite, nil)
+			_ = forms.Confirm("Overwrite local file?", &overwrite)
 			if !overwrite {
 				return
 			}

client/command/generate/canaries.go

@@ -32,7 +32,7 @@ func PrintCanaries(con *console.SliverClient, canaries []*clientpb.DNSCanary, bu
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
 	tw.AppendHeader(table.Row{
-		"Sliver Name",
+		"Implant Name",
 		"Domain",
 		"Triggered",
 		"First Trigger",

client/command/generate/commands.go

@@ -357,6 +357,7 @@ func coreImplantFlagCompletions(cmd *cobra.Command, con *console.SliverClient) {
 		(*comp)["traffic-encoders"] = TrafficEncodersCompleter(con).UniqueList(",")
 		(*comp)["c2profile"] = HTTPC2Completer(con)
 	})
+	registerImplantTargetFlagCompletions(cmd, con)
 }
 
 // coreBeaconFlags binds all flags specific to beacon implants (profiles or compiled).

client/command/generate/generate-beacon.go

@@ -1,11 +1,15 @@
 package generate
 
 import (
+	"errors"
 	"fmt"
 	"os"
+	"strconv"
+	"strings"
 	"time"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/spf13/cobra"
 )
@@ -17,6 +21,22 @@ var (
 
 // GenerateBeaconCmd - The main command used to generate implant binaries
 func GenerateBeaconCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	if shouldRunGenerateBeaconForm(cmd, con, args) {
+		compiler, _ := compilerTargets(con)
+		result, err := forms.GenerateBeaconForm(compiler)
+		if err != nil {
+			if errors.Is(err, forms.ErrUserAborted) {
+				return
+			}
+			con.PrintErrorf("Generate beacon form failed: %s\n", err)
+			return
+		}
+		if err := applyGenerateBeaconForm(cmd, result); err != nil {
+			con.PrintErrorf("Failed to apply generate beacon form values: %s\n", err)
+			return
+		}
+	}
+
 	name, config := parseCompileFlags(cmd, con)
 	if config == nil {
 		return
@@ -67,3 +87,99 @@ func parseBeaconFlags(cmd *cobra.Command, config *clientpb.ImplantConfig) error
 	config.BeaconJitter = int64(time.Duration(beaconJitter) * time.Second)
 	return nil
 }
+
+func shouldRunGenerateBeaconForm(cmd *cobra.Command, con *console.SliverClient, args []string) bool {
+	if con == nil || con.IsCLI {
+		return false
+	}
+	if len(args) != 0 {
+		return false
+	}
+	return cmd.Flags().NFlag() == 0
+}
+
+func applyGenerateBeaconForm(cmd *cobra.Command, result *forms.GenerateBeaconFormResult) error {
+	if err := cmd.Flags().Set("os", result.OS); err != nil {
+		return err
+	}
+	if err := cmd.Flags().Set("arch", result.Arch); err != nil {
+		return err
+	}
+	if err := cmd.Flags().Set("format", result.Format); err != nil {
+		return err
+	}
+	name := strings.TrimSpace(result.Name)
+	if name != "" {
+		if err := cmd.Flags().Set("name", name); err != nil {
+			return err
+		}
+	}
+	save := strings.TrimSpace(result.Save)
+	if save != "" {
+		if err := cmd.Flags().Set("save", save); err != nil {
+			return err
+		}
+	}
+
+	c2Value := strings.TrimSpace(result.C2Value)
+	switch result.C2Type {
+	case "mtls":
+		if err := cmd.Flags().Set("mtls", c2Value); err != nil {
+			return err
+		}
+	case "wg":
+		if err := cmd.Flags().Set("wg", c2Value); err != nil {
+			return err
+		}
+	case "http":
+		if err := cmd.Flags().Set("http", c2Value); err != nil {
+			return err
+		}
+	case "dns":
+		if err := cmd.Flags().Set("dns", c2Value); err != nil {
+			return err
+		}
+	case "named-pipe":
+		if err := cmd.Flags().Set("named-pipe", c2Value); err != nil {
+			return err
+		}
+	case "tcp-pivot":
+		if err := cmd.Flags().Set("tcp-pivot", c2Value); err != nil {
+			return err
+		}
+	default:
+		return errors.New("unsupported C2 transport selection")
+	}
+
+	if err := setOptionalInt64Flag(cmd, "days", result.Days); err != nil {
+		return err
+	}
+	if err := setOptionalInt64Flag(cmd, "hours", result.Hours); err != nil {
+		return err
+	}
+	if err := setOptionalInt64Flag(cmd, "minutes", result.Minutes); err != nil {
+		return err
+	}
+	if err := setOptionalInt64Flag(cmd, "seconds", result.Seconds); err != nil {
+		return err
+	}
+	if err := setOptionalInt64Flag(cmd, "jitter", result.Jitter); err != nil {
+		return err
+	}
+	return nil
+}
+
+func setOptionalInt64Flag(cmd *cobra.Command, name, value string) error {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return nil
+	}
+	parsed, err := strconv.ParseInt(trimmed, 10, 64)
+	if err != nil {
+		return err
+	}
+	if parsed < 0 {
+		return fmt.Errorf("%s must be 0 or greater", name)
+	}
+	return cmd.Flags().Set(name, strconv.FormatInt(parsed, 10))
+}

client/command/generate/generate.go

@@ -32,9 +32,9 @@ import (
 	"strings"
 	"time"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/spin"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
@@ -85,10 +85,27 @@ var (
 
 	ErrNoExternalBuilder = errors.New("no external builders are available")
 	ErrNoValidBuilders   = errors.New("no valid external builders for target")
+	ErrNoSelection       = errors.New("no selection")
 )
 
 // GenerateCmd - The main command used to generate implant binaries
 func GenerateCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	if shouldRunGenerateForm(cmd, con, args) {
+		compiler, _ := compilerTargets(con)
+		result, err := forms.GenerateForm(compiler)
+		if err != nil {
+			if errors.Is(err, forms.ErrUserAborted) {
+				return
+			}
+			con.PrintErrorf("Generate form failed: %s\n", err)
+			return
+		}
+		if err := applyGenerateForm(cmd, result); err != nil {
+			con.PrintErrorf("Failed to apply generate form values: %s\n", err)
+			return
+		}
+	}
+
 	name, config := parseCompileFlags(cmd, con)
 	if config == nil {
 		return
@@ -102,14 +119,15 @@ func GenerateCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	} else {
 		_, err := externalBuild(name, config, save, con)
 		if err != nil {
-			if err == ErrNoExternalBuilder {
+			switch err {
+			case ErrNoExternalBuilder:
 				con.PrintErrorf("There are no external builders currently connected to the server\n")
 				con.PrintErrorf("See 'builders' command for more information\n")
-			} else if err == ErrNoValidBuilders {
+			case ErrNoValidBuilders:
 				con.PrintErrorf("There are external builders connected to the server, but none can build the target you specified\n")
 				con.PrintErrorf("Invalid target %s\n", fmt.Sprintf("%s:%s/%s", config.Format, config.GOOS, config.GOARCH))
 				con.PrintErrorf("See 'builders' command for more information\n")
-			} else {
+			default:
 				con.PrintErrorf("%s\n", err)
 			}
 			return
@@ -117,6 +135,58 @@ func GenerateCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	}
 }
 
+func shouldRunGenerateForm(cmd *cobra.Command, con *console.SliverClient, args []string) bool {
+	if con == nil || con.IsCLI {
+		return false
+	}
+	if len(args) != 0 {
+		return false
+	}
+	return cmd.Flags().NFlag() == 0
+}
+
+func applyGenerateForm(cmd *cobra.Command, result *forms.GenerateFormResult) error {
+	if err := cmd.Flags().Set("os", result.OS); err != nil {
+		return err
+	}
+	if err := cmd.Flags().Set("arch", result.Arch); err != nil {
+		return err
+	}
+	if err := cmd.Flags().Set("format", result.Format); err != nil {
+		return err
+	}
+	name := strings.TrimSpace(result.Name)
+	if name != "" {
+		if err := cmd.Flags().Set("name", name); err != nil {
+			return err
+		}
+	}
+	save := strings.TrimSpace(result.Save)
+	if save != "" {
+		if err := cmd.Flags().Set("save", save); err != nil {
+			return err
+		}
+	}
+
+	c2Value := strings.TrimSpace(result.C2Value)
+	switch result.C2Type {
+	case "mtls":
+		return cmd.Flags().Set("mtls", c2Value)
+	case "wg":
+		return cmd.Flags().Set("wg", c2Value)
+	case "http":
+		return cmd.Flags().Set("http", c2Value)
+	case "dns":
+		return cmd.Flags().Set("dns", c2Value)
+	case "named-pipe":
+		return cmd.Flags().Set("named-pipe", c2Value)
+	case "tcp-pivot":
+		return cmd.Flags().Set("tcp-pivot", c2Value)
+	default:
+		return errors.New("unsupported C2 transport selection")
+	}
+}
+
 func expandPath(path string) string {
 	// unless path starts with ~
 	if len(path) == 0 || path[0] != 126 {
@@ -134,13 +204,10 @@ func saveLocation(save, DefaultName string, con *console.SliverClient) (string,
 	save = expandPath(save)
 	fi, err := os.Stat(save)
 	if os.IsNotExist(err) {
-		con.Printf("%s does not exist\n", save)
 		if strings.HasSuffix(save, "/") {
-			con.Printf("%s is dir\n", save)
 			os.MkdirAll(save, 0o700)
 			saveTo, _ = filepath.Abs(filepath.Join(saveTo, DefaultName))
 		} else {
-			con.Printf("%s is not dir\n", save)
 			saveDir := filepath.Dir(save)
 			_, err := os.Stat(saveTo)
 			if os.IsNotExist(err) {
@@ -152,10 +219,8 @@ func saveLocation(save, DefaultName string, con *console.SliverClient) (string,
 		if fi.IsDir() {
 			saveTo, _ = filepath.Abs(filepath.Join(save, DefaultName))
 		} else {
-			con.PrintInfof("%s is not dir\n", save)
-			prompt := &survey.Confirm{Message: "Overwrite existing file?"}
 			var confirm bool
-			survey.AskOne(prompt, &confirm)
+			_ = forms.Confirm("Overwrite existing file?", &confirm)
 			if !confirm {
 				return "", errors.New("file already exists")
 			}
@@ -466,9 +531,8 @@ func getTargets(targetOS string, targetArch string, con *console.SliverClient) (
 			console.Bold, target, console.Normal,
 		)
 		con.Printf("⚠️  Generic implants do not support all commands/features.\n")
-		prompt := &survey.Confirm{Message: "Attempt to build generic implant?"}
 		var confirm bool
-		survey.AskOne(prompt, &confirm)
+		_ = forms.Confirm("Attempt to build generic implant?", &confirm)
 		if !confirm {
 			return "", ""
 		}
@@ -576,7 +640,7 @@ func hasValidC2AdvancedOptions(options url.Values) (bool, error) {
 			if testValue != "wininet" {
 				return false, fmt.Errorf("C2 option \"driver\" must be empty for the default driver or \"wininet\" for the wininet driver (Windows only)")
 			}
-		case "force-http", "disable-accept-header", "disable-upgrade-header", "ask-proxy-creds", "force-base32":
+		case "force-http", "disable-accept-header", "disable-upgrade-header", "ask-proxy-creds":
 			if testValue != "true" && testValue != "false" {
 				return false, fmt.Errorf("C2 option \"%s\" must be a boolean value: true or false", key)
 			}
@@ -738,11 +802,8 @@ func ParseNamedPipec2(args string) ([]*clientpb.ImplantC2, error) {
 		}
 
 		if !strings.HasPrefix(uri.Path, "/pipe/") {
-			prompt := &survey.Confirm{
-				Message: fmt.Sprintf("Named pipe '%s' is missing the 'pipe' path prefix\nContinue anyways?", uri),
-			}
 			var confirm bool
-			survey.AskOne(prompt, &confirm)
+			_ = forms.Confirm(fmt.Sprintf("Named pipe '%s' is missing the 'pipe' path prefix\nContinue anyways?", uri), &confirm)
 			if !confirm {
 				return nil, fmt.Errorf("invalid namedpipe path: %s", uri.Path)
 			}
@@ -1049,8 +1110,7 @@ func warnMissingCrossCompiler(format clientpb.OutputFormat, targetOS string, tar
 	con.PrintWarnf("For more information please read %s\n", crossCompilerInfoURL)
 
 	confirm := false
-	prompt := &survey.Confirm{Message: "Try to compile anyways (will likely fail)?"}
-	survey.AskOne(prompt, &confirm, nil)
+	_ = forms.Confirm("Try to compile anyways (will likely fail)?", &confirm)
 	return confirm
 }
 
@@ -1086,11 +1146,12 @@ func selectExternalBuilder(builders []*clientpb.Builder, _ *console.SliverClient
 		choices = append(choices, builder.Name)
 	}
 	choice := ""
-	prompt := &survey.Select{
-		Message: "Select an external builder:",
-		Options: choices,
+	_ = forms.Select("Select an external builder:", choices, &choice)
+
+	if choice == "" {
+		return nil, ErrNoSelection
 	}
-	survey.AskOne(prompt, &choice, nil)
+
 	for _, builder := range builders {
 		if builder.Name == choice {
 			return builder, nil

client/command/generate/helpers.go

@@ -3,11 +3,13 @@ package generate
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
 )
 
 // GetSliverBinary - Get the binary of an implant based on it's profile.
@@ -51,71 +53,112 @@ func GetSliverBinary(profile *clientpb.ImplantProfile, con *console.SliverClient
 	return data, err
 }
 
+func compilerTargets(con *console.SliverClient) (*clientpb.Compiler, error) {
+	if con == nil || con.Rpc == nil {
+		return nil, fmt.Errorf("no compiler info")
+	}
+	return con.Rpc.GetCompiler(context.Background(), &commonpb.Empty{})
+}
+
+func appendUnique(values []string, value string) []string {
+	for _, existing := range values {
+		if existing == value {
+			return values
+		}
+	}
+	return append(values, value)
+}
+
+func compilerArchValues(compiler *clientpb.Compiler) []string {
+	results := []string{}
+
+	for _, target := range compiler.Targets {
+		results = appendUnique(results, target.GOARCH)
+	}
+
+	for _, target := range compiler.UnsupportedTargets {
+		results = appendUnique(results, target.GOARCH)
+	}
+
+	return results
+}
+
+func compilerOSValues(compiler *clientpb.Compiler) []string {
+	results := []string{}
+
+	for _, target := range compiler.Targets {
+		results = appendUnique(results, target.GOOS)
+	}
+
+	for _, target := range compiler.UnsupportedTargets {
+		results = appendUnique(results, target.GOOS)
+	}
+
+	return results
+}
+
+func filterByPrefix(values []string, prefix string) []string {
+	if prefix == "" {
+		return values
+	}
+
+	filtered := make([]string, 0, len(values))
+	for _, value := range values {
+		if strings.HasPrefix(value, prefix) {
+			filtered = append(filtered, value)
+		}
+	}
+
+	return filtered
+}
+
+func registerTargetFlagCompletion(cmd *cobra.Command, name string, valuesFn func(*clientpb.Compiler) []string, con *console.SliverClient) {
+	if cmd == nil {
+		return
+	}
+	if _, ok := cmd.GetFlagCompletionFunc(name); ok {
+		return
+	}
+	if cmd.Flags().Lookup(name) == nil && cmd.PersistentFlags().Lookup(name) == nil {
+		return
+	}
+	_ = cmd.RegisterFlagCompletionFunc(name, func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		compiler, err := compilerTargets(con)
+		if err != nil {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+
+		values := valuesFn(compiler)
+		return filterByPrefix(values, toComplete), cobra.ShellCompDirectiveNoFileComp
+	})
+}
+
+func registerImplantTargetFlagCompletions(cmd *cobra.Command, con *console.SliverClient) {
+	registerTargetFlagCompletion(cmd, "os", compilerOSValues, con)
+	registerTargetFlagCompletion(cmd, "arch", compilerArchValues, con)
+}
+
 // FormatCompleter completes builds' architectures.
 func ArchCompleter(con *console.SliverClient) carapace.Action {
 	return carapace.ActionCallback(func(_ carapace.Context) carapace.Action {
-		compiler, err := con.Rpc.GetCompiler(context.Background(), &commonpb.Empty{})
+		compiler, err := compilerTargets(con)
 		if err != nil {
 			return carapace.ActionMessage("No compiler info: %s", err.Error())
 		}
 
-		var results []string
-
-	nextTarget:
-		for _, target := range compiler.Targets {
-			for _, res := range results {
-				if res == target.GOARCH {
-					continue nextTarget
-				}
-			}
-			results = append(results, target.GOARCH)
-		}
-
-	nextUnsupported:
-		for _, target := range compiler.UnsupportedTargets {
-			for _, res := range results {
-				if res == target.GOARCH {
-					continue nextUnsupported
-				}
-			}
-			results = append(results, target.GOARCH)
-		}
-
-		return carapace.ActionValues(results...).Tag("architectures")
+		return carapace.ActionValues(compilerArchValues(compiler)...).Tag("architectures")
 	})
 }
 
 // FormatCompleter completes build operating systems.
 func OSCompleter(con *console.SliverClient) carapace.Action {
 	return carapace.ActionCallback(func(_ carapace.Context) carapace.Action {
-		compiler, err := con.Rpc.GetCompiler(context.Background(), &commonpb.Empty{})
+		compiler, err := compilerTargets(con)
 		if err != nil {
 			return carapace.ActionMessage("No compiler info: %s", err.Error())
 		}
 
-		var results []string
-
-	nextTarget:
-		for _, target := range compiler.Targets {
-			for _, res := range results {
-				if res == target.GOOS {
-					continue nextTarget
-				}
-			}
-			results = append(results, target.GOOS)
-		}
-
-	nextUnsupported:
-		for _, target := range compiler.UnsupportedTargets {
-			for _, res := range results {
-				if res == target.GOOS {
-					continue nextUnsupported
-				}
-			}
-			results = append(results, target.GOOS)
-		}
-
-		return carapace.ActionValues(results...).Tag("operating systems")
+		return carapace.ActionValues(compilerOSValues(compiler)...).Tag("operating systems")
 	})
 }
 

client/command/generate/implants-rm.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/spf13/cobra"
 )
@@ -24,8 +24,7 @@ func ImplantsRmCmd(cmd *cobra.Command, con *console.SliverClient, args []string)
 		return
 	}
 	confirm := false
-	prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' build?", name)}
-	survey.AskOne(prompt, &confirm)
+	_ = forms.Confirm(fmt.Sprintf("Remove '%s' build?", name), &confirm)
 	if !confirm {
 		return
 	}

client/command/generate/implants-stage.go

@@ -21,10 +21,10 @@ package generate
 import (
 	"context"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/spf13/cobra"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
@@ -42,12 +42,8 @@ func ImplantsStageCmd(cmd *cobra.Command, con *console.SliverClient, args []stri
 		options = append(options, name)
 	}
 
-	prompt := &survey.MultiSelect{
-		Message: "Select sessions and beacons to expose:",
-		Options: options,
-	}
 	selected := []string{}
-	survey.AskOne(prompt, &selected)
+	_ = forms.MultiSelect("Select sessions and beacons to expose:", options, &selected)
 
 	_, err = con.Rpc.StageImplantBuild(context.Background(), &clientpb.ImplantStageReq{Build: selected})
 	if err != nil {

client/command/generate/implants.go

@@ -124,7 +124,7 @@ func PrintImplantBuilds(builds *clientpb.ImplantBuilds, filters ImplantBuildFilt
 			config.Format,
 			strings.Join(c2URLs, "\n"),
 			fmt.Sprintf("%v", config.Debug),
-			fmt.Sprintf(config.HTTPC2ConfigName),
+			fmt.Sprintf("%s", config.HTTPC2ConfigName),
 			fmt.Sprintf("%v", builds.ResourceIDs[sliverName].Value),
 			fmt.Sprintf("%v", builds.Staged[sliverName]),
 		})

client/command/generate/profiles-new.go

@@ -19,8 +19,11 @@ package generate
 */
 import (
 	"context"
+	"errors"
+	"strings"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/spf13/cobra"
 )
@@ -28,7 +31,22 @@ import (
 // ProfilesNewCmd - Create a new implant profile.
 func ProfilesNewCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	var name string
-	if len(args) > 0 {
+	if shouldRunGenerateProfilesNewForm(cmd, con, args) {
+		result, err := forms.GenerateProfilesNewForm()
+		if err != nil {
+			if errors.Is(err, forms.ErrUserAborted) {
+				return
+			}
+			con.PrintErrorf("Profiles new form failed: %s\n", err)
+			return
+		}
+		profileName, err := applyGenerateProfilesNewForm(cmd, result)
+		if err != nil {
+			con.PrintErrorf("Failed to apply profiles new form values: %s\n", err)
+			return
+		}
+		name = profileName
+	} else if len(args) > 0 {
 		name = args[0]
 	}
 	// name := ctx.Args.String("name")
@@ -51,7 +69,22 @@ func ProfilesNewCmd(cmd *cobra.Command, con *console.SliverClient, args []string
 // ProfilesNewBeaconCmd - Create a new beacon profile.
 func ProfilesNewBeaconCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	var name string
-	if len(args) > 0 {
+	if shouldRunGenerateProfilesNewBeaconForm(cmd, con, args) {
+		result, err := forms.GenerateProfilesNewBeaconForm()
+		if err != nil {
+			if errors.Is(err, forms.ErrUserAborted) {
+				return
+			}
+			con.PrintErrorf("Profiles new beacon form failed: %s\n", err)
+			return
+		}
+		profileName, err := applyGenerateProfilesNewBeaconForm(cmd, result)
+		if err != nil {
+			con.PrintErrorf("Failed to apply profiles new beacon form values: %s\n", err)
+			return
+		}
+		name = profileName
+	} else if len(args) > 0 {
 		name = args[0]
 	}
 	// name := ctx.Args.String("name")
@@ -80,3 +113,151 @@ func ProfilesNewBeaconCmd(cmd *cobra.Command, con *console.SliverClient, args []
 		con.PrintInfof("Saved new implant profile (beacon) %s\n", resp.Name)
 	}
 }
+
+func shouldRunGenerateProfilesNewForm(cmd *cobra.Command, con *console.SliverClient, args []string) bool {
+	if con == nil || con.IsCLI {
+		return false
+	}
+	if len(args) != 0 {
+		return false
+	}
+	return cmd.Flags().NFlag() == 0
+}
+
+func applyGenerateProfilesNewForm(cmd *cobra.Command, result *forms.GenerateProfilesNewFormResult) (string, error) {
+	if err := cmd.Flags().Set("os", result.OS); err != nil {
+		return "", err
+	}
+	if err := cmd.Flags().Set("arch", result.Arch); err != nil {
+		return "", err
+	}
+	if err := cmd.Flags().Set("format", result.Format); err != nil {
+		return "", err
+	}
+
+	profileName := strings.TrimSpace(result.ProfileName)
+	if profileName == "" {
+		return "", errors.New("profile name required")
+	}
+
+	implantName := strings.TrimSpace(result.Name)
+	if implantName != "" {
+		if err := cmd.Flags().Set("name", implantName); err != nil {
+			return "", err
+		}
+	}
+
+	c2Value := strings.TrimSpace(result.C2Value)
+	switch result.C2Type {
+	case "mtls":
+		if err := cmd.Flags().Set("mtls", c2Value); err != nil {
+			return "", err
+		}
+	case "wg":
+		if err := cmd.Flags().Set("wg", c2Value); err != nil {
+			return "", err
+		}
+	case "http":
+		if err := cmd.Flags().Set("http", c2Value); err != nil {
+			return "", err
+		}
+	case "dns":
+		if err := cmd.Flags().Set("dns", c2Value); err != nil {
+			return "", err
+		}
+	case "named-pipe":
+		if err := cmd.Flags().Set("named-pipe", c2Value); err != nil {
+			return "", err
+		}
+	case "tcp-pivot":
+		if err := cmd.Flags().Set("tcp-pivot", c2Value); err != nil {
+			return "", err
+		}
+	default:
+		return "", errors.New("unsupported C2 transport selection")
+	}
+
+	return profileName, nil
+}
+
+func shouldRunGenerateProfilesNewBeaconForm(cmd *cobra.Command, con *console.SliverClient, args []string) bool {
+	if con == nil || con.IsCLI {
+		return false
+	}
+	if len(args) != 0 {
+		return false
+	}
+	return cmd.Flags().NFlag() == 0
+}
+
+func applyGenerateProfilesNewBeaconForm(cmd *cobra.Command, result *forms.GenerateProfilesNewBeaconFormResult) (string, error) {
+	if err := cmd.Flags().Set("os", result.OS); err != nil {
+		return "", err
+	}
+	if err := cmd.Flags().Set("arch", result.Arch); err != nil {
+		return "", err
+	}
+	if err := cmd.Flags().Set("format", result.Format); err != nil {
+		return "", err
+	}
+
+	profileName := strings.TrimSpace(result.ProfileName)
+	if profileName == "" {
+		return "", errors.New("profile name required")
+	}
+
+	implantName := strings.TrimSpace(result.Name)
+	if implantName != "" {
+		if err := cmd.Flags().Set("name", implantName); err != nil {
+			return "", err
+		}
+	}
+
+	c2Value := strings.TrimSpace(result.C2Value)
+	switch result.C2Type {
+	case "mtls":
+		if err := cmd.Flags().Set("mtls", c2Value); err != nil {
+			return "", err
+		}
+	case "wg":
+		if err := cmd.Flags().Set("wg", c2Value); err != nil {
+			return "", err
+		}
+	case "http":
+		if err := cmd.Flags().Set("http", c2Value); err != nil {
+			return "", err
+		}
+	case "dns":
+		if err := cmd.Flags().Set("dns", c2Value); err != nil {
+			return "", err
+		}
+	case "named-pipe":
+		if err := cmd.Flags().Set("named-pipe", c2Value); err != nil {
+			return "", err
+		}
+	case "tcp-pivot":
+		if err := cmd.Flags().Set("tcp-pivot", c2Value); err != nil {
+			return "", err
+		}
+	default:
+		return "", errors.New("unsupported C2 transport selection")
+	}
+
+	if err := setOptionalInt64Flag(cmd, "days", result.Days); err != nil {
+		return "", err
+	}
+	if err := setOptionalInt64Flag(cmd, "hours", result.Hours); err != nil {
+		return "", err
+	}
+	if err := setOptionalInt64Flag(cmd, "minutes", result.Minutes); err != nil {
+		return "", err
+	}
+	if err := setOptionalInt64Flag(cmd, "seconds", result.Seconds); err != nil {
+		return "", err
+	}
+	if err := setOptionalInt64Flag(cmd, "jitter", result.Jitter); err != nil {
+		return "", err
+	}
+
+	return profileName, nil
+}

client/command/generate/profiles-rm.go

@@ -22,8 +22,8 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/spf13/cobra"
 )
@@ -45,8 +45,7 @@ func ProfilesRmCmd(cmd *cobra.Command, con *console.SliverClient, args []string)
 		return
 	}
 	confirm := false
-	prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' profile?", name)}
-	survey.AskOne(prompt, &confirm)
+	_ = forms.Confirm(fmt.Sprintf("Remove '%s' profile?", name), &confirm)
 	if !confirm {
 		return
 	}

client/command/generate/traffic-encoders.go

@@ -26,10 +26,10 @@ import (
 	"strings"
 	"time"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/util"
@@ -140,10 +140,7 @@ func TrafficEncodersAddCmd(cmd *cobra.Command, con *console.SliverClient, args [
 // saveFailedSample - Save the sample the encoder failed to properly encode/decode.
 func saveFailedSample(encoderName string, test *clientpb.TrafficEncoderTest) {
 	confirm := false
-	prompt := &survey.Confirm{
-		Message: fmt.Sprintf("Failed to add traffic encoder %s, save failed sample to disk?", encoderName),
-	}
-	survey.AskOne(prompt, &confirm)
+	_ = forms.Confirm(fmt.Sprintf("Failed to add traffic encoder %s, save failed sample to disk?", encoderName), &confirm)
 	if !confirm {
 		return
 	}
@@ -286,10 +283,10 @@ func SelectTrafficEncoder(con *console.SliverClient) string {
 	}
 	sort.Strings(encoderNames)
 	var selectedEncoder string
-	prompt := &survey.Select{
-		Message: "Select a traffic encoder:",
-		Options: encoderNames,
+	err = forms.Select("Select a traffic encoder:", encoderNames, &selectedEncoder)
+	if err != nil {
+		con.PrintErrorf("%s", err)
+		return ""
 	}
-	survey.AskOne(prompt, &selectedEncoder)
 	return selectedEncoder
 }

client/command/help/long-help.go

@@ -68,6 +68,7 @@ var (
 		consts.RunAsStr:            runAsHelp,
 		consts.ImpersonateStr:      impersonateHelp,
 		consts.RevToSelfStr:        revToSelfHelp,
+		consts.ExecuteStr:          executeHelp,
 		consts.ExecuteAssemblyStr:  executeAssemblyHelp,
 		consts.ExecuteShellcodeStr: executeShellcodeHelp,
 		consts.MigrateStr:          migrateHelp,
@@ -124,6 +125,22 @@ var (
 		consts.C2ProfileStr + sep + consts.C2GenerateStr: c2GenerateHelp,
 	}
 
+	executeHelp = `[[.Bold]]Command:[[.Normal]] execute <path to executable> [options] -- [args...]
+
+[[.Bold]]About:[[.Normal]] Execute a program on the remote system with optional arguments, note the subprocess 
+arguments are be separated from the sliver 'execute' arguments with '--' 
+
+[[.Bold]]Example:[[.Normal]]
+execute /bin/bash --env FOO=1 -- -c env
+
+[*] Execute: /bin/bash [-c env]
+[*] Output:
+FOO=1
+PWD=/Users/moloch/git/sliver
+SHLVL=1
+_=/usr/bin/env
+`
+
 	jobsHelp = `[[.Bold]]Command:[[.Normal]] jobs <options>
 	[[.Bold]]About:[[.Normal]] Manage jobs/listeners.`
 

client/command/hosts/hosts-ioc.go

@@ -25,8 +25,8 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
@@ -86,12 +86,8 @@ func SelectHostIOC(host *clientpb.Host, con *console.SliverClient) (*clientpb.IO
 
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
-	prompt := &survey.Select{
-		Message: "Select an IOC:",
-		Options: options,
-	}
 	selected := ""
-	survey.AskOne(prompt, &selected)
+	_ = forms.Select("Select an IOC:", options, &selected)
 	if selected == "" {
 		return nil, ErrNoSelection
 	}

client/command/hosts/hosts.go

@@ -28,9 +28,9 @@ import (
 	"text/tabwriter"
 	"time"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/jedib0t/go-pretty/v6/table"
@@ -172,12 +172,8 @@ func SelectHost(con *console.SliverClient) (*clientpb.Host, error) {
 
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
-	prompt := &survey.Select{
-		Message: "Select a host:",
-		Options: options,
-	}
 	selected := ""
-	survey.AskOne(prompt, &selected)
+	_ = forms.Select("Select a host:", options, &selected)
 	if selected == "" {
 		return nil, ErrNoSelection
 	}

client/command/kill/kill.go

@@ -22,11 +22,11 @@ import (
 	"context"
 	"errors"
 
-	"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/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
@@ -39,7 +39,7 @@ func KillCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	confirm := false
 	con.PrintWarnf("WARNING: This will kill the remote implant process\n\n")
 	if session != nil {
-		survey.AskOne(&survey.Confirm{Message: "Kill the active session?"}, &confirm, nil)
+		_ = forms.Confirm("Kill the active session?", &confirm)
 		if !confirm {
 			return
 		}
@@ -52,7 +52,7 @@ func KillCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 		con.ActiveTarget.Background()
 		return
 	} else if beacon != nil {
-		survey.AskOne(&survey.Confirm{Message: "Kill the active beacon?"}, &confirm, nil)
+		_ = forms.Confirm("Kill the active beacon?", &confirm)
 		if !confirm {
 			return
 		}

client/command/loot/helpers.go

@@ -31,9 +31,9 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/spf13/cobra"
 
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/rpcpb"
@@ -106,11 +106,7 @@ func SelectLoot(cmd *cobra.Command, rpc rpcpb.SliverRPCClient) (*clientpb.Loot,
 	}
 
 	selected := ""
-	prompt := &survey.Select{
-		Message: "Select a piece of loot:",
-		Options: options,
-	}
-	err = survey.AskOne(prompt, &selected)
+	err = forms.Select("Select a piece of loot:", options, &selected)
 	if err != nil {
 		return nil, err
 	}

client/command/loot/loot.go

@@ -26,12 +26,12 @@ import (
 	"strings"
 	"unicode/utf8"
 
-	"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/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/util"
@@ -111,8 +111,7 @@ func saveLootToDisk(cmd *cobra.Command, loot *clientpb.Loot) (string, error) {
 	}
 	if _, err := os.Stat(saveTo); err == nil {
 		overwrite := false
-		prompt := &survey.Confirm{Message: "Overwrite local file?"}
-		survey.AskOne(prompt, &overwrite, nil)
+		_ = forms.Confirm("Overwrite local file?", &overwrite)
 		if !overwrite {
 			return "", nil
 		}

client/command/loot/rename.go

@@ -21,10 +21,10 @@ package loot
 import (
 	"context"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/spf13/cobra"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 )
 
@@ -37,8 +37,7 @@ func LootRenameCmd(cmd *cobra.Command, con *console.SliverClient, args []string)
 	}
 	oldName := loot.Name
 	newName := ""
-	prompt := &survey.Input{Message: "Enter new name: "}
-	survey.AskOne(prompt, &newName)
+	_ = forms.Input("Enter new name:", &newName)
 
 	loot, err = con.Rpc.LootUpdate(context.Background(), &clientpb.Loot{
 		ID:   loot.ID,

client/command/mcp/commands.go

@@ -0,0 +1,76 @@
+package mcp
+
+import (
+	"github.com/bishopfox/sliver/client/command/flags"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	clientmcp "github.com/bishopfox/sliver/client/mcp"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+// Commands returns the `mcp` command and its subcommands.
+func Commands(con *console.SliverClient) []*cobra.Command {
+	defaultConfig := clientmcp.DefaultConfig()
+
+	mcpCmd := &cobra.Command{
+		Use:     consts.MCPStr,
+		Short:   "Manage the MCP server",
+		Long:    help.GetHelpFor([]string{consts.MCPStr}),
+		GroupID: consts.NetworkHelpGroup,
+		Run: func(cmd *cobra.Command, args []string) {
+			McpCmd(cmd, con, args)
+		},
+	}
+
+	startCmd := &cobra.Command{
+		Use:   consts.StartStr,
+		Short: "Start the MCP server",
+		Long:  help.GetHelpFor([]string{consts.MCPStr, consts.StartStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			McpStartCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, startCmd, func(f *pflag.FlagSet) {
+		f.String("transport", string(defaultConfig.Transport), "mcp transport (http or sse)")
+		f.String("listen", defaultConfig.ListenAddress, "listen address for the MCP server")
+		f.String("name", defaultConfig.ServerName, "server name for MCP initialize")
+		f.String("version", defaultConfig.ServerVersion, "server version for MCP initialize")
+	})
+	flags.BindFlagCompletions(startCmd, func(comp *carapace.ActionMap) {
+		(*comp)["transport"] = carapace.ActionValues("http", "sse")
+	})
+	mcpCmd.AddCommand(startCmd)
+
+	stopCmd := &cobra.Command{
+		Use:   consts.StopStr,
+		Short: "Stop the MCP server",
+		Long:  help.GetHelpFor([]string{consts.MCPStr, consts.StopStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			McpStopCmd(cmd, con, args)
+		},
+	}
+	mcpCmd.AddCommand(stopCmd)
+
+	consoleCmd := &cobra.Command{
+		Use:     "console",
+		Aliases: []string{"repl"},
+		Short:   "Open an MCP console session",
+		Long:    help.GetHelpFor([]string{consts.MCPStr, "console"}),
+		Run: func(cmd *cobra.Command, args []string) {
+			McpConsoleCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("", false, consoleCmd, func(f *pflag.FlagSet) {
+		f.String("transport", string(defaultConfig.Transport), "mcp transport (http or sse)")
+		f.String("url", "", "mcp server URL (defaults to local server settings)")
+	})
+	flags.BindFlagCompletions(consoleCmd, func(comp *carapace.ActionMap) {
+		(*comp)["transport"] = carapace.ActionValues("http", "sse")
+	})
+	mcpCmd.AddCommand(consoleCmd)
+
+	return []*cobra.Command{mcpCmd}
+}

client/command/mcp/console.go

@@ -0,0 +1,132 @@
+package mcp
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/console"
+	clientmcp "github.com/bishopfox/sliver/client/mcp"
+	"github.com/bishopfox/sliver/client/version"
+	mcpclient "github.com/mark3labs/mcp-go/client"
+	mcpapi "github.com/mark3labs/mcp-go/mcp"
+	"github.com/spf13/cobra"
+)
+
+// McpConsoleCmd connects to an MCP server and starts a minimal console.
+func McpConsoleCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	rawTransport, _ := cmd.Flags().GetString("transport")
+	transport, err := clientmcp.ParseTransport(rawTransport)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	targetURL, _ := cmd.Flags().GetString("url")
+	if targetURL == "" {
+		cfg := clientmcp.GetStatus().Config.WithDefaults()
+		cfg.Transport = transport
+		targetURL, err = cfg.EndpointURL()
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+	}
+
+	client, err := newConsoleClient(transport, targetURL)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	defer client.Close()
+
+	ctx := context.Background()
+	if err := client.Start(ctx); err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	_, err = client.Initialize(ctx, mcpapi.InitializeRequest{
+		Params: mcpapi.InitializeParams{
+			ProtocolVersion: mcpapi.LATEST_PROTOCOL_VERSION,
+			ClientInfo: mcpapi.Implementation{
+				Name:    "sliver-mcp-console",
+				Version: version.Version,
+			},
+			Capabilities: mcpapi.ClientCapabilities{},
+		},
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	con.PrintInfof("Connected to MCP server (%s)\n", targetURL)
+	runConsoleREPL(ctx, client, cmd.InOrStdin(), cmd.OutOrStdout())
+}
+
+func newConsoleClient(transport clientmcp.Transport, targetURL string) (*mcpclient.Client, error) {
+	switch transport {
+	case clientmcp.TransportHTTP:
+		return mcpclient.NewStreamableHttpClient(targetURL)
+	case clientmcp.TransportSSE:
+		return mcpclient.NewSSEMCPClient(targetURL)
+	default:
+		return nil, fmt.Errorf("unsupported transport %q", transport)
+	}
+}
+
+func runConsoleREPL(ctx context.Context, client *mcpclient.Client, in io.Reader, out io.Writer) {
+	reader := bufio.NewReader(in)
+	for {
+		fmt.Fprint(out, "mcp> ")
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				fmt.Fprintln(out)
+				return
+			}
+			fmt.Fprintf(out, "read error: %s\n", err)
+			return
+		}
+		line = strings.TrimSpace(line)
+		switch line {
+		case "":
+			continue
+		case "exit", "quit":
+			return
+		case "help", "?":
+			printConsoleHelp(out)
+		case "tools":
+			printConsoleTools(ctx, client, out)
+		default:
+			fmt.Fprintf(out, "unknown command: %s\n", line)
+		}
+	}
+}
+
+func printConsoleHelp(out io.Writer) {
+	fmt.Fprintln(out, "commands: tools, help, exit")
+}
+
+func printConsoleTools(ctx context.Context, client *mcpclient.Client, out io.Writer) {
+	tools, err := client.ListTools(ctx, mcpapi.ListToolsRequest{})
+	if err != nil {
+		fmt.Fprintf(out, "tools error: %s\n", err)
+		return
+	}
+	if len(tools.Tools) == 0 {
+		fmt.Fprintln(out, "no tools available")
+		return
+	}
+	for _, tool := range tools.Tools {
+		if tool.Description != "" {
+			fmt.Fprintf(out, "- %s: %s\n", tool.Name, tool.Description)
+			continue
+		}
+		fmt.Fprintf(out, "- %s\n", tool.Name)
+	}
+}

client/command/mcp/mcp.go

@@ -0,0 +1,37 @@
+package mcp
+
+import (
+	"time"
+
+	"github.com/bishopfox/sliver/client/console"
+	clientmcp "github.com/bishopfox/sliver/client/mcp"
+	"github.com/spf13/cobra"
+)
+
+// McpCmd prints the current MCP server state.
+func McpCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	status := clientmcp.GetStatus()
+	state := "stopped"
+	if status.Running {
+		state = "running"
+	}
+
+	con.Printf("Status: %s\n", state)
+	con.Printf("Transport: %s\n", status.Config.Transport)
+	con.Printf("Listen: %s\n", status.Config.ListenAddress)
+
+	endpoint, err := status.Config.EndpointURL()
+	if err == nil {
+		con.Printf("Endpoint: %s\n", endpoint)
+	} else {
+		con.PrintErrorf("Endpoint: %s\n", err)
+	}
+
+	if status.Running && !status.StartedAt.IsZero() {
+		uptime := time.Since(status.StartedAt).Truncate(time.Second)
+		con.Printf("Uptime: %s\n", uptime)
+	}
+	if status.LastError != "" {
+		con.PrintErrorf("Last error: %s\n", status.LastError)
+	}
+}

client/command/mcp/start.go

@@ -0,0 +1,39 @@
+package mcp
+
+import (
+	"github.com/bishopfox/sliver/client/console"
+	slivermcp "github.com/bishopfox/sliver/client/mcp"
+	"github.com/spf13/cobra"
+)
+
+// McpStartCmd starts the local MCP server.
+func McpStartCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	rawTransport, _ := cmd.Flags().GetString("transport")
+	transport, err := slivermcp.ParseTransport(rawTransport)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	listen, _ := cmd.Flags().GetString("listen")
+	name, _ := cmd.Flags().GetString("name")
+	version, _ := cmd.Flags().GetString("version")
+
+	cfg := slivermcp.Config{
+		Transport:     transport,
+		ListenAddress: listen,
+		ServerName:    name,
+		ServerVersion: version,
+	}.WithDefaults()
+
+	if err := slivermcp.Start(cfg, con.Rpc); err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	con.PrintInfof("Starting MCP server (%s) on %s\n", cfg.Transport, cfg.ListenAddress)
+	endpoint, err := cfg.EndpointURL()
+	if err == nil {
+		con.PrintInfof("Endpoint: %s\n", endpoint)
+	}
+}

client/command/mcp/stop.go

@@ -0,0 +1,24 @@
+package mcp
+
+import (
+	"context"
+	"time"
+
+	"github.com/bishopfox/sliver/client/console"
+	clientmcp "github.com/bishopfox/sliver/client/mcp"
+	"github.com/spf13/cobra"
+)
+
+const mcpStopTimeout = 5 * time.Second
+
+// McpStopCmd stops the local MCP server.
+func McpStopCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	ctx, cancel := context.WithTimeout(context.Background(), mcpStopTimeout)
+	defer cancel()
+
+	if err := clientmcp.Stop(ctx); err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	con.PrintInfof("MCP server stopped\n")
+}

client/command/monitor/config.go

@@ -22,9 +22,9 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/jedib0t/go-pretty/v6/table"
@@ -121,11 +121,7 @@ func selectWatchtowerConfig(configs *clientpb.MonitoringProviders) (*clientpb.Mo
 	}
 
 	selected := ""
-	prompt := &survey.Select{
-		Message: "Select a configuration:",
-		Options: options,
-	}
-	err := survey.AskOne(prompt, &selected)
+	err := forms.Select("Select a configuration:", options, &selected)
 	if err != nil {
 		return nil, err
 	}

client/command/pivots/helpers.go

@@ -27,8 +27,8 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/rsteube/carapace"
 )
@@ -49,11 +49,7 @@ func SelectPivotListener(listeners []*sliverpb.PivotListener, con *console.Slive
 	}
 
 	selected := ""
-	prompt := &survey.Select{
-		Message: "Select a beacon task:",
-		Options: options,
-	}
-	err := survey.AskOne(prompt, &selected)
+	err := forms.Select("Select a beacon task:", options, &selected)
 	if err != nil {
 		return nil, err
 	}

client/command/privilege/getsystem.go

@@ -26,6 +26,7 @@ import (
 	"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"
 )
@@ -44,6 +45,17 @@ func GetSystemCmd(cmd *cobra.Command, con *console.SliverClient, args []string)
 
 	process, _ := cmd.Flags().GetString("process")
 	config := con.GetActiveSessionConfig()
+
+	/* If the HTTP C2 Config name is not defined, then put in the default value
+	   This will have no effect on implants that do not use HTTP C2
+	   Also this should be overridden when the build info is pulled from the
+	   database, but if there is no build info and we have to create the build
+	   from scratch, we need to have something in here.
+	*/
+	if config.HTTPC2ConfigName == "" {
+		config.HTTPC2ConfigName = consts.DefaultC2Profile
+	}
+
 	ctrl := make(chan bool)
 	con.SpinUntil("Attempting to create a new sliver session as 'NT AUTHORITY\\SYSTEM'...", ctrl)
 

client/command/reaction/reload.go

@@ -21,8 +21,8 @@ package reaction
 import (
 	"os"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/spf13/cobra"
 )
 
@@ -33,8 +33,7 @@ func ReactionReloadCmd(cmd *cobra.Command, con *console.SliverClient, args []str
 		return
 	}
 	confirm := false
-	prompt := &survey.Confirm{Message: "Reload reactions from disk?"}
-	survey.AskOne(prompt, &confirm)
+	_ = forms.Confirm("Reload reactions from disk?", &confirm)
 	if !confirm {
 		return
 	}

client/command/reaction/save.go

@@ -22,9 +22,9 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/spf13/cobra"
 )
 
@@ -33,8 +33,7 @@ func ReactionSaveCmd(cmd *cobra.Command, con *console.SliverClient, args []strin
 	reactionPath := GetReactionFilePath()
 	if _, err := os.Stat(reactionPath); !os.IsNotExist(err) {
 		confirm := false
-		prompt := &survey.Confirm{Message: fmt.Sprintf("Overwrite reactions (%s) on disk?", reactionPath)}
-		survey.AskOne(prompt, &confirm)
+		_ = forms.Confirm(fmt.Sprintf("Overwrite reactions (%s) on disk?", reactionPath), &confirm)
 		if !confirm {
 			return
 		}

client/command/reaction/set.go

@@ -22,9 +22,9 @@ import (
 	"errors"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/spf13/cobra"
 )
 
@@ -77,12 +77,8 @@ func getEventType(cmd *cobra.Command, con *console.SliverClient) (string, error)
 }
 
 func selectEventType(con *console.SliverClient) (string, error) {
-	prompt := &survey.Select{
-		Message: "Select an event:",
-		Options: core.ReactableEvents,
-	}
 	selection := ""
-	err := survey.AskOne(prompt, &selection)
+	err := forms.Select("Select an event:", core.ReactableEvents, &selection)
 	if err != nil {
 		return "", err
 	}
@@ -96,9 +92,6 @@ func selectEventType(con *console.SliverClient) (string, error) {
 
 func userCommands() (string, error) {
 	text := ""
-	prompt := &survey.Multiline{
-		Message: "Enter commands: ",
-	}
-	err := survey.AskOne(prompt, &text)
+	err := forms.Text("Enter commands:", &text)
 	return text, err
 }

client/command/reaction/unset.go

@@ -25,9 +25,9 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/spf13/cobra"
 )
 
@@ -65,13 +65,8 @@ func selectReaction(con *console.SliverClient) (*core.Reaction, error) {
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove blank line at the end
 
-	// Prompt user with options
-	prompt := &survey.Select{
-		Message: "Select a reaction:",
-		Options: options,
-	}
 	selection := ""
-	err := survey.AskOne(prompt, &selection)
+	err := forms.Select("Select a reaction:", options, &selection)
 	if err != nil {
 		return nil, err
 	}

client/command/server.go

@@ -22,6 +22,7 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/bishopfox/sliver/client/command/aka"
 	"github.com/bishopfox/sliver/client/command/alias"
 	"github.com/bishopfox/sliver/client/command/armory"
 	"github.com/bishopfox/sliver/client/command/beacons"
@@ -39,6 +40,7 @@ import (
 	"github.com/bishopfox/sliver/client/command/jobs"
 	"github.com/bishopfox/sliver/client/command/licenses"
 	"github.com/bishopfox/sliver/client/command/loot"
+	"github.com/bishopfox/sliver/client/command/mcp"
 	"github.com/bishopfox/sliver/client/command/monitor"
 	"github.com/bishopfox/sliver/client/command/operators"
 	"github.com/bishopfox/sliver/client/command/reaction"
@@ -101,11 +103,13 @@ func ServerCommands(con *client.SliverClient, serverCmds func() []*cobra.Command
 			crack.Commands,
 			certificates.Commands,
 			clean.Command,
+      aka.ServerCommands,
 		)
 
 		// C2 Network
 		bind(consts.NetworkHelpGroup,
 			jobs.Commands,
+			mcp.Commands,
 			websites.Commands,
 			wireguard.Commands,
 			c2profiles.Commands,

client/command/sessions/commands.go

@@ -43,6 +43,7 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		(*comp)["interact"] = SessionIDCompleter(con)
 		(*comp)["kill"] = SessionIDCompleter(con)
 	})
+	registerSessionIDFlagCompletion(sessionsCmd, "interact", con)
 
 	sessionsPruneCmd := &cobra.Command{
 		Use:   consts.PruneStr,
@@ -63,26 +64,78 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 // SessionIDCompleter completes session IDs.
 func SessionIDCompleter(con *console.SliverClient) carapace.Action {
 	callback := func(_ carapace.Context) carapace.Action {
-		results := make([]string, 0)
-
-		sessions, err := con.Rpc.GetSessions(context.Background(), &commonpb.Empty{})
-		if err == nil {
-			for _, s := range sessions.Sessions {
-				link := fmt.Sprintf("[%s <- %s]", s.ActiveC2, s.RemoteAddress)
-				id := fmt.Sprintf("%s (%d)", s.Name, s.PID)
-				userHost := fmt.Sprintf("%s@%s", s.Username, s.Hostname)
-				desc := strings.Join([]string{id, userHost, link}, " ")
-
-				results = append(results, s.ID[:8])
-				results = append(results, desc)
-			}
-		}
-		return carapace.ActionValuesDescribed(results...).Tag("sessions")
+		return carapace.ActionValuesDescribed(sessionCompletionPairs(con)...).Tag("sessions")
 	}
 
 	return carapace.ActionCallback(callback)
 }
 
+func registerSessionIDFlagCompletion(cmd *cobra.Command, name string, con *console.SliverClient) {
+	if cmd == nil {
+		return
+	}
+	if _, ok := cmd.GetFlagCompletionFunc(name); ok {
+		return
+	}
+	if cmd.Flags().Lookup(name) == nil && cmd.PersistentFlags().Lookup(name) == nil {
+		return
+	}
+	_ = cmd.RegisterFlagCompletionFunc(name, func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		values := describedValuesToTabs(sessionCompletionPairs(con))
+		return filterCompletionValues(values, toComplete), cobra.ShellCompDirectiveNoFileComp
+	})
+}
+
+func sessionCompletionPairs(con *console.SliverClient) []string {
+	results := make([]string, 0)
+	if con == nil || con.Rpc == nil {
+		return results
+	}
+
+	sessions, err := con.Rpc.GetSessions(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return results
+	}
+
+	for _, s := range sessions.Sessions {
+		link := fmt.Sprintf("[%s <- %s]", s.ActiveC2, s.RemoteAddress)
+		id := fmt.Sprintf("%s (%d)", s.Name, s.PID)
+		userHost := fmt.Sprintf("%s@%s", s.Username, s.Hostname)
+		desc := strings.Join([]string{id, userHost, link}, " ")
+
+		results = append(results, s.ID[:8], desc)
+	}
+
+	return results
+}
+
+func describedValuesToTabs(values []string) []string {
+	tabbed := make([]string, 0, len(values)/2)
+	for i := 0; i+1 < len(values); i += 2 {
+		tabbed = append(tabbed, fmt.Sprintf("%s\t%s", values[i], values[i+1]))
+	}
+	return tabbed
+}
+
+func filterCompletionValues(values []string, prefix string) []string {
+	if prefix == "" {
+		return values
+	}
+
+	filtered := make([]string, 0, len(values))
+	for _, value := range values {
+		candidate := value
+		if tab := strings.IndexByte(value, '\t'); tab >= 0 {
+			candidate = value[:tab]
+		}
+		if strings.HasPrefix(candidate, prefix) {
+			filtered = append(filtered, value)
+		}
+	}
+
+	return filtered
+}
+
 // SliverCommands returns all session control commands for the active target.
 func SliverCommands(con *console.SliverClient) []*cobra.Command {
 	backgroundCmd := &cobra.Command{

client/command/sessions/helpers.go

@@ -27,8 +27,8 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
@@ -85,12 +85,8 @@ func SelectSession(onlyAlive bool, con *console.SliverClient) (*clientpb.Session
 
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
-	prompt := &survey.Select{
-		Message: "Select a session:",
-		Options: options,
-	}
 	selected := ""
-	survey.AskOne(prompt, &selected)
+	_ = forms.Select("Select a session:", options, &selected)
 	if selected == "" {
 		return nil, ErrNoSelection
 	}

client/command/settings/commands.go

@@ -19,6 +19,7 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		},
 		GroupID: consts.GenericHelpGroup,
 	}
+	settingsCmd.Flags().Bool("show", false, "Show current settings without prompting")
 	settingsCmd.AddCommand(&cobra.Command{
 		Use:   consts.SaveStr,
 		Short: "Save the current settings to disk",

client/command/settings/opsec.go

@@ -19,9 +19,9 @@ package settings
 */
 
 import (
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/spf13/cobra"
 )
 
@@ -45,8 +45,7 @@ func IsUserAnAdult(con *console.SliverClient) bool {
 		return true
 	}
 	confirm := false
-	prompt := &survey.Confirm{Message: "This action is bad OPSEC, are you an adult?"}
-	survey.AskOne(prompt, &confirm, nil)
+	_ = forms.Confirm("This action is bad OPSEC, are you an adult?", &confirm)
 	return confirm
 }
 

client/command/settings/settings.go

@@ -19,11 +19,13 @@ package settings
 */
 
 import (
+	"errors"
 	"strconv"
+	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
 )
@@ -39,6 +41,25 @@ func SettingsCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 		}
 	}
 
+	if shouldRunSettingsForm(cmd, con, args) {
+		tableStyleOptions := make([]string, 0, len(tableStyles))
+		for option := range tableStyles {
+			tableStyleOptions = append(tableStyleOptions, option)
+		}
+		result, err := forms.SettingsForm(con.Settings, tableStyleOptions)
+		if err != nil {
+			if errors.Is(err, forms.ErrUserAborted) {
+				return
+			}
+			con.PrintErrorf("Settings form failed: %s\n", err)
+			return
+		}
+		if err := applySettingsForm(con.Settings, result); err != nil {
+			con.PrintErrorf("Failed to apply settings form values: %s\n", err)
+			return
+		}
+	}
+
 	tw := table.NewWriter()
 	tw.SetStyle(GetTableStyle(con))
 	tw.AppendHeader(table.Row{"Name", "Value", "Description"})
@@ -48,6 +69,7 @@ func SettingsCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	tw.AppendRow(table.Row{"Small Term Width", con.Settings.SmallTermWidth, "Omit some table columns when terminal width is less than this value"})
 	tw.AppendRow(table.Row{"Always Overflow", con.Settings.AlwaysOverflow, "Disable table pagination"})
 	tw.AppendRow(table.Row{"Vim Mode", con.Settings.VimMode, "Navigation mode, vim style"})
+	tw.AppendRow(table.Row{"User Connect", con.Settings.UserConnect, "Show operator connect/disconnect events"})
 	tw.AppendRow(table.Row{"Console Logs", con.Settings.ConsoleLogs, "Log console output to disk"})
 	con.Printf("%s\n", tw.Render())
 }
@@ -91,8 +113,7 @@ func SettingsSmallTerm(cmd *cobra.Command, con *console.SliverClient, args []str
 		}
 	}
 	result := ""
-	prompt := &survey.Input{Message: "Set small width:"}
-	err = survey.AskOne(prompt, &result)
+	err = forms.Input("Set small width:", &result)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -126,11 +147,7 @@ func SettingsTablesCmd(cmd *cobra.Command, con *console.SliverClient, args []str
 		options = append(options, option)
 	}
 	style := ""
-	prompt := &survey.Select{
-		Message: "Choose a style:",
-		Options: options,
-	}
-	err = survey.AskOne(prompt, &style)
+	err = forms.Select("Choose a style:", options, &style)
 	if err != nil {
 		con.PrintErrorf("No selection\n")
 		return
@@ -173,3 +190,45 @@ func SettingsUserConnect(cmd *cobra.Command, con *console.SliverClient, args []s
 	con.Settings.UserConnect = !con.Settings.UserConnect
 	con.PrintInfof("User connect events = %v\n", con.Settings.UserConnect)
 }
+
+func shouldRunSettingsForm(cmd *cobra.Command, con *console.SliverClient, args []string) bool {
+	if con == nil || con.IsCLI {
+		return false
+	}
+	if len(args) != 0 {
+		return false
+	}
+	if show, err := cmd.Flags().GetBool("show"); err == nil && show {
+		return false
+	}
+	return cmd.Flags().NFlag() == 0
+}
+
+func applySettingsForm(settings *assets.ClientSettings, result *forms.SettingsFormResult) error {
+	if settings == nil {
+		return errors.New("settings are required")
+	}
+	if result == nil {
+		return errors.New("settings form result is required")
+	}
+	if _, ok := tableStyles[result.TableStyle]; !ok {
+		return errors.New("invalid table style")
+	}
+	width, err := strconv.Atoi(strings.TrimSpace(result.SmallTermWidth))
+	if err != nil {
+		return err
+	}
+	if width < 1 {
+		return errors.New("small terminal width must be 1 or greater")
+	}
+
+	settings.TableStyle = result.TableStyle
+	settings.AutoAdult = result.AutoAdult
+	settings.BeaconAutoResults = result.BeaconAutoResults
+	settings.SmallTermWidth = width
+	settings.AlwaysOverflow = result.AlwaysOverflow
+	settings.VimMode = result.VimMode
+	settings.UserConnect = result.UserConnect
+	settings.ConsoleLogs = result.ConsoleLogs
+	return nil
+}

client/command/settings/tables.go

@@ -22,9 +22,9 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/jedib0t/go-pretty/v6/text"
 	"golang.org/x/term"
@@ -212,10 +212,7 @@ func PaginateTable(tw table.Writer, skipPages int, overflow bool, interactive bo
 			if 1 < len(pages) {
 				if pageNumber+1 < len(pages) {
 					nextPage := false
-					prompt := &survey.Confirm{
-						Message: fmt.Sprintf("[%d/%d] Continue?", pageNumber+1, len(pages)),
-					}
-					survey.AskOne(prompt, &nextPage)
+					_ = forms.Confirm(fmt.Sprintf("[%d/%d] Continue?", pageNumber+1, len(pages)), &nextPage)
 					if !nextPage {
 						break
 					}

client/command/sliver.go

@@ -22,6 +22,7 @@ import (
 	"fmt"
 
 	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/aka"
 	"github.com/bishopfox/sliver/client/command/alias"
 	"github.com/bishopfox/sliver/client/command/backdoor"
 	"github.com/bishopfox/sliver/client/command/cursed"
@@ -78,6 +79,7 @@ func SliverCommands(con *client.SliverClient) console.Commands {
 			// use.Commands,
 			tasks.Commands,
 			pivots.Commands,
+      aka.ImplantCommands,
 		)
 
 		// [ Info ]

client/command/socks/socks-start.go

@@ -27,8 +27,8 @@ import (
 
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/spf13/cobra"
-	"gopkg.in/AlecAivazis/survey.v1"
 )
 
 // SocksStartCmd - Add a new tunneled port forward.
@@ -56,8 +56,7 @@ func SocksStartCmd(cmd *cobra.Command, con *console.SliverClient, args []string)
 		con.PrintWarnf("SOCKS proxy authentication credentials are tunneled to the implant\n")
 		con.PrintWarnf("These credentials are recoverable from the implant's memory!\n\n")
 		confirm := false
-		prompt := &survey.Confirm{Message: "Do you understand the implication?"}
-		survey.AskOne(prompt, &confirm, nil)
+		_ = forms.Confirm("Do you understand the implication?", &confirm)
 		if !confirm {
 			return
 		}

client/command/taskmany/taskmany.go

@@ -29,10 +29,10 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
@@ -214,12 +214,8 @@ func SelectMultipleBeaconsAndSessions(con *console.SliverClient) ([]*clientpb.Se
 
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
-	prompt := &survey.MultiSelect{
-		Message: "Select sessions and beacons:",
-		Options: options,
-	}
 	selected := []string{}
-	survey.AskOne(prompt, &selected)
+	_ = forms.MultiSelect("Select sessions and beacons:", options, &selected)
 
 	if len(selected) == 0 {
 		return nil, nil, fmt.Errorf("no sessions or beacons selected 🤔")

client/command/tasks/fetch.go

@@ -24,7 +24,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/environment"
 	"github.com/bishopfox/sliver/client/command/exec"
 	"github.com/bishopfox/sliver/client/command/extensions"
@@ -36,6 +35,7 @@ import (
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util"
@@ -750,11 +750,7 @@ func taskResponseDownload(download *sliverpb.Download, con *console.SliverClient
 		saveTo = "Save to File ..."
 	)
 	action := saveTo
-	prompt := &survey.Select{
-		Message: "Choose an option:",
-		Options: []string{dump, saveTo},
-	}
-	err := survey.AskOne(prompt, &action, survey.WithValidator(survey.Required))
+	err := forms.SelectRequired("Choose an option:", []string{dump, saveTo}, &action)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -769,16 +765,14 @@ func taskResponseDownload(download *sliverpb.Download, con *console.SliverClient
 
 func promptSaveToFile(data []byte, con *console.SliverClient) {
 	saveTo := ""
-	saveToPrompt := &survey.Input{Message: "Save to: "}
-	err := survey.AskOne(saveToPrompt, &saveTo)
+	err := forms.Input("Save to:", &saveTo)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
 	if _, err := os.Stat(saveTo); !os.IsNotExist(err) {
 		confirm := false
-		prompt := &survey.Confirm{Message: "Overwrite existing file?"}
-		survey.AskOne(prompt, &confirm)
+		_ = forms.Confirm("Overwrite existing file?", &confirm)
 		if !confirm {
 			return
 		}

client/command/tasks/helpers.go

@@ -9,8 +9,8 @@ import (
 	"text/tabwriter"
 	"time"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/rsteube/carapace"
 )
@@ -32,11 +32,7 @@ func SelectBeaconTask(tasks []*clientpb.BeaconTask) (*clientpb.BeaconTask, error
 	}
 
 	selected := ""
-	prompt := &survey.Select{
-		Message: "Select a beacon task:",
-		Options: options,
-	}
-	err := survey.AskOne(prompt, &selected)
+	err := forms.Select("Select a beacon task:", options, &selected)
 	if err != nil {
 		return nil, err
 	}

client/command/update/update.go

@@ -28,16 +28,15 @@ import (
 	"net/url"
 	"os"
 	"os/user"
-	"path"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"time"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/version"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/util"
@@ -57,14 +56,12 @@ func UpdateCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 		con.Println()
 		con.Println(console.Warn + "You're trying to update over an insecure connection, this is a really bad idea!")
 		confirm := false
-		prompt := &survey.Confirm{Message: "Recklessly update?"}
-		survey.AskOne(prompt, &confirm)
+		forms.Confirm("Recklessly update?", &confirm)
 		if !confirm {
 			return
 		}
 		confirm = false
-		prompt = &survey.Confirm{Message: "Seriously?"}
-		survey.AskOne(prompt, &confirm)
+		forms.Confirm("Seriously?", &confirm)
 		if !confirm {
 			return
 		}
@@ -115,9 +112,9 @@ func UpdateCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 		con.PrintInfof("No new releases.\n")
 	}
 	now := time.Now()
-	lastCheck := []byte(fmt.Sprintf("%d", now.Unix()))
+	lastCheck := fmt.Appendf(nil, "%d", now.Unix())
 	appDir := assets.GetRootAppDir()
-	lastUpdateCheckPath := path.Join(appDir, consts.LastUpdateCheckFileName)
+	lastUpdateCheckPath := filepath.Join(appDir, consts.LastUpdateCheckFileName)
 	err = os.WriteFile(lastUpdateCheckPath, lastCheck, 0o600)
 	if err != nil {
 		con.Printf("Failed to save update check time %s", err)
@@ -231,10 +228,7 @@ func updateAvailable(con *console.SliverClient, client *http.Client, release *ve
 	con.Println()
 
 	confirm := false
-	prompt := &survey.Confirm{
-		Message: "Download update?",
-	}
-	survey.AskOne(prompt, &confirm)
+	forms.Confirm("Download update?", &confirm)
 	if confirm {
 		con.Printf("Please wait ...")
 		err := downloadAsset(client, serverAsset, saveTo)

client/command/use/commands.go

@@ -27,6 +27,7 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
 	})
 	carapace.Gen(useCmd).PositionalCompletion(BeaconAndSessionIDCompleter(con))
+	registerUseIDCompletion(useCmd, con, true, true)
 
 	useSessionCmd := &cobra.Command{
 		Use:   consts.SessionsStr,
@@ -37,6 +38,7 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		},
 	}
 	carapace.Gen(useSessionCmd).PositionalCompletion(SessionIDCompleter(con))
+	registerUseIDCompletion(useSessionCmd, con, true, false)
 	useCmd.AddCommand(useSessionCmd)
 
 	useBeaconCmd := &cobra.Command{
@@ -48,6 +50,7 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		},
 	}
 	carapace.Gen(useBeaconCmd).PositionalCompletion(beacons.BeaconIDCompleter(con))
+	registerUseIDCompletion(useBeaconCmd, con, false, true)
 	useCmd.AddCommand(useBeaconCmd)
 
 	return []*cobra.Command{useCmd}

client/command/use/use.go

@@ -27,18 +27,89 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/rsteube/carapace"
 	"github.com/spf13/cobra"
 
 	"github.com/bishopfox/sliver/client/command/beacons"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
 
 var ErrNoSelection = errors.New("no selection")
 
+func registerUseIDCompletion(cmd *cobra.Command, con *console.SliverClient, includeSessions, includeBeacons bool) {
+	if cmd == nil || cmd.ValidArgsFunction != nil {
+		return
+	}
+
+	cmd.ValidArgsFunction = func(_ *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		if len(args) > 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+
+		values := useCompletionValues(con, includeSessions, includeBeacons)
+		return filterCompletionValues(values, toComplete), cobra.ShellCompDirectiveNoFileComp
+	}
+}
+
+func useCompletionValues(con *console.SliverClient, includeSessions, includeBeacons bool) []string {
+	results := []string{}
+	if con == nil || con.Rpc == nil {
+		return results
+	}
+
+	if includeSessions {
+		sessions, err := con.Rpc.GetSessions(context.Background(), &commonpb.Empty{})
+		if err == nil {
+			for _, session := range sessions.Sessions {
+				link := fmt.Sprintf("[%s <- %s]", session.ActiveC2, session.RemoteAddress)
+				id := fmt.Sprintf("%s (%d)", session.Name, session.PID)
+				userHost := fmt.Sprintf("%s@%s", session.Username, session.Hostname)
+				desc := strings.Join([]string{id, userHost, link}, " ")
+
+				results = append(results, fmt.Sprintf("%s\t%s", session.ID[:8], desc))
+			}
+		}
+	}
+
+	if includeBeacons {
+		beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+		if err == nil {
+			for _, beacon := range beacons.Beacons {
+				link := fmt.Sprintf("[%s <- %s]", beacon.ActiveC2, beacon.RemoteAddress)
+				id := fmt.Sprintf("%s (%d)", beacon.Name, beacon.PID)
+				userHost := fmt.Sprintf("%s@%s", beacon.Username, beacon.Hostname)
+				desc := strings.Join([]string{id, userHost, link}, " ")
+
+				results = append(results, fmt.Sprintf("%s\t%s", beacon.ID[:8], desc))
+			}
+		}
+	}
+
+	return results
+}
+
+func filterCompletionValues(values []string, prefix string) []string {
+	if prefix == "" {
+		return values
+	}
+
+	filtered := make([]string, 0, len(values))
+	for _, value := range values {
+		candidate := value
+		if tab := strings.IndexByte(value, '\t'); tab >= 0 {
+			candidate = value[:tab]
+		}
+		if strings.HasPrefix(candidate, prefix) {
+			filtered = append(filtered, value)
+		}
+	}
+
+	return filtered
+}
+
 // UseCmd - Change the active session
 func UseCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	var session *clientpb.Session
@@ -74,8 +145,7 @@ func SessionOrBeaconByID(id string, con *console.SliverClient) (*clientpb.Sessio
 	sessions, err := con.Rpc.GetSessions(context.Background(), &commonpb.Empty{})
 	if err != nil {
 		return nil, nil, err
-	}
-	if err == nil {
+	} else {
 		for _, session := range sessions.Sessions {
 			if strings.HasPrefix(session.ID, id) {
 				return session, nil, nil
@@ -162,12 +232,8 @@ func SelectSessionOrBeacon(con *console.SliverClient) (*clientpb.Session, *clien
 
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
-	prompt := &survey.Select{
-		Message: "Select a session or beacon:",
-		Options: options,
-	}
 	selected := ""
-	survey.AskOne(prompt, &selected)
+	_ = forms.Select("Select a session or beacon:", options, &selected)
 	if selected == "" {
 		return nil, nil, ErrNoSelection
 	}

client/command/websites/websites-add-content.go

@@ -27,8 +27,8 @@ import (
 	"path"
 	"path/filepath"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/spf13/cobra"
 )
@@ -130,8 +130,7 @@ func webAddFile(web *clientpb.WebsiteAddContent, webpath string, contentType str
 
 func confirmAddDirectory() bool {
 	confirm := false
-	prompt := &survey.Confirm{Message: "Recursively add entire directory?"}
-	survey.AskOne(prompt, &confirm, nil)
+	_ = forms.Confirm("Recursively add entire directory?", &confirm)
 	return confirm
 }
 

client/console/command_fallback.go

@@ -0,0 +1,195 @@
+package console
+
+import (
+	"strings"
+
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/reeflective/console"
+	"github.com/spf13/cobra"
+)
+
+func (con *SliverClient) allowServerRootCommands(args []string) ([]string, error) {
+	con.applyCommandFallback(args)
+	return args, nil
+}
+
+func (con *SliverClient) prepareCompletion(line []rune, cursor int) {
+	if con == nil || con.App == nil {
+		return
+	}
+
+	menu := con.App.ActiveMenu()
+	if menu == nil {
+		return
+	}
+
+	con.setMenuCommandForCompletion(menu, line, cursor)
+}
+
+func (con *SliverClient) applyCommandFallback(args []string) {
+	if con == nil || con.App == nil {
+		return
+	}
+
+	con.setMenuCommand(con.App.ActiveMenu(), args)
+}
+
+func (con *SliverClient) setMenuCommand(menu *console.Menu, args []string) {
+	if menu == nil {
+		return
+	}
+
+	if menu.Name() != consts.ImplantMenu {
+		if menu.Command == nil && con.serverCmds != nil {
+			menu.Command = con.serverCmds()
+		}
+		return
+	}
+
+	if menu.Command == nil {
+		if con.sliverCmds == nil {
+			return
+		}
+		menu.Command = con.sliverCmds()
+	}
+
+	if con.serverCmds == nil {
+		return
+	}
+
+	name := firstNonFlagArg(args)
+	if name == "" {
+		return
+	}
+
+	if rootHasCommand(menu.Command, name) {
+		return
+	}
+
+	serverRoot := con.serverCmds()
+	if serverRoot == nil || !rootHasCommand(serverRoot, name) {
+		return
+	}
+
+	menu.Command = serverRoot
+}
+
+func (con *SliverClient) setMenuCommandForCompletion(menu *console.Menu, line []rune, cursor int) {
+	if menu == nil || menu.Name() != consts.ImplantMenu {
+		return
+	}
+
+	if menu.Command == nil {
+		if con.sliverCmds == nil {
+			return
+		}
+		menu.Command = con.sliverCmds()
+	}
+
+	if con.serverCmds == nil {
+		return
+	}
+
+	token := firstTokenFromLine(line, cursor)
+	if token == "" {
+		return
+	}
+
+	if rootHasCommandPrefix(menu.Command, token) {
+		return
+	}
+
+	serverRoot := con.serverCmds()
+	if serverRoot == nil || !rootHasCommandPrefix(serverRoot, token) {
+		return
+	}
+
+	menu.Command = serverRoot
+	hideFilteredCommands(menu, menu.Command)
+}
+
+func firstNonFlagArg(args []string) string {
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		if arg == "--" {
+			if i+1 < len(args) {
+				return args[i+1]
+			}
+			return ""
+		}
+		if strings.HasPrefix(arg, "-") {
+			continue
+		}
+		return arg
+	}
+	return ""
+}
+
+func firstTokenFromLine(line []rune, cursor int) string {
+	if cursor > len(line) {
+		cursor = len(line)
+	}
+	if cursor < 0 {
+		cursor = 0
+	}
+
+	pos := 0
+	for pos < cursor && isSpace(line[pos]) {
+		pos++
+	}
+	start := pos
+	for pos < cursor && !isSpace(line[pos]) {
+		pos++
+	}
+	if start == pos {
+		return ""
+	}
+	return string(line[start:pos])
+}
+
+func isSpace(r rune) bool {
+	return r == ' ' || r == '\t' || r == '\n' || r == '\r'
+}
+
+func rootHasCommand(root *cobra.Command, name string) bool {
+	if root == nil || name == "" {
+		return false
+	}
+	for _, cmd := range root.Commands() {
+		if cmd.Name() == name || cmd.HasAlias(name) {
+			return true
+		}
+	}
+	return false
+}
+
+func rootHasCommandPrefix(root *cobra.Command, prefix string) bool {
+	if root == nil || prefix == "" {
+		return false
+	}
+	for _, cmd := range root.Commands() {
+		if strings.HasPrefix(cmd.Name(), prefix) {
+			return true
+		}
+		for _, alias := range cmd.Aliases {
+			if strings.HasPrefix(alias, prefix) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func hideFilteredCommands(menu *console.Menu, root *cobra.Command) {
+	if menu == nil || root == nil {
+		return
+	}
+	for _, cmd := range root.Commands() {
+		if cmd.Hidden {
+			continue
+		}
+		if filters := menu.ActiveFiltersFor(cmd); len(filters) > 0 {
+			cmd.Hidden = true
+		}
+	}
+}