Compare commits

..
Author SHA1 Message Date
shadowdaoandClaude Opus 5.5 73eb507cfe feat(docker): tell "not running" apart from "not installed"
Secret Scan / scan (push) Successful in 15s
Build App (Preview) / compute-version (pull_request) Successful in 7s
Secret Scan / scan (pull_request) Successful in 15s
Build App (Preview) / test (pull_request) Successful in 11m20s
Build App (Preview) / create-release (pull_request) Successful in 5s
Build App (Preview) / build-macos (pull_request) Successful in 6m51s
Build App (Preview) / build-linux (pull_request) Successful in 13m0s
Build App (Preview) / build-windows (pull_request) Successful in 13m49s
Build App (Preview) / prune-previews (pull_request) Successful in 2s
The app told a user whose Docker daemon had hit systemd start-limit-hit
to install Docker. New check_docker_status command classifies the ping
failure (io error kind in the bollard/hyper chain) plus cheap installed-
ness probes into running / not_running / no_permission / not_installed,
reports the endpoint tried (DOCKER_HOST respected), and the dialog, top
bar, welcome checklist and Docker settings show per-state guidance. The
dialog updates live from polling and closes when Docker comes up.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 12:26:37 -08:00
shadowdao 67b80f73c3 Merge remote-tracking branch 'origin/feat/bundle-ssm-plugin' into fix/hosts-ui 2026-11-17 12:21:35 -08:00
shadowdaoandClaude Opus 5.5 614e89bef4 fix(ssm-plugin): lock down the Windows work root; re-hash the output in place
Secret Scan / scan (push) Successful in 14s
Build App (Preview) / compute-version (pull_request) Successful in 14s
Secret Scan / scan (pull_request) Successful in 7s
Build App (Preview) / test (pull_request) Successful in 9m25s
Build App (Preview) / create-release (pull_request) Successful in 1s
Build App (Preview) / build-macos (pull_request) Successful in 6m40s
Build App (Preview) / build-linux (pull_request) Successful in 17m3s
Build App (Preview) / build-windows (pull_request) Successful in 13m53s
Build App (Preview) / prune-previews (pull_request) Successful in 2s
The short %SystemDrive%\ssm-<8hex> root inherited the drive root's ACL,
where Authenticated Users can write, so another local user could swap the
source, toolchain or output between verification and use. Right after
creating it, icacls removes inheritance and grants full control only to
SYSTEM, Administrators and the current user's SID; failure aborts. It is
mandatory on Windows and skipped only off Windows (the pwsh test path).
The binary is hashed again at its final location.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 08:21:55 -08:00
shadowdaoandClaude Opus 5.5 b62f472d79 fix(ssm-plugin): review fixes for the source build and signing checks
Secret Scan / scan (push) Successful in 11s
Build App (Preview) / compute-version (pull_request) Successful in 11s
Secret Scan / scan (pull_request) Successful in 12s
Build App (Preview) / create-release (pull_request) Successful in 1s
Build App (Preview) / build-macos (pull_request) Successful in 6m42s
Build App (Preview) / test (pull_request) Successful in 15m11s
Build App (Preview) / build-linux (pull_request) Successful in 13m45s
Build App (Preview) / build-windows (pull_request) Successful in 13m59s
Build App (Preview) / prune-previews (pull_request) Successful in 2s
- build-ssm-plugin.{sh,ps1}: skip the vendored SDK's Java codegen/ and
  test snapshot/ trees when extracting (codegen paths reach 258 chars,
  past MAX_PATH on Windows); the .ps1 works under a short
  %SystemDrive%\ssm-<8hex> root and falls back to rd /s /q on cleanup.
  Pinned output hashes unchanged (rebuilt every target).
- build-ssm-plugin.sh: the header no longer claims a git commit-id check.
- windows-verify-signatures.ps1: compare signer Subject + Issuer, not the
  thumbprint (Artifact Signing certificates rotate); require
  THIRD_PARTY_NOTICES in the MSI.
- windows-sign.ps1: allowlist exactly
  src-tauri\binaries\session-manager-plugin-x86_64-pc-windows-msvc.exe.
- macOS jobs: check the .app carries the two-slice plugin and
  Contents/Resources/THIRD_PARTY_NOTICES.
- CLAUDE.md: a local release build must re-run the build script.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 08:20:09 -08:00
shadowdaoandClaude Opus 5.5 5b23dc1aec build: build session-manager-plugin from source, not AWS's binaries
Build App (Preview) / compute-version (pull_request) Successful in 5s
Secret Scan / scan (push) Successful in 8s
Secret Scan / scan (pull_request) Successful in 7s
Build App (Preview) / create-release (pull_request) Successful in 2s
Build App (Preview) / build-macos (pull_request) Successful in 6m42s
Build App (Preview) / build-linux (pull_request) Successful in 12m41s
Build App (Preview) / build-windows (pull_request) Successful in 13m57s
Build App (Preview) / test (pull_request) Successful in 23m29s
Build App (Preview) / prune-previews (pull_request) Successful in 3s
AWS ships its prebuilt plugin as "AWS Content" under the AWS Customer
Agreement; the source is Apache-2.0. Replace the binary fetch with
scripts/build-ssm-plugin.sh (any triple, cross-compiles; universal via
lipo) and build-ssm-plugin.ps1 (Windows runner):

- source: tag 1.2.896.0 at commit 6430675a, GitHub archive SHA-256
  checked before extraction;
- Go 1.26.11 from go.dev, published SHA-256 checked before use;
- the repo's own build (GOPATH mode, vendored deps, -s -w,
  sessionmanagerplugin-main) with VERSION stamped to the tag, plus
  -trimpath, no VCS stamp, empty build id, CGO off;
- output must equal a pinned SHA-256 per target (reproducible builds).

Each platform job builds its own targets. Windows: the exe is now ours
and unsigned, so windows-sign.ps1 allowlists it and
windows-verify-signatures.ps1 requires it signed by the installer's own
certificate in the MSI and NSIS. THIRD_PARTY_NOTICES now carries the
source's LICENSE/NOTICE/THIRD-PARTY, the commit, every linked vendored
module's licence and Go's. AWS's GPG key and the AWS-signature checks
are gone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 08:12:11 -08:00
shadowdaoandClaude Opus 5.5 381158cca0 docs: the bundled AWS session-manager-plugin
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 06:44:30 -08:00
shadowdaoandClaude Opus 5.5 cb28d1da39 ci: fetch the SSM plugin before every build; check it ships
Both build workflows fetch the pinned plugin before tauri build on Linux,
macOS (universal: both slices plus the lipo'd file) and Windows. The test
job needs no fetch: debug builds get build.rs's placeholder.

finalize-appimage.sh asserts usr/bin/session-manager-plugin is a running
ELF and THIRD_PARTY_NOTICES is in the image.

Windows: the plugin ships under AWS's Authenticode signature and is not
re-signed (Tauri skips a sidecar signtool verify accepts).
windows-sign.ps1 refuses it if it is ever presented rather than letting the
allowlist skip it unsigned; windows-verify-signatures.ps1 requires it in
the MSI, valid, timestamped and signed by Amazon Web Services, Inc.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 06:44:30 -08:00
shadowdaoandClaude Opus 5.5 39f502dcdf feat(ssm): bundle session-manager-plugin as a sidecar and prefer it
bundle.externalBin ships the plugin beside the app binary (usr/bin in the
AppImage, Contents/MacOS, the Windows install dir) and THIRD_PARTY_NOTICES as
a resource. find_plugin() now resolves TRIPLEC_SSM_PLUGIN, then the bundled
sidecar next to current_exe(), then PATH and AWS's install locations, then
the install hint; the order is unit-tested against temp dirs.

tauri-build fails any build whose externalBin file is missing, so build.rs
writes a marked placeholder in debug builds (cargo test/check, tauri dev)
and refuses a missing file or a placeholder in release builds.
find_plugin() skips the placeholder.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 06:43:41 -08:00
shadowdaoandClaude Opus 5.5 05ac6b3e8c build: fetch a pinned, verified AWS session-manager-plugin
scripts/fetch-ssm-plugin.sh (Linux/macOS, incl. universal via lipo) and
scripts/fetch-ssm-plugin.ps1 (Windows) download plugin 1.2.896.0 from AWS's
S3 path into app/src-tauri/binaries/session-manager-plugin-<triple>[.exe],
checking a pinned SHA-256 of each artifact before extraction, AWS's GPG
signature on the Linux .deb (key committed, fingerprint pinned) or AWS's
Authenticode signature on Windows, and a pinned SHA-256 of the binary.

THIRD_PARTY_NOTICES reproduces the plugin's LICENSE (Apache-2.0), NOTICE
and AWS's THIRD-PARTY statement. The binaries directory is never committed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 06:43:41 -08:00
36 changed files with 2771 additions and 74 deletions

No files matched your search

+42 -1
View File
@@ -334,7 +334,9 @@ jobs:
run: npx vitest run
# `--locked`: test against the committed Cargo.lock, never a re-resolved
# one, for the same reason the frontend uses `npm ci`.
# one, for the same reason the frontend uses `npm ci`. No plugin fetch
# here: a debug build gets a placeholder for the session-manager-plugin
# sidecar from build.rs, so tests never build Go or download anything.
- name: Backend tests (cargo test)
working-directory: ./app/src-tauri
run: |
@@ -468,6 +470,14 @@ jobs:
export PATH="$HOME/.cargo/bin:$PATH"
npx tauri --version || npm install @tauri-apps/cli
# The AWS Session Manager plugin, bundled as a sidecar (bundle.externalBin)
# so AWS workspaces work without the user installing it. Built here from
# AWS's Apache-2.0 source (pinned commit + archive SHA-256) with a pinned,
# hash-checked Go; the output must match a pinned SHA-256 (reproducible
# build). A release build refuses to start without it (build.rs).
- name: Build the AWS Session Manager plugin
run: bash scripts/build-ssm-plugin.sh x86_64-unknown-linux-gnu
- name: Build Tauri app
working-directory: ./app
env:
@@ -597,6 +607,15 @@ jobs:
export PATH="$HOME/.cargo/bin:$PATH"
npx tauri --version || npm install @tauri-apps/cli
# The AWS Session Manager plugin sidecar (bundle.externalBin), built from
# source (see build-ssm-plugin.sh): both thin slices (tauri-build checks
# each arch it compiles) and the lipo'd universal one the bundler copies
# into Contents/MacOS. Each must match its pinned SHA-256. Signed exactly
# like the app: Go ad-hoc signs the arm64 slice, and with APPLE_* signing
# configured Tauri would sign the sidecar with the app's identity.
- name: Build the AWS Session Manager plugin
run: bash scripts/build-ssm-plugin.sh universal-apple-darwin
- name: Build Tauri app (universal)
working-directory: ./app
env:
@@ -606,6 +625,21 @@ jobs:
export PATH="$HOME/.cargo/bin:$PATH"
npx tauri build --target universal-apple-darwin
# The sidecar and its notices must be in the bundle Tauri made: the
# plugin in Contents/MacOS with both slices, THIRD_PARTY_NOTICES in
# Contents/Resources (bundle.resources).
- name: Check the bundled Session Manager plugin
run: |
app_dir="$(ls -d app/src-tauri/target/universal-apple-darwin/release/bundle/macos/*.app | head -n1)"
[ -n "$app_dir" ] || { echo "no .app bundle"; exit 1; }
plugin="$app_dir/Contents/MacOS/session-manager-plugin"
[ -x "$plugin" ] || { echo "missing $plugin"; exit 1; }
archs="$(lipo -archs "$plugin")"
case " $archs " in *" x86_64 "*) ;; *) echo "plugin lacks x86_64 ($archs)"; exit 1 ;; esac
case " $archs " in *" arm64 "*) ;; *) echo "plugin lacks arm64 ($archs)"; exit 1 ;; esac
"$plugin" --version
[ -f "$app_dir/Contents/Resources/THIRD_PARTY_NOTICES" ] || { echo "missing Contents/Resources/THIRD_PARTY_NOTICES"; exit 1; }
- name: Collect artifacts
run: |
mkdir -p artifacts
@@ -729,6 +763,13 @@ jobs:
set "PATH=%USERPROFILE%\.cargo\bin;C:\Program Files\nodejs;%PATH%"
npm run build
# The AWS Session Manager plugin sidecar (bundle.externalBin), built from
# source (see build-ssm-plugin.ps1); must match its pinned SHA-256. It
# comes out unsigned, so it ships unsigned in previews, like the
# app (releases sign it: see build-app.yml).
- name: Build the AWS Session Manager plugin
run: powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File scripts\build-ssm-plugin.ps1
- name: Build Tauri app
working-directory: ./app
# Previews are not code-signed: signing is metered, previews are built
+39
View File
@@ -227,6 +227,14 @@ jobs:
export PATH="$HOME/.cargo/bin:$PATH"
npx tauri --version || npm install @tauri-apps/cli
# The AWS Session Manager plugin, bundled as a sidecar (bundle.externalBin)
# so AWS workspaces work without the user installing it. Built here from
# AWS's Apache-2.0 source (pinned commit + archive SHA-256) with a pinned,
# hash-checked Go; the output must match a pinned SHA-256 (reproducible
# build). A release build refuses to start without it (build.rs).
- name: Build the AWS Session Manager plugin
run: bash scripts/build-ssm-plugin.sh x86_64-unknown-linux-gnu
- name: Build Tauri app
working-directory: ./app
run: |
@@ -417,12 +425,36 @@ jobs:
export PATH="$HOME/.cargo/bin:$PATH"
npx tauri --version || npm install @tauri-apps/cli
# The AWS Session Manager plugin sidecar (bundle.externalBin), built from
# source (see build-ssm-plugin.sh): both thin slices (tauri-build checks
# each arch it compiles) and the lipo'd universal one the bundler copies
# into Contents/MacOS. Each must match its pinned SHA-256. Signed exactly
# like the app: Go ad-hoc signs the arm64 slice, and with APPLE_* signing
# configured Tauri would sign the sidecar with the app's identity.
- name: Build the AWS Session Manager plugin
run: bash scripts/build-ssm-plugin.sh universal-apple-darwin
- name: Build Tauri app (universal)
working-directory: ./app
run: |
export PATH="$HOME/.cargo/bin:$PATH"
npx tauri build --target universal-apple-darwin
# The sidecar and its notices must be in the bundle Tauri made: the
# plugin in Contents/MacOS with both slices, THIRD_PARTY_NOTICES in
# Contents/Resources (bundle.resources).
- name: Check the bundled Session Manager plugin
run: |
app_dir="$(ls -d app/src-tauri/target/universal-apple-darwin/release/bundle/macos/*.app | head -n1)"
[ -n "$app_dir" ] || { echo "no .app bundle"; exit 1; }
plugin="$app_dir/Contents/MacOS/session-manager-plugin"
[ -x "$plugin" ] || { echo "missing $plugin"; exit 1; }
archs="$(lipo -archs "$plugin")"
case " $archs " in *" x86_64 "*) ;; *) echo "plugin lacks x86_64 ($archs)"; exit 1 ;; esac
case " $archs " in *" arm64 "*) ;; *) echo "plugin lacks arm64 ($archs)"; exit 1 ;; esac
"$plugin" --version
[ -f "$app_dir/Contents/Resources/THIRD_PARTY_NOTICES" ] || { echo "missing Contents/Resources/THIRD_PARTY_NOTICES"; exit 1; }
- name: Collect artifacts
run: |
mkdir -p artifacts
@@ -656,6 +688,13 @@ jobs:
set "PATH=%USERPROFILE%\.cargo\bin;C:\Program Files\nodejs;%PATH%"
npm run build
# The AWS Session Manager plugin sidecar (bundle.externalBin), built from
# source (see build-ssm-plugin.ps1); must match its pinned SHA-256. It
# comes out unsigned, so Tauri hands it to the sign command and
# "Verify signatures" requires our signature on it in both installers.
- name: Build the AWS Session Manager plugin
run: powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File scripts\build-ssm-plugin.ps1
# Releases are signed with Azure Artifact Signing (scripts/windows-*.ps1).
# The setup fetches the signing client and a job-local .NET runtime, and
# writes the Tauri config holding the sign command, which "Build Tauri
+4
View File
@@ -27,3 +27,7 @@ screenshot_for_fix/
*.tfstate
*.tfstate.*
.terraform.tfstate.lock.info
# The bundled AWS session-manager-plugin sidecar (scripts/build-ssm-plugin.*, built from source) and the
# debug-build placeholder build.rs writes there. Never committed.
app/src-tauri/binaries/
+74 -5
View File
@@ -14,7 +14,8 @@ All frontend/tauri commands run from the `app/` directory:
cd app
npm ci # Install dependencies (required first time)
npx tauri dev # Launch app in dev mode with hot reload (Vite on port 1420)
npx tauri build # Production build (outputs to src-tauri/target/release/bundle/)
npx tauri build # Production build (outputs to src-tauri/target/release/bundle/);
# run ../scripts/build-ssm-plugin.sh first (bundled AWS plugin, see Packaging)
npm run build # Frontend-only build (tsc + vite)
npm run test # Run Vitest once
npm run test:watch # Run Vitest in watch mode
@@ -1225,10 +1226,77 @@ verbatim copy yields a launcher entry that starts nothing. It keeps `StartupWMCl
the bundle sets it, which is what lets the shell match the window to the entry. Extraction uses
`--appimage-extract`, which needs no FUSE, so the script works before `fuse2` is installed.
### The bundled AWS Session Manager plugin
AWS workspaces connect through AWS's `session-manager-plugin` (`host/ssm.rs`), and the app
**bundles it as a Tauri sidecar** (`bundle.externalBin: binaries/session-manager-plugin`) so users
need not install it. Tauri copies it beside the app binary with the `-<target-triple>` suffix
stripped — `usr/bin/session-manager-plugin` in the AppImage, `Contents/MacOS/` on macOS, the
install directory on Windows (`session-manager-plugin.exe`), and `target/<profile>/` under
`tauri dev`. `find_plugin()` resolves `TRIPLEC_SSM_PLUGIN` → **that sidecar (beside
`current_exe()`)** → `PATH` → AWS's install locations → the install hint; the order is
unit-tested (`host/ssm/tests.rs`, `plugin_resolution`).
- **We build it from source; we never ship AWS's binaries.** AWS distributes its prebuilt plugin
as "AWS Content" under the AWS Customer Agreement; the source (github.com/aws/session-manager-plugin)
is Apache-2.0. `scripts/build-ssm-plugin.sh <triple>…` (Linux/macOS; any triple, it
cross-compiles) and `scripts/build-ssm-plugin.ps1` (the Windows runner, which has no bash) take
the tag's **commit** as GitHub's archive (pinned SHA-256, checked before extraction; the
vendored SDK's Java `codegen/` and test `snapshot/` trees are not extracted — they reach 258
characters, past Windows' MAX_PATH, so the `.ps1` also works under a short `C:\ssm-<8hex>` root)
and a
**pinned Go** from go.dev (go.dev's published SHA-256), and run the repo's own build — GOPATH
mode over its vendored deps, `-ldflags "-s -w"`, `sessionmanagerplugin-main` — with `VERSION`
stamped to the tag (the repo's file says `1.3.0.0`; AWS's pipeline stamps the real one, so
`--version` would otherwise lie), plus `-trimpath`, no VCS stamp, empty build id, `CGO_ENABLED=0`
and a scrubbed Go environment. **The output must equal a pinned SHA-256 per target**: Go builds
are reproducible across hosts, so every runner must produce the exact bytes recorded in the
scripts (verified locally: Linux-hosted builds of every target, repeated in fresh directories,
and the `.ps1` flow, are identical). A mismatch fails the build and means the source, toolchain
or flags changed — never "update the hash" without knowing which.
- **Each platform job builds its own targets** before `tauri build` (Linux: `x86_64-unknown-linux-gnu`;
macOS: `universal-apple-darwin`, i.e. both thin slices — tauri-build checks the arch it compiles —
plus the `lipo`'d universal file the bundler wants, whose slices must thin back out byte-identical
to the pins; Windows: the `.ps1`). Not one Linux job feeding the others: workflow artifacts do
not work on this Gitea (see `build-app-preview.yml`'s header), and with reproducible output and
pinned hashes nothing is gained by building once.
- **Bumping** the plugin or Go: new pins in **both** scripts, rebuild every target, record the new
output hashes, and update `app/src-tauri/THIRD_PARTY_NOTICES` (the scripts refuse to run unless
its `Version:`/`Commit:` lines match) including its dependency licences.
- **Debug builds get a placeholder; release builds refuse one.** tauri-build fails *any* build
whose externalBin file is missing, `cargo test` included. `build.rs` (`ensure_ssm_sidecar`)
writes a marked placeholder (`src/sidecar_placeholder.rs`) for a missing file when
`PROFILE=debug`, so `cargo test`/`cargo check`/`tauri dev` and CI's `test` job need neither Go
nor the network, and `find_plugin()` skips it (falling back to an installed plugin). With
`PROFILE=release` a missing file **or** a placeholder stops the build, so a local `cargo build
--release` needs the build script first. **build.rs rejects only a missing file or the
placeholder, not a stale or wrong binary**: re-run `scripts/build-ssm-plugin.sh` before every
local release build (it is a no-op when the file already matches the pin, and rebuilds it
otherwise — e.g. after a pin bump, or after a Windows release build signed it in place). `finalize-appimage.sh` asserts the shipped
`usr/bin/session-manager-plugin` is an ELF that runs `--version`.
- **Windows: our build is unsigned, so the release signs it with our certificate.** Tauri runs
`signtool verify /pa` on each sidecar and hands the unsigned one to the sign command, in place
under `app\src-tauri\binaries` before any bundle (both MSI and NSIS pack that file);
`windows-sign.ps1`'s allowlist includes it (one more metered signature per release: 6).
`windows-verify-signatures.ps1` requires exactly one `session-manager-plugin.exe` in the MSI and
the file NSIS packed to be validly signed, timestamped, **by the same signing identity
(subject + issuer) as the installer** — not the thumbprint: Artifact Signing certificates are
short-lived and rotate — and the signing log to show it. The MSI must also carry
`THIRD_PARTY_NOTICES`; on macOS a workflow step checks the `.app` holds the two-slice plugin in
`Contents/MacOS` and the notices in `Contents/Resources`. Previews ship it unsigned, like the app.
- **macOS: signed exactly like the app.** The app is not code-signed (no `APPLE_*`/`signingIdentity`
in the workflows); Go's linker ad-hoc signs the arm64 slice (needed to run on Apple Silicon). If
signing is ever configured, Tauri signs externalBin with the app's identity, inside-out.
- **Licence:** `app/src-tauri/THIRD_PARTY_NOTICES` (bundled as a resource; `usr/lib/Triple-C/` in
the AppImage, asserted by `finalize-appimage.sh`) carries the plugin's Apache-2.0 LICENSE and
NOTICE, the commit we build, the repo's own `THIRD-PARTY` file verbatim, the licence of every
vendored module linked in (`go list -deps` for linux/darwin/windows) and Go's own. Note that the
repo's `THIRD-PARTY` file opens with the same "AWS Content" sentence as the binary packages.
### Windows code signing
Windows **releases** (`build-app.yml`) are signed with **Azure Artifact Signing**: the app binary,
the MSI, the NSIS installer and its uninstaller. Three scripts do it, and "Verify signatures"
the bundled `session-manager-plugin`, the MSI, the NSIS installer and its uninstaller. Three scripts do it, and "Verify signatures"
fails the job if any of them is unsigned or untimestamped, so an unsigned installer cannot ship
quietly. **PR previews are deliberately not signed**, and `build-app-preview.yml` must not
reference the signing secrets. Two reasons: signing is metered (about 1000 signatures a month,
@@ -1246,12 +1314,13 @@ without releasing (see Releases above).
- `scripts/windows-sign.ps1` is the sign command: `signtool sign /dlib` with SHA-256 and the
Microsoft timestamp server, retried. Credentials never reach a command line — the dlib reads
`AZURE_TENANT_ID` / `AZURE_CLIENT_ID` / `AZURE_CLIENT_SECRET` from the environment.
**It signs only an allowlist of what ships**: 5 signatures per release (the app binary twice,
**It signs only an allowlist of what ships**: 6 signatures per release (the app binary twice,
because Tauri re-patches it between the MSI and NSIS bundles; the MSI; the NSIS installer;
and its uninstaller). Tauri also presents build-time tools, the WiX extension DLLs and NSIS
its uninstaller; and the `session-manager-plugin` sidecar we build from source). Tauri also presents build-time tools, the WiX extension DLLs and NSIS
plugins, and signing those would more than double the metered count for no user-visible
benefit. If the app ever ships resource DLLs or sidecars, extend the
allowlist, or they will go out unsigned. Tauri reports a failed sign command only as
allowlist, or they will go out unsigned (as `session-manager-plugin`'s entry does; see the
section above). Tauri reports a failed sign command only as
"failed to run powershell", so the script keeps a transcript (`.code-signing/sign-output.log`,
`signtool /debug` included), and the job prints it on failure.
- `scripts/windows-verify-signatures.ps1` checks `signtool verify /pa` plus a timestamp on the
File diff suppressed because it is too large. Load diff
+50
View File
@@ -14,6 +14,8 @@
#[path = "src/command_census.rs"]
mod command_census;
#[path = "src/sidecar_placeholder.rs"]
mod sidecar_placeholder;
use std::path::Path;
@@ -79,6 +81,7 @@ fn main() {
}
prune_permissions(&commands);
ensure_ssm_sidecar();
// `AppManifest::commands` takes `&'static [&'static str]` and the struct is `Copy`, so
// there is no owned form; leaking is fine in a process that exits right after.
@@ -206,3 +209,50 @@ fn check_tauri_config() {
fail("capabilities declared outside capabilities/", &problems, LAYOUT_HINT);
}
}
/// `bundle.externalBin` names `binaries/session-manager-plugin`, and tauri-build stops on a
/// missing `binaries/session-manager-plugin-<target-triple>[.exe]` for every build, tests
/// included. The real one is built from AWS's source by `scripts/build-ssm-plugin.sh` (`.ps1` on
/// Windows), which CI runs before `tauri build`.
///
/// - **Release profile:** the real plugin is required. A missing file or a placeholder stops
/// the build here, so a placeholder can never ship.
/// - **Debug profile** (`cargo test`, `cargo check`, `tauri dev`): a missing file is replaced
/// by a placeholder (`src/sidecar_placeholder.rs`) so no test run needs Go or the network. The app's
/// `find_plugin` skips a placeholder and falls back to an installed plugin.
fn ensure_ssm_sidecar() {
let target = std::env::var("TARGET").expect("cargo sets TARGET");
let ext = if target.contains("windows") { ".exe" } else { "" };
let path = Path::new("binaries").join(format!("session-manager-plugin-{target}{ext}"));
println!("cargo:rerun-if-changed={}", path.display());
let release = std::env::var("PROFILE").as_deref() == Ok("release");
let head = std::fs::read(&path).ok().map(|b| sidecar_placeholder::is_placeholder(&b));
let build = if target.contains("windows") {
"scripts\\build-ssm-plugin.ps1"
} else {
"scripts/build-ssm-plugin.sh"
};
match (head, release) {
(Some(false), _) => {}
(state, true) => fail(
"the AWS Session Manager plugin sidecar is missing",
&[format!(
"{} is {} (release builds bundle the real plugin)",
path.display(),
if state.is_some() { "a debug-build placeholder" } else { "missing" }
)],
&format!("Run {build} {target} from the repository root first."),
),
(None, false) => {
std::fs::create_dir_all("binaries").expect("create src-tauri/binaries");
std::fs::write(&path, sidecar_placeholder::contents())
.unwrap_or_else(|e| panic!("cannot write {}: {e}", path.display()));
println!(
"cargo:warning=no {} - wrote a placeholder (debug only; AWS workspaces use an \
installed plugin). Run {build} to build the real one.",
path.display()
);
}
(Some(true), false) => {}
}
}
+1
View File
@@ -9,6 +9,7 @@
"dialog:allow-open",
"dialog:allow-save",
"allow-check-docker",
"allow-check-docker-status",
"allow-check-image-exists",
"allow-build-image",
"allow-get-container-info",
+1 -1
View File
@@ -1 +1 @@
{"__app-acl__":{"default_permission":null,"permissions":{"allow-acquire-claude-token":{"identifier":"allow-acquire-claude-token","description":"Enables the acquire_claude_token command without any pre-configured scope.","commands":{"allow":["acquire_claude_token"],"deny":[]}},"allow-add-aws-keys-connection":{"identifier":"allow-add-aws-keys-connection","description":"Enables the add_aws_keys_connection command without any pre-configured scope.","commands":{"allow":["add_aws_keys_connection"],"deny":[]}},"allow-add-aws-profile-connection":{"identifier":"allow-add-aws-profile-connection","description":"Enables the add_aws_profile_connection command without any pre-configured scope.","commands":{"allow":["add_aws_profile_connection"],"deny":[]}},"allow-add-marketplace":{"identifier":"allow-add-marketplace","description":"Enables the add_marketplace command without any pre-configured scope.","commands":{"allow":["add_marketplace"],"deny":[]}},"allow-add-marketplace-gh-host-account":{"identifier":"allow-add-marketplace-gh-host-account","description":"Enables the add_marketplace_gh_host_account command without any pre-configured scope.","commands":{"allow":["add_marketplace_gh_host_account"],"deny":[]}},"allow-add-marketplace-token-account":{"identifier":"allow-add-marketplace-token-account","description":"Enables the add_marketplace_token_account command without any pre-configured scope.","commands":{"allow":["add_marketplace_token_account"],"deny":[]}},"allow-add-project":{"identifier":"allow-add-project","description":"Enables the add_project command without any pre-configured scope.","commands":{"allow":["add_project"],"deny":[]}},"allow-add-scheduled-task":{"identifier":"allow-add-scheduled-task","description":"Enables the add_scheduled_task command without any pre-configured scope.","commands":{"allow":["add_scheduled_task"],"deny":[]}},"allow-apply-marketplace-now":{"identifier":"allow-apply-marketplace-now","description":"Enables the apply_marketplace_now command without any pre-configured scope.","commands":{"allow":["apply_marketplace_now"],"deny":[]}},"allow-apply-settings-import":{"identifier":"allow-apply-settings-import","description":"Enables the apply_settings_import command without any pre-configured scope.","commands":{"allow":["apply_settings_import"],"deny":[]}},"allow-aws-connection-identity":{"identifier":"allow-aws-connection-identity","description":"Enables the aws_connection_identity command without any pre-configured scope.","commands":{"allow":["aws_connection_identity"],"deny":[]}},"allow-aws-connection-sso-login":{"identifier":"allow-aws-connection-sso-login","description":"Enables the aws_connection_sso_login command without any pre-configured scope.","commands":{"allow":["aws_connection_sso_login"],"deny":[]}},"allow-aws-cost-estimate":{"identifier":"allow-aws-cost-estimate","description":"Enables the aws_cost_estimate command without any pre-configured scope.","commands":{"allow":["aws_cost_estimate"],"deny":[]}},"allow-aws-ec2-capacity":{"identifier":"allow-aws-ec2-capacity","description":"Enables the aws_ec2_capacity command without any pre-configured scope.","commands":{"allow":["aws_ec2_capacity"],"deny":[]}},"allow-aws-environment-max-hours":{"identifier":"allow-aws-environment-max-hours","description":"Enables the aws_environment_max_hours command without any pre-configured scope.","commands":{"allow":["aws_environment_max_hours"],"deny":[]}},"allow-aws-policy-document":{"identifier":"allow-aws-policy-document","description":"Enables the aws_policy_document command without any pre-configured scope.","commands":{"allow":["aws_policy_document"],"deny":[]}},"allow-aws-sso-refresh":{"identifier":"allow-aws-sso-refresh","description":"Enables the aws_sso_refresh command without any pre-configured scope.","commands":{"allow":["aws_sso_refresh"],"deny":[]}},"allow-aws-task-log":{"identifier":"allow-aws-task-log","description":"Enables the aws_task_log command without any pre-configured scope.","commands":{"allow":["aws_task_log"],"deny":[]}},"allow-aws-workspace-status":{"identifier":"allow-aws-workspace-status","description":"Enables the aws_workspace_status command without any pre-configured scope.","commands":{"allow":["aws_workspace_status"],"deny":[]}},"allow-build-gateway-image":{"identifier":"allow-build-gateway-image","description":"Enables the build_gateway_image command without any pre-configured scope.","commands":{"allow":["build_gateway_image"],"deny":[]}},"allow-build-image":{"identifier":"allow-build-image","description":"Enables the build_image command without any pre-configured scope.","commands":{"allow":["build_image"],"deny":[]}},"allow-build-stt-image":{"identifier":"allow-build-stt-image","description":"Enables the build_stt_image command without any pre-configured scope.","commands":{"allow":["build_stt_image"],"deny":[]}},"allow-cancel-aws-deployment":{"identifier":"allow-cancel-aws-deployment","description":"Enables the cancel_aws_deployment command withoutLine truncated
{"__app-acl__":{"default_permission":null,"permissions":{"allow-acquire-claude-token":{"identifier":"allow-acquire-claude-token","description":"Enables the acquire_claude_token command without any pre-configured scope.","commands":{"allow":["acquire_claude_token"],"deny":[]}},"allow-add-aws-keys-connection":{"identifier":"allow-add-aws-keys-connection","description":"Enables the add_aws_keys_connection command without any pre-configured scope.","commands":{"allow":["add_aws_keys_connection"],"deny":[]}},"allow-add-aws-profile-connection":{"identifier":"allow-add-aws-profile-connection","description":"Enables the add_aws_profile_connection command without any pre-configured scope.","commands":{"allow":["add_aws_profile_connection"],"deny":[]}},"allow-add-marketplace":{"identifier":"allow-add-marketplace","description":"Enables the add_marketplace command without any pre-configured scope.","commands":{"allow":["add_marketplace"],"deny":[]}},"allow-add-marketplace-gh-host-account":{"identifier":"allow-add-marketplace-gh-host-account","description":"Enables the add_marketplace_gh_host_account command without any pre-configured scope.","commands":{"allow":["add_marketplace_gh_host_account"],"deny":[]}},"allow-add-marketplace-token-account":{"identifier":"allow-add-marketplace-token-account","description":"Enables the add_marketplace_token_account command without any pre-configured scope.","commands":{"allow":["add_marketplace_token_account"],"deny":[]}},"allow-add-project":{"identifier":"allow-add-project","description":"Enables the add_project command without any pre-configured scope.","commands":{"allow":["add_project"],"deny":[]}},"allow-add-scheduled-task":{"identifier":"allow-add-scheduled-task","description":"Enables the add_scheduled_task command without any pre-configured scope.","commands":{"allow":["add_scheduled_task"],"deny":[]}},"allow-apply-marketplace-now":{"identifier":"allow-apply-marketplace-now","description":"Enables the apply_marketplace_now command without any pre-configured scope.","commands":{"allow":["apply_marketplace_now"],"deny":[]}},"allow-apply-settings-import":{"identifier":"allow-apply-settings-import","description":"Enables the apply_settings_import command without any pre-configured scope.","commands":{"allow":["apply_settings_import"],"deny":[]}},"allow-aws-connection-identity":{"identifier":"allow-aws-connection-identity","description":"Enables the aws_connection_identity command without any pre-configured scope.","commands":{"allow":["aws_connection_identity"],"deny":[]}},"allow-aws-connection-sso-login":{"identifier":"allow-aws-connection-sso-login","description":"Enables the aws_connection_sso_login command without any pre-configured scope.","commands":{"allow":["aws_connection_sso_login"],"deny":[]}},"allow-aws-cost-estimate":{"identifier":"allow-aws-cost-estimate","description":"Enables the aws_cost_estimate command without any pre-configured scope.","commands":{"allow":["aws_cost_estimate"],"deny":[]}},"allow-aws-ec2-capacity":{"identifier":"allow-aws-ec2-capacity","description":"Enables the aws_ec2_capacity command without any pre-configured scope.","commands":{"allow":["aws_ec2_capacity"],"deny":[]}},"allow-aws-environment-max-hours":{"identifier":"allow-aws-environment-max-hours","description":"Enables the aws_environment_max_hours command without any pre-configured scope.","commands":{"allow":["aws_environment_max_hours"],"deny":[]}},"allow-aws-policy-document":{"identifier":"allow-aws-policy-document","description":"Enables the aws_policy_document command without any pre-configured scope.","commands":{"allow":["aws_policy_document"],"deny":[]}},"allow-aws-sso-refresh":{"identifier":"allow-aws-sso-refresh","description":"Enables the aws_sso_refresh command without any pre-configured scope.","commands":{"allow":["aws_sso_refresh"],"deny":[]}},"allow-aws-task-log":{"identifier":"allow-aws-task-log","description":"Enables the aws_task_log command without any pre-configured scope.","commands":{"allow":["aws_task_log"],"deny":[]}},"allow-aws-workspace-status":{"identifier":"allow-aws-workspace-status","description":"Enables the aws_workspace_status command without any pre-configured scope.","commands":{"allow":["aws_workspace_status"],"deny":[]}},"allow-build-gateway-image":{"identifier":"allow-build-gateway-image","description":"Enables the build_gateway_image command without any pre-configured scope.","commands":{"allow":["build_gateway_image"],"deny":[]}},"allow-build-image":{"identifier":"allow-build-image","description":"Enables the build_image command without any pre-configured scope.","commands":{"allow":["build_image"],"deny":[]}},"allow-build-stt-image":{"identifier":"allow-build-stt-image","description":"Enables the build_stt_image command without any pre-configured scope.","commands":{"allow":["build_stt_image"],"deny":[]}},"allow-cancel-aws-deployment":{"identifier":"allow-cancel-aws-deployment","description":"Enables the cancel_aws_deployment command withoutLine truncated
+1 -1
View File
@@ -1 +1 @@
{"default":{"identifier":"default","description":"Default capabilities for Triple-C. Every entry here is an IPC command a compromised webview can call directly, so the set is an enumeration of what `app/src` actually invokes — plugin and core grants verified against tauri 2.11.0's `PLUGINS` table in tauri's own `build.rs` rather than assumed from a plugin's `default` set, app-command grants (the bare `allow-*` entries) cross-checked by this crate's `build.rs` against `generate_handler!`. `core:default` in particular is NOT used: it is an alias for `core:{path,event,window,webview,app,image,resources,menu,tray}:default`, and `core:image:default` carries `allow-from-path`, whose handler (`tauri-2.11.0/src/image/plugin.rs:41` → `src/image/mod.rs:96`) is a bare `std::fs::read(path)` with no scope mechanism of any kind. Nothing imports `@tauri-apps/api/image`, so the whole plugin is dropped rather than scoped — there is nothing to scope it with. `core:menu` and `core:tray` are dropped for the same reason (no menu, no tray icon); `core:window` and `core:path` because nothing imports them; `core:resources:allow-close` because no frontend value is a `Resource`; and `core:event`'s `allow-emit`/`allow-emit-to` because the frontend only ever *listens* — every emit in this app originates in Rust. Three notes on what is deliberately kept or accepted: (1) `core:webview:allow-internal-toggle-devtools` is not called by `app/src` at all — it is called by Tauri's own injected `toggle-devtools.js`, which binds Ctrl/Cmd+Shift+I. Both that script and the command behind it are `#[cfg(any(debug_assertions, feature = \"devtools\"))]`, so this grant is a `tauri dev` convenience that does not exist in a release bundle. (2) `opener:allow-open-url` is **gone**. It could not be narrowed by host — `TerminalView`'s `WebLinksAddon` opens links Claude printed inside the container, which are arbitrary by construction, so a host allowlist would have deleted the feature rather than bounded it — and it was carried here as an accepted residual risk: a compromised webview could make the OS open an attacker-chosen http(s) URL, an outbound channel. That risk is now closed rather than recorded. Every host-browser open in the app goes through the `open_url_external` command in `url_open.rs`, which exists because the AppImage environment leaks into a cold-launched browser on Linux (triple-c#34) and which re-validates the URL in Rust — scheme allowlist, no embedded credentials, no control characters, length cap, ASCII asserted before `execvp`. On macOS and Windows that command reaches the same plugin as before, via `OpenerExt::open_url`, whose desktop implementation calls `crate::open::open` directly and is therefore not gated by this file at all (`tauri-plugin-opener-2.5.3/src/lib.rs:60`). The plugin stays a dependency for exactly that reason; what is removed is the webview's ability to reach it without passing the Rust validation. (3) `drag:allow-start-drag` is **gone**, together with the OS drag-out it existed for. It could not be scoped — `tauri-plugin-drag` takes the item paths from the caller and has no scope mechanism, so a compromised webview could call `startDrag({ item: ['~/.ssh/id_rsa'] })` against any host path the user can read — and it was carried as an accepted residual risk for one gesture. Drag-out was held back for separate hardening (see branch `hold/disk-and-dragout`) and the plugin is no longer a dependency. Getting a file *out* of a container is either \"Back up container\" on the project's Overview tab, which archives a tree through the Docker API, or the Files tab's per-row \"Save to host…\", which copies one file; getting one *in* is a drop on the Terminal or the Files tab's \"Upload…\". None of the four touches this permission. The Files tab's two are worth separating out here, because they are the only host-path commands in the app whose dialog is opened by **Rust** rather than by the webview — `pick_save_path` and `pick_files_to_upload` in `commands/file_commands.rs` drive `tauri-plugin-dialog` from the backend, so a compromised webview can ask for a picker and nothing more: it cannot name a host path as an *input* to either command. Be precise about the limit of that claim — host paths do still travel outward in error text (`Failed to create /home/j/Documents/x.txt.triple-c-part-1a2b3c4d: Permission denied`), including canonicalized ones, which disclose symlink targets. That is accepted; the app already hands the webview the project paths. What is closed is the direction that mattered — the webview naming where bytes go. That is the shape an earlier revision of this file named as the honest one if the Files tab ever regained host I/O, and it is the shape it regained it in. The `dialog:allow-open` / `dialog:allow-save` grants below are therefore *not* what those two use; they remain for the frontend pickers in Add Project, the Config tab's workspace and access sections, the CA-certificate fielLine truncated
{"default":{"identifier":"default","description":"Default capabilities for Triple-C. Every entry here is an IPC command a compromised webview can call directly, so the set is an enumeration of what `app/src` actually invokes — plugin and core grants verified against tauri 2.11.0's `PLUGINS` table in tauri's own `build.rs` rather than assumed from a plugin's `default` set, app-command grants (the bare `allow-*` entries) cross-checked by this crate's `build.rs` against `generate_handler!`. `core:default` in particular is NOT used: it is an alias for `core:{path,event,window,webview,app,image,resources,menu,tray}:default`, and `core:image:default` carries `allow-from-path`, whose handler (`tauri-2.11.0/src/image/plugin.rs:41` → `src/image/mod.rs:96`) is a bare `std::fs::read(path)` with no scope mechanism of any kind. Nothing imports `@tauri-apps/api/image`, so the whole plugin is dropped rather than scoped — there is nothing to scope it with. `core:menu` and `core:tray` are dropped for the same reason (no menu, no tray icon); `core:window` and `core:path` because nothing imports them; `core:resources:allow-close` because no frontend value is a `Resource`; and `core:event`'s `allow-emit`/`allow-emit-to` because the frontend only ever *listens* — every emit in this app originates in Rust. Three notes on what is deliberately kept or accepted: (1) `core:webview:allow-internal-toggle-devtools` is not called by `app/src` at all — it is called by Tauri's own injected `toggle-devtools.js`, which binds Ctrl/Cmd+Shift+I. Both that script and the command behind it are `#[cfg(any(debug_assertions, feature = \"devtools\"))]`, so this grant is a `tauri dev` convenience that does not exist in a release bundle. (2) `opener:allow-open-url` is **gone**. It could not be narrowed by host — `TerminalView`'s `WebLinksAddon` opens links Claude printed inside the container, which are arbitrary by construction, so a host allowlist would have deleted the feature rather than bounded it — and it was carried here as an accepted residual risk: a compromised webview could make the OS open an attacker-chosen http(s) URL, an outbound channel. That risk is now closed rather than recorded. Every host-browser open in the app goes through the `open_url_external` command in `url_open.rs`, which exists because the AppImage environment leaks into a cold-launched browser on Linux (triple-c#34) and which re-validates the URL in Rust — scheme allowlist, no embedded credentials, no control characters, length cap, ASCII asserted before `execvp`. On macOS and Windows that command reaches the same plugin as before, via `OpenerExt::open_url`, whose desktop implementation calls `crate::open::open` directly and is therefore not gated by this file at all (`tauri-plugin-opener-2.5.3/src/lib.rs:60`). The plugin stays a dependency for exactly that reason; what is removed is the webview's ability to reach it without passing the Rust validation. (3) `drag:allow-start-drag` is **gone**, together with the OS drag-out it existed for. It could not be scoped — `tauri-plugin-drag` takes the item paths from the caller and has no scope mechanism, so a compromised webview could call `startDrag({ item: ['~/.ssh/id_rsa'] })` against any host path the user can read — and it was carried as an accepted residual risk for one gesture. Drag-out was held back for separate hardening (see branch `hold/disk-and-dragout`) and the plugin is no longer a dependency. Getting a file *out* of a container is either \"Back up container\" on the project's Overview tab, which archives a tree through the Docker API, or the Files tab's per-row \"Save to host…\", which copies one file; getting one *in* is a drop on the Terminal or the Files tab's \"Upload…\". None of the four touches this permission. The Files tab's two are worth separating out here, because they are the only host-path commands in the app whose dialog is opened by **Rust** rather than by the webview — `pick_save_path` and `pick_files_to_upload` in `commands/file_commands.rs` drive `tauri-plugin-dialog` from the backend, so a compromised webview can ask for a picker and nothing more: it cannot name a host path as an *input* to either command. Be precise about the limit of that claim — host paths do still travel outward in error text (`Failed to create /home/j/Documents/x.txt.triple-c-part-1a2b3c4d: Permission denied`), including canonicalized ones, which disclose symlink targets. That is accepted; the app already hands the webview the project paths. What is closed is the direction that mattered — the webview naming where bytes go. That is the shape an earlier revision of this file named as the honest one if the Files tab ever regained host I/O, and it is the shape it regained it in. The `dialog:allow-open` / `dialog:allow-save` grants below are therefore *not* what those two use; they remain for the frontend pickers in Add Project, the Config tab's workspace and access sections, the CA-certificate fielLine truncated
@@ -512,6 +512,12 @@
"const": "allow-check-docker",
"markdownDescription": "Enables the check_docker command without any pre-configured scope."
},
{
"description": "Enables the check_docker_status command without any pre-configured scope.",
"type": "string",
"const": "allow-check-docker-status",
"markdownDescription": "Enables the check_docker_status command without any pre-configured scope."
},
{
"description": "Enables the check_for_updates command without any pre-configured scope.",
"type": "string",
@@ -1502,6 +1508,12 @@
"const": "deny-check-docker",
"markdownDescription": "Denies the check_docker command without any pre-configured scope."
},
{
"description": "Denies the check_docker_status command without any pre-configured scope.",
"type": "string",
"const": "deny-check-docker-status",
"markdownDescription": "Denies the check_docker_status command without any pre-configured scope."
},
{
"description": "Denies the check_for_updates command without any pre-configured scope.",
"type": "string",
@@ -512,6 +512,12 @@
"const": "allow-check-docker",
"markdownDescription": "Enables the check_docker command without any pre-configured scope."
},
{
"description": "Enables the check_docker_status command without any pre-configured scope.",
"type": "string",
"const": "allow-check-docker-status",
"markdownDescription": "Enables the check_docker_status command without any pre-configured scope."
},
{
"description": "Enables the check_for_updates command without any pre-configured scope.",
"type": "string",
@@ -1502,6 +1508,12 @@
"const": "deny-check-docker",
"markdownDescription": "Denies the check_docker command without any pre-configured scope."
},
{
"description": "Denies the check_docker_status command without any pre-configured scope.",
"type": "string",
"const": "deny-check-docker-status",
"markdownDescription": "Denies the check_docker_status command without any pre-configured scope."
},
{
"description": "Denies the check_for_updates command without any pre-configured scope.",
"type": "string",
@@ -9,6 +9,12 @@ pub async fn check_docker() -> Result<bool, String> {
docker::check_docker_available().await
}
/// Like `check_docker`, but says *why* Docker is unavailable.
#[tauri::command]
pub async fn check_docker_status() -> Result<docker::status::DockerStatus, String> {
Ok(docker::client::docker_status().await)
}
#[tauri::command]
pub async fn check_image_exists(state: State<'_, AppState>) -> Result<bool, String> {
let settings = state.settings_store.get();
+29 -10
View File
@@ -15,16 +15,35 @@ pub fn get_docker() -> Result<Docker, String> {
}
pub async fn check_docker_available() -> Result<bool, String> {
let docker = get_docker()?;
match docker.ping().await {
Ok(_) => Ok(true),
Err(_) => {
// Connection object exists but daemon not responding — clear cache
let mut guard = DOCKER.lock().map_err(|e| format!("Lock poisoned: {}", e))?;
*guard = None;
Ok(false)
}
}
Ok(docker_status().await.state == super::status::DockerState::Running)
}
/// Ping the daemon and, when it does not answer, say why: not installed, installed
/// but not running, or running but refusing us. See `docker/status.rs`.
pub async fn docker_status() -> super::status::DockerStatus {
use super::status::{self, PingOutcome};
let docker_host = std::env::var("DOCKER_HOST").ok();
let os = status::current_os();
let endpoint = status::endpoint(docker_host.as_deref());
let (ping, detail) = match get_docker() {
Err(e) => (PingOutcome::Unreachable, Some(e)),
Ok(docker) => match docker.ping().await {
Ok(_) => (PingOutcome::Ok, None),
Err(e) => {
// Connection object exists but daemon not responding — clear cache
if let Ok(mut guard) = DOCKER.lock() {
*guard = None;
}
(status::ping_outcome_from_error(&e), Some(e.to_string()))
}
},
};
let installed = ping == PingOutcome::Unreachable
&& (status::docker_installed(os, docker_host.as_deref())
// An explicit DOCKER_HOST means the user has a daemon somewhere.
|| docker_host.as_deref().is_some_and(|h| !h.trim().is_empty()));
status::DockerStatus { state: status::classify(ping, installed), endpoint, detail, os }
}
/// The daemon socket a project container gets bind-mounted when Docker access
+1
View File
@@ -1,5 +1,6 @@
pub mod ca_certs;
pub mod client;
pub mod status;
pub mod events;
pub mod container;
pub mod workspace_env;
+282
View File
@@ -0,0 +1,282 @@
//! Why Docker is unavailable, not just whether it is.
//!
//! A daemon that failed to start (systemd `start-limit-hit`, Docker Desktop
//! still booting) and a socket the user may not open both used to surface as
//! "Docker not detected — install it", which sends people to reinstall
//! something they already have. This module tells the cases apart from the
//! ping's error and a few cheap filesystem probes. It never runs a process
//! (no `systemctl`, no `docker info`).
use serde::Serialize;
use std::error::Error as StdError;
use std::io;
use std::path::{Path, PathBuf};
/// Mirrors `DockerStatus` in `src/lib/types.ts`.
#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
pub struct DockerStatus {
/// `running` | `not_running` | `no_permission` | `not_installed`
pub state: DockerState,
/// The endpoint that was tried — `DOCKER_HOST` when set, else the default socket/pipe.
pub endpoint: String,
/// The connection error, for the "details" line. `None` when running.
pub detail: Option<String>,
/// `linux` | `macos` | `windows` | `unknown` — picks the guidance to show.
pub os: &'static str,
}
#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum DockerState {
Running,
NotRunning,
NoPermission,
NotInstalled,
}
/// What the ping told us, reduced to what matters for the classification.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PingOutcome {
Ok,
/// The socket/pipe exists but the OS refused to let us open it.
PermissionDenied,
/// Nothing answered: socket missing, connection refused, timeout, other.
Unreachable,
}
/// The pure decision. `installed` is true when any installed-ness probe hit.
pub fn classify(ping: PingOutcome, installed: bool) -> DockerState {
match ping {
PingOutcome::Ok => DockerState::Running,
// Getting EACCES means something is listening on a socket we can't
// open — Docker is there; the user lacks access.
PingOutcome::PermissionDenied => DockerState::NoPermission,
PingOutcome::Unreachable if installed => DockerState::NotRunning,
PingOutcome::Unreachable => DockerState::NotInstalled,
}
}
/// Walk an error's `source()` chain for an `io::Error` and map its kind.
/// Falls back to the rendered message, since some layers (hyper-util's
/// connect errors, named pipes) only keep the OS error as text.
pub fn ping_outcome_from_error(err: &(dyn StdError + 'static)) -> PingOutcome {
let mut cur: Option<&(dyn StdError + 'static)> = Some(err);
let mut text = String::new();
while let Some(e) = cur {
if let Some(ioe) = e.downcast_ref::<io::Error>() {
if ioe.kind() == io::ErrorKind::PermissionDenied {
return PingOutcome::PermissionDenied;
}
}
text.push_str(&e.to_string().to_lowercase());
text.push('\n');
cur = e.source();
}
if text.contains("permission denied") || text.contains("access is denied") || text.contains("os error 13") {
PingOutcome::PermissionDenied
} else {
PingOutcome::Unreachable
}
}
/// The endpoint bollard's `connect_with_local_defaults` will use.
pub fn endpoint(docker_host: Option<&str>) -> String {
match docker_host.map(str::trim).filter(|h| !h.is_empty()) {
Some(h) => h.to_string(),
None if cfg!(windows) => "npipe:////./pipe/docker_engine".to_string(),
None => "unix:///var/run/docker.sock".to_string(),
}
}
pub fn current_os() -> &'static str {
if cfg!(target_os = "linux") {
"linux"
} else if cfg!(target_os = "macos") {
"macos"
} else if cfg!(windows) {
"windows"
} else {
"unknown"
}
}
/// Paths whose existence means Docker is installed on this OS. Pure so the
/// list can be tested; `docker_installed` does the filesystem checks.
pub fn install_markers(os: &str, home: Option<&Path>, docker_host: Option<&str>) -> Vec<PathBuf> {
let mut v: Vec<PathBuf> = Vec::new();
// A unix:// DOCKER_HOST whose socket file exists counts, whatever the OS.
if let Some(p) = docker_host.and_then(|h| h.trim().strip_prefix("unix://")) {
if !p.is_empty() {
v.push(PathBuf::from(p));
}
}
match os {
"linux" => {
v.extend(
["/usr/bin/dockerd", "/usr/local/bin/dockerd", "/usr/bin/docker", "/var/run/docker.sock", "/run/docker.sock"]
.iter()
.map(PathBuf::from),
);
if let Some(h) = home {
v.push(h.join(".docker/desktop"));
v.push(h.join("bin/dockerd")); // rootless install script
}
}
"macos" => {
v.push(PathBuf::from("/Applications/Docker.app"));
v.push(PathBuf::from("/var/run/docker.sock"));
v.push(PathBuf::from("/usr/local/bin/docker"));
if let Some(h) = home {
v.push(h.join("Applications/Docker.app"));
v.push(h.join(".docker/run/docker.sock"));
}
}
"windows" => {
v.push(PathBuf::from(r"C:\Program Files\Docker\Docker\Docker Desktop.exe"));
v.push(PathBuf::from(r"C:\Program Files\Docker\Docker\resources\bin\docker.exe"));
}
_ => {}
}
v
}
/// Executable names to look for on `PATH`.
pub fn path_binaries(os: &str) -> &'static [&'static str] {
match os {
"windows" => &["docker.exe"],
_ => &["docker", "dockerd"],
}
}
fn on_path(name: &str) -> bool {
std::env::var_os("PATH")
.map(|p| std::env::split_paths(&p).any(|dir| dir.join(name).is_file()))
.unwrap_or(false)
}
/// Cheap installed-ness probe: stats a handful of paths, runs nothing.
pub fn docker_installed(os: &str, docker_host: Option<&str>) -> bool {
let home = dirs::home_dir();
if install_markers(os, home.as_deref(), docker_host).iter().any(|p| p.exists()) {
return true;
}
if os == "linux" {
// Rootless Docker's socket lives in the user's runtime dir.
if let Some(rt) = std::env::var_os("XDG_RUNTIME_DIR") {
if Path::new(&rt).join("docker.sock").exists() {
return true;
}
}
}
path_binaries(os).iter().any(|b| on_path(b))
}
#[cfg(test)]
mod tests {
use super::*;
use std::fmt;
#[test]
fn ping_ok_is_running_regardless_of_probes() {
assert_eq!(classify(PingOutcome::Ok, false), DockerState::Running);
assert_eq!(classify(PingOutcome::Ok, true), DockerState::Running);
}
#[test]
fn unreachable_and_installed_is_not_running() {
// The reported case: dockerd present, systemd gave up restarting it.
assert_eq!(classify(PingOutcome::Unreachable, true), DockerState::NotRunning);
}
#[test]
fn unreachable_and_nothing_found_is_not_installed() {
assert_eq!(classify(PingOutcome::Unreachable, false), DockerState::NotInstalled);
}
#[test]
fn permission_denied_is_no_permission_even_without_probes() {
assert_eq!(classify(PingOutcome::PermissionDenied, false), DockerState::NoPermission);
assert_eq!(classify(PingOutcome::PermissionDenied, true), DockerState::NoPermission);
}
/// An error that wraps another, the way bollard → hyper → io do.
#[derive(Debug)]
struct Wrap(&'static str, Option<io::Error>);
impl fmt::Display for Wrap {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.0)
}
}
impl StdError for Wrap {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
self.1.as_ref().map(|e| e as _)
}
}
#[test]
fn nested_io_permission_denied_is_found() {
let e = Wrap("error trying to connect", Some(io::Error::from(io::ErrorKind::PermissionDenied)));
assert_eq!(ping_outcome_from_error(&e), PingOutcome::PermissionDenied);
}
#[test]
fn nested_connection_refused_and_not_found_are_unreachable() {
let refused = Wrap("error trying to connect", Some(io::Error::from(io::ErrorKind::ConnectionRefused)));
let missing = Wrap("error trying to connect", Some(io::Error::from(io::ErrorKind::NotFound)));
assert_eq!(ping_outcome_from_error(&refused), PingOutcome::Unreachable);
assert_eq!(ping_outcome_from_error(&missing), PingOutcome::Unreachable);
}
#[test]
fn permission_denied_only_in_text_is_found() {
let e = Wrap("client error (Connect): Permission denied (os error 13)", None);
assert_eq!(ping_outcome_from_error(&e), PingOutcome::PermissionDenied);
}
#[test]
fn endpoint_respects_docker_host() {
assert_eq!(endpoint(Some("tcp://10.0.0.5:2375")), "tcp://10.0.0.5:2375");
assert_eq!(endpoint(Some(" ")), endpoint(None));
let default = endpoint(None);
assert!(default.starts_with("unix://") || default.starts_with("npipe://"), "{default}");
}
#[test]
fn install_markers_cover_each_os() {
let home = Path::new("/home/u");
let linux = install_markers("linux", Some(home), None);
assert!(linux.contains(&PathBuf::from("/usr/bin/dockerd")));
assert!(linux.contains(&PathBuf::from("/var/run/docker.sock")));
assert!(linux.contains(&home.join(".docker/desktop")));
let mac = install_markers("macos", Some(home), None);
assert!(mac.contains(&PathBuf::from("/Applications/Docker.app")));
assert!(mac.contains(&home.join(".docker/run/docker.sock")));
let win = install_markers("windows", None, None);
assert!(win.contains(&PathBuf::from(r"C:\Program Files\Docker\Docker\Docker Desktop.exe")));
assert_eq!(path_binaries("windows"), &["docker.exe"]);
assert!(path_binaries("linux").contains(&"dockerd"));
}
#[test]
fn unix_docker_host_socket_is_a_marker() {
let m = install_markers("linux", None, Some("unix:///run/user/1000/docker.sock"));
assert_eq!(m[0], PathBuf::from("/run/user/1000/docker.sock"));
let tcp = install_markers("linux", None, Some("tcp://host:2375"));
assert!(!tcp.iter().any(|p| p.to_string_lossy().contains("host")));
}
#[test]
fn status_serializes_with_snake_case_state() {
let s = DockerStatus {
state: DockerState::NotRunning,
endpoint: "unix:///var/run/docker.sock".into(),
detail: Some("refused".into()),
os: "linux",
};
let json = serde_json::to_value(&s).unwrap();
assert_eq!(json["state"], "not_running");
assert_eq!(json["os"], "linux");
}
}
+82 -26
View File
@@ -198,27 +198,48 @@ fn sdk_error(e: &(dyn std::error::Error + 'static)) -> String {
// ── The plugin ───────────────────────────────────────────────────────────────
/// Find `session-manager-plugin`: `TRIPLEC_SSM_PLUGIN` if set, then `PATH`,
/// then where AWS's installers put it (the GUI app on macOS does not get the
/// shell's `PATH`, so the install locations are not optional).
/// The plugin's file name on this platform: what the bundle holds (Tauri strips the
/// `-<target-triple>` suffix of `bundle.externalBin` when it copies the sidecar in) and what
/// AWS's installers put on `PATH`.
const PLUGIN_FILE: &str =
if cfg!(windows) { "session-manager-plugin.exe" } else { "session-manager-plugin" };
const PLUGIN_INSTALL_HINT: &str = "The AWS Session Manager plugin (session-manager-plugin) is \
not installed. It is what connects to a workspace on AWS; install it from \
https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html";
/// Find `session-manager-plugin`, in this order:
///
/// 1. `TRIPLEC_SSM_PLUGIN`, if set (an error if it names no file — an explicit choice is never
/// silently replaced by another plugin);
/// 2. **the copy bundled with the app** (`bundle.externalBin`), beside the app's own
/// executable: `usr/bin` in the AppImage, `Contents/MacOS` in the macOS bundle, the install
/// directory on Windows (and `target/<profile>` under `tauri dev`, where tauri-build copies
/// it). A debug build's placeholder (`sidecar_placeholder`) is skipped;
/// 3. `PATH`;
/// 4. where AWS's installers put it (the GUI app on macOS does not get the shell's `PATH`, so
/// the install locations are not optional).
///
/// 3 and 4 remain for dev builds without a fetched sidecar.
pub fn find_plugin() -> Result<PathBuf, String> {
if let Some(p) = std::env::var_os("TRIPLEC_SSM_PLUGIN").filter(|p| !p.is_empty()) {
let p = PathBuf::from(p);
return if p.is_file() {
Ok(p)
} else {
Err(format!("TRIPLEC_SSM_PLUGIN names {}, which is not a file", p.display()))
};
}
let name = if cfg!(windows) { "session-manager-plugin.exe" } else { "session-manager-plugin" };
let on_path = std::env::var_os("PATH")
.map(|paths| std::env::split_paths(&paths).map(|d| d.join(name)).collect::<Vec<_>>())
.unwrap_or_default();
let installed: Vec<PathBuf> = if cfg!(windows) {
let exe_dir = std::env::current_exe()
.ok()
.and_then(|exe| exe.parent().map(Path::to_path_buf));
resolve_plugin(&PluginSearch {
override_path: std::env::var_os("TRIPLEC_SSM_PLUGIN"),
exe_dir,
path_var: std::env::var_os("PATH"),
install_dirs: plugin_install_dirs(),
})
}
/// Where AWS's installers put the plugin, in the order they are tried.
fn plugin_install_dirs() -> Vec<PathBuf> {
if cfg!(windows) {
["ProgramFiles", "ProgramFiles(x86)"]
.iter()
.filter_map(|v| std::env::var_os(v))
.map(|d| PathBuf::from(d).join(r"Amazon\SessionManagerPlugin\bin").join(name))
.map(|d| PathBuf::from(d).join(r"Amazon\SessionManagerPlugin\bin"))
.collect()
} else {
[
@@ -228,19 +249,54 @@ pub fn find_plugin() -> Result<PathBuf, String> {
"/usr/bin",
]
.iter()
.map(|d| Path::new(d).join(name))
.map(PathBuf::from)
.collect()
};
}
}
/// Everything [`find_plugin`] reads from the process, so the order is testable.
struct PluginSearch {
override_path: Option<std::ffi::OsString>,
exe_dir: Option<PathBuf>,
path_var: Option<std::ffi::OsString>,
install_dirs: Vec<PathBuf>,
}
fn resolve_plugin(search: &PluginSearch) -> Result<PathBuf, String> {
if let Some(p) = search.override_path.as_ref().filter(|p| !p.is_empty()) {
let p = PathBuf::from(p);
return if p.is_file() {
Ok(p)
} else {
Err(format!("TRIPLEC_SSM_PLUGIN names {}, which is not a file", p.display()))
};
}
if let Some(bundled) = search.exe_dir.as_ref().map(|d| d.join(PLUGIN_FILE)) {
if bundled.is_file() && !is_sidecar_placeholder(&bundled) {
return Ok(bundled);
}
}
let on_path = search
.path_var
.as_ref()
.map(|paths| std::env::split_paths(paths).map(|d| d.join(PLUGIN_FILE)).collect::<Vec<_>>())
.unwrap_or_default();
on_path
.into_iter()
.chain(installed)
.chain(search.install_dirs.iter().map(|d| d.join(PLUGIN_FILE)))
.find(|p| p.is_file())
.ok_or_else(|| {
"The AWS Session Manager plugin (session-manager-plugin) is not installed. It is \
what connects to a workspace on AWS; install it from \
https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html"
.to_string()
})
.ok_or_else(|| PLUGIN_INSTALL_HINT.to_string())
}
/// Whether `path` is the stand-in a debug build bundles when no real plugin was fetched.
/// Unreadable counts as "not a placeholder": the spawn then reports the real error.
fn is_sidecar_placeholder(path: &Path) -> bool {
use std::io::Read;
let mut head = [0u8; crate::sidecar_placeholder::MARKER.len()];
std::fs::File::open(path)
.and_then(|mut f| f.read_exact(&mut head))
.map(|()| crate::sidecar_placeholder::is_placeholder(&head))
.unwrap_or(false)
}
/// A running plugin process with a listener on the local port.
+132
View File
@@ -400,3 +400,135 @@ async fn the_keepalive_asks_for_health_without_a_token() {
assert!(req.starts_with("GET /v1/health HTTP/1.1\r\n"), "{req}");
assert!(!req.to_ascii_lowercase().contains("authorization"), "{req}");
}
// ── Finding the plugin ───────────────────────────────────────────────────────
mod plugin_resolution {
use super::super::{resolve_plugin, PluginSearch, PLUGIN_FILE, PLUGIN_INSTALL_HINT};
use std::path::{Path, PathBuf};
/// A directory holding a fake plugin (contents are never run).
fn dir_with_plugin(root: &Path, name: &str) -> PathBuf {
let d = root.join(name);
std::fs::create_dir_all(&d).unwrap();
std::fs::write(d.join(PLUGIN_FILE), b"\x7fELF fake plugin").unwrap();
d
}
fn search(
override_path: Option<&Path>,
exe_dir: Option<&Path>,
path: &[&Path],
install: &[&Path],
) -> PluginSearch {
PluginSearch {
override_path: override_path.map(|p| p.as_os_str().to_owned()),
exe_dir: exe_dir.map(Path::to_path_buf),
path_var: Some(std::env::join_paths(path).unwrap()),
install_dirs: install.iter().map(|p| p.to_path_buf()).collect(),
}
}
#[test]
fn the_override_wins_over_everything() {
let t = tempfile::tempdir().unwrap();
let chosen = t.path().join("my-plugin");
std::fs::write(&chosen, b"x").unwrap();
let bundled = dir_with_plugin(t.path(), "app");
let on_path = dir_with_plugin(t.path(), "path");
let s = search(Some(&chosen), Some(&bundled), &[&on_path], &[]);
assert_eq!(resolve_plugin(&s).unwrap(), chosen);
}
#[test]
fn an_override_naming_no_file_is_an_error_not_a_fallback() {
let t = tempfile::tempdir().unwrap();
let bundled = dir_with_plugin(t.path(), "app");
let s = search(Some(&t.path().join("missing")), Some(&bundled), &[], &[]);
let e = resolve_plugin(&s).unwrap_err();
assert!(e.contains("TRIPLEC_SSM_PLUGIN names"), "{e}");
}
#[test]
fn an_empty_override_is_ignored() {
let t = tempfile::tempdir().unwrap();
let bundled = dir_with_plugin(t.path(), "app");
let mut s = search(None, Some(&bundled), &[], &[]);
s.override_path = Some(std::ffi::OsString::new());
assert_eq!(resolve_plugin(&s).unwrap(), bundled.join(PLUGIN_FILE));
}
#[test]
fn the_bundled_sidecar_wins_over_path_and_installs() {
let t = tempfile::tempdir().unwrap();
let bundled = dir_with_plugin(t.path(), "app");
let on_path = dir_with_plugin(t.path(), "path");
let installed = dir_with_plugin(t.path(), "installed");
let s = search(None, Some(&bundled), &[&on_path], &[&installed]);
assert_eq!(resolve_plugin(&s).unwrap(), bundled.join(PLUGIN_FILE));
}
#[test]
fn without_a_sidecar_path_comes_before_the_install_locations() {
let t = tempfile::tempdir().unwrap();
let empty_app = t.path().join("app");
std::fs::create_dir_all(&empty_app).unwrap();
let first = t.path().join("path-first-empty");
std::fs::create_dir_all(&first).unwrap();
let on_path = dir_with_plugin(t.path(), "path");
let installed = dir_with_plugin(t.path(), "installed");
let s = search(None, Some(&empty_app), &[&first, &on_path], &[&installed]);
assert_eq!(resolve_plugin(&s).unwrap(), on_path.join(PLUGIN_FILE));
let s = search(None, Some(&empty_app), &[&first], &[&installed]);
assert_eq!(resolve_plugin(&s).unwrap(), installed.join(PLUGIN_FILE));
}
#[test]
fn a_debug_placeholder_beside_the_exe_is_skipped() {
let t = tempfile::tempdir().unwrap();
let app = t.path().join("app");
std::fs::create_dir_all(&app).unwrap();
std::fs::write(app.join(PLUGIN_FILE), crate::sidecar_placeholder::contents()).unwrap();
let on_path = dir_with_plugin(t.path(), "path");
let s = search(None, Some(&app), &[&on_path], &[]);
assert_eq!(resolve_plugin(&s).unwrap(), on_path.join(PLUGIN_FILE));
// And with nothing else installed, the install hint, not the placeholder.
let s = search(None, Some(&app), &[], &[]);
assert_eq!(resolve_plugin(&s).unwrap_err(), PLUGIN_INSTALL_HINT);
}
#[test]
fn a_directory_named_like_the_plugin_is_not_a_plugin() {
let t = tempfile::tempdir().unwrap();
let app = t.path().join("app");
std::fs::create_dir_all(app.join(PLUGIN_FILE)).unwrap();
let installed = dir_with_plugin(t.path(), "installed");
let s = search(None, Some(&app), &[], &[&installed]);
assert_eq!(resolve_plugin(&s).unwrap(), installed.join(PLUGIN_FILE));
}
#[test]
fn nothing_anywhere_is_the_install_hint() {
let t = tempfile::tempdir().unwrap();
let s = search(None, None, &[t.path()], &[t.path()]);
let e = resolve_plugin(&s).unwrap_err();
assert!(e.contains("is not installed") && e.contains("docs.aws.amazon.com"), "{e}");
}
#[test]
fn the_bundled_name_is_what_tauri_gives_the_sidecar() {
// tauri-build/-bundler strip "-<target-triple>" from bundle.externalBin's
// "binaries/session-manager-plugin"; the .exe stays on Windows.
let conf: serde_json::Value =
serde_json::from_str(include_str!("../../../tauri.conf.json")).unwrap();
let bins = conf["bundle"]["externalBin"].as_array().expect("bundle.externalBin");
let stems: Vec<&str> = bins
.iter()
.map(|b| b.as_str().unwrap().rsplit('/').next().unwrap())
.collect();
let expected = PLUGIN_FILE.trim_end_matches(".exe");
assert!(stems.contains(&expected), "{stems:?} has no {expected}");
}
}
+2
View File
@@ -15,6 +15,7 @@ mod logging;
mod marketplace;
mod models;
mod project_lock;
mod sidecar_placeholder;
mod storage;
pub mod url_open;
pub mod web_terminal;
@@ -541,6 +542,7 @@ pub fn run() {
.invoke_handler(tauri::generate_handler![
// Docker
commands::docker_commands::check_docker,
commands::docker_commands::check_docker_status,
commands::docker_commands::check_image_exists,
commands::docker_commands::build_image,
commands::docker_commands::get_container_info,
+32
View File
@@ -0,0 +1,32 @@
//! The stand-in `build.rs` writes for the bundled `session-manager-plugin` sidecar in a
//! **debug** build that has no real one, and how the app recognises it.
//!
//! `bundle.externalBin` makes tauri-build fail outright when the per-target file is missing,
//! for `cargo test`, `cargo check` and `tauri dev` as much as for a release. The real binary
//! is built from AWS's pinned source by `scripts/build-ssm-plugin.sh` (`.ps1` on Windows), with
//! a downloaded Go toolchain; requiring that for every test run would put a Go build and the
//! network on the path of every `cargo test`. So debug builds get this placeholder instead, a
//! release build refuses it (`build.rs`), and `host::ssm::find_plugin` skips it and falls back to
//! an installed plugin.
//!
//! Shared by `build.rs` (through `#[path]`) and the app, so the two cannot disagree.
/// The first bytes of a placeholder. Not an executable format on any platform.
pub const MARKER: &[u8] = b"TRIPLE-C SSM PLUGIN PLACEHOLDER";
/// The whole placeholder file.
#[allow(dead_code)] // build.rs only
pub fn contents() -> Vec<u8> {
let mut v = MARKER.to_vec();
v.extend_from_slice(
b"\nNot the AWS Session Manager plugin. Debug builds get this when \
app/src-tauri/binaries has no real one; run scripts/build-ssm-plugin.sh \
(scripts/build-ssm-plugin.ps1 on Windows) to build the real plugin.\n",
);
v
}
/// Whether `bytes` (the start of a file) is a placeholder.
pub fn is_placeholder(bytes: &[u8]) -> bool {
bytes.starts_with(MARKER)
}
+6
View File
@@ -36,6 +36,12 @@
"icons/icon.icns",
"icons/icon.png"
],
"externalBin": [
"binaries/session-manager-plugin"
],
"resources": {
"THIRD_PARTY_NOTICES": "THIRD_PARTY_NOTICES"
},
"linux": {
"appimage": {
"bundleMediaFramework": true
+4 -2
View File
@@ -6,6 +6,7 @@ import TopBar from "./components/layout/TopBar";
import StatusBar from "./components/layout/StatusBar";
import NotesDock from "./components/layout/NotesDock";
import TerminalView from "./components/terminal/TerminalView";
import { dockerFailLabel } from "./lib/dockerStatus";
import DockerInstallDialog from "./components/DockerInstallDialog";
import ProjectHome from "./components/projects/home/ProjectHome";
import AddProjectDialog from "./components/projects/AddProjectDialog";
@@ -213,9 +214,10 @@ export default function App() {
* tracks and ends in a real button.
*/
function WelcomeScreen() {
const { dockerAvailable, imageExists, projects, openProjectHome } = useAppState(
const { dockerAvailable, dockerStatus, imageExists, projects, openProjectHome } = useAppState(
useShallow((s) => ({
dockerAvailable: s.dockerAvailable,
dockerStatus: s.dockerStatus,
imageExists: s.imageExists,
projects: s.projects,
openProjectHome: s.openProjectHome,
@@ -233,7 +235,7 @@ function WelcomeScreen() {
label: "Docker detected",
state: dockerAvailable,
pendingLabel: "Checking for Docker…",
failLabel: "Docker not available",
failLabel: dockerFailLabel(dockerStatus),
},
{
label: "Container image ready",
@@ -0,0 +1,91 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { render, screen, act } from "@testing-library/react";
import DockerInstallDialog from "./DockerInstallDialog";
import { useAppState } from "../store/appState";
import type { DockerStatus } from "../lib/types";
vi.mock("../lib/tauri-commands", () => ({
getDockerStatus: vi.fn(),
checkImageExists: vi.fn(),
buildImage: vi.fn(),
pullImage: vi.fn(),
openUrlExternal: vi.fn(),
}));
vi.mock("../hooks/useInstallHelper", () => ({
useInstallHelper: () => ({
options: {
os: "linux",
product_name: "Docker Engine",
can_auto_install: false,
auto_install_method: null,
auto_install_blocker: "no pkexec",
docs_url: "https://docs.docker.com",
manual_steps: [],
post_install_notes: [],
},
loadOptions: vi.fn(),
runInstall: vi.fn(),
}),
}));
const status = (state: DockerStatus["state"], os: DockerStatus["os"] = "linux"): DockerStatus => ({
state,
endpoint: "unix:///var/run/docker.sock",
detail: state === "running" ? null : "connection refused",
os,
});
function setStatus(s: DockerStatus) {
act(() => useAppState.getState().setDockerStatus(s));
}
describe("DockerInstallDialog", () => {
beforeEach(() => {
useAppState.setState({ dockerStatus: null, dockerAvailable: null });
});
it("offers install guidance when Docker is not installed", () => {
setStatus(status("not_installed"));
render(<DockerInstallDialog onClose={vi.fn()} />);
expect(screen.getByRole("dialog", { name: "Docker is not installed" })).toBeTruthy();
expect(screen.getByText(/AWS projects don't need local Docker/)).toBeTruthy();
expect(screen.getByText("unix:///var/run/docker.sock")).toBeTruthy();
});
it("says installed-but-not-running with systemd steps on Linux, and offers no install", () => {
setStatus(status("not_running"));
render(<DockerInstallDialog onClose={vi.fn()} />);
expect(screen.getByRole("dialog", { name: "Docker is installed but not running" })).toBeTruthy();
expect(screen.getByText("sudo systemctl start docker")).toBeTruthy();
expect(screen.getByText("sudo systemctl reset-failed docker")).toBeTruthy();
expect(screen.getByText("journalctl -u docker -b")).toBeTruthy();
expect(screen.queryByText(/Install Docker Engine/)).toBeNull();
expect(screen.getByText(/AWS projects don't need local Docker/)).toBeTruthy();
});
it("tells macOS/Windows users to start Docker Desktop", () => {
setStatus(status("not_running", "macos"));
render(<DockerInstallDialog onClose={vi.fn()} />);
expect(screen.getByText("Docker Desktop")).toBeTruthy();
expect(screen.queryByText("sudo systemctl start docker")).toBeNull();
});
it("explains the docker group on permission denied", () => {
setStatus(status("no_permission"));
render(<DockerInstallDialog onClose={vi.fn()} />);
expect(screen.getByRole("dialog", { name: "Docker is running but not accessible" })).toBeTruthy();
expect(screen.getByText("sudo usermod -aG docker $USER")).toBeTruthy();
});
it("updates live and closes itself when Docker becomes available", () => {
setStatus(status("not_installed"));
const onClose = vi.fn();
render(<DockerInstallDialog onClose={onClose} />);
setStatus(status("not_running"));
expect(screen.getByRole("dialog", { name: "Docker is installed but not running" })).toBeTruthy();
expect(onClose).not.toHaveBeenCalled();
setStatus(status("running"));
expect(onClose).toHaveBeenCalled();
});
});
+124 -2
View File
@@ -1,10 +1,79 @@
import { useEffect, useState } from "react";
import { useInstallHelper } from "../hooks/useInstallHelper";
import { openUrlExternal } from "../lib/tauri-commands";
import type { DockerStatus } from "../lib/types";
import { useDocker } from "../hooks/useDocker";
import Modal from "./ui/Modal";
import Button from "./ui/Button";
const AWS_NOTE = "AWS projects don't need local Docker and still work.";
function Cmd({ children }: { children: string }) {
return (
<code className="block font-mono text-[var(--text-primary)] bg-[var(--bg-primary)] border border-[var(--border-color)] rounded-[var(--radius-control)] px-2 py-1 my-1 select-all break-all">
{children}
</code>
);
}
/** Guidance for a Docker that is installed but not answering. */
function NotRunningHelp({ status }: { status: DockerStatus }) {
if (status.os === "linux") {
return (
<div className="text-xs text-[var(--text-secondary)] space-y-2">
<p>Start the daemon:</p>
<Cmd>sudo systemctl start docker</Cmd>
<p>
If systemd gave up restarting it (<span className="font-mono">start-limit-hit</span>),
clear that first, then start it again:
</p>
<Cmd>sudo systemctl reset-failed docker</Cmd>
<p>To see why it stopped:</p>
<Cmd>systemctl status docker</Cmd>
<Cmd>journalctl -u docker -b</Cmd>
<p>
To start it at every boot, use{" "}
<span className="font-mono">sudo systemctl enable --now docker</span>. Rootless Docker
runs as your user instead: <span className="font-mono">systemctl --user start docker</span>.
</p>
</div>
);
}
return (
<div className="text-xs text-[var(--text-secondary)] space-y-2">
<p>
Start <span className="text-[var(--text-primary)]">Docker Desktop</span> and wait until it
says the engine is running — the first start can take a minute. This dialog closes on its
own once Docker answers.
</p>
</div>
);
}
function NoPermissionHelp({ status }: { status: DockerStatus }) {
if (status.os === "linux") {
return (
<div className="text-xs text-[var(--text-secondary)] space-y-2">
<p>
Your user is not in the <span className="font-mono">docker</span> group, so the socket
refuses the connection. Add yourself:
</p>
<Cmd>sudo usermod -aG docker $USER</Cmd>
<p>Then log out and back in (or reboot) so the new group applies, and reopen Triple-C.</p>
</div>
);
}
return (
<div className="text-xs text-[var(--text-secondary)] space-y-2">
<p>
The Docker endpoint refused access. Make sure Docker Desktop is running for your user
{status.os === "windows" ? " and that your account is in the docker-users group" : ""}, then
re-check.
</p>
</div>
);
}
interface Props {
onClose: () => void;
}
@@ -13,7 +82,7 @@ type Phase = "idle" | "installing" | "done" | "error";
export default function DockerInstallDialog({ onClose }: Props) {
const { options, loadOptions, runInstall } = useInstallHelper();
const { checkDocker } = useDocker();
const { checkDocker, dockerStatus } = useDocker();
const [showManual, setShowManual] = useState(false);
const [phase, setPhase] = useState<Phase>("idle");
const [log, setLog] = useState<string[]>([]);
@@ -23,6 +92,13 @@ export default function DockerInstallDialog({ onClose }: Props) {
loadOptions();
}, [loadOptions]);
// Docker came up while the dialog was open (polling keeps `dockerStatus`
// current): nothing left to say. Not mid-install, whose notes still matter.
const running = dockerStatus?.state === "running";
useEffect(() => {
if (running && (phase === "idle" || phase === "error")) onClose();
}, [running, phase, onClose]);
const handleInstall = async () => {
setPhase("installing");
setLog([]);
@@ -52,6 +128,50 @@ export default function DockerInstallDialog({ onClose }: Props) {
if (available) onClose();
};
const state = dockerStatus?.state ?? "not_installed";
const endpointLine = dockerStatus && (
<p className="text-[11px] text-[var(--text-secondary)] mt-3 break-all">
Tried <span className="font-mono">{dockerStatus.endpoint}</span>
{dockerStatus.detail ? <> — {dockerStatus.detail}</> : null}
</p>
);
const awsLine = (
<p className="text-[11px] text-[var(--text-secondary)] mt-2">{AWS_NOTE}</p>
);
if (dockerStatus && (state === "not_running" || state === "no_permission")) {
return (
<Modal
title={state === "not_running" ? "Docker is installed but not running" : "Docker is running but not accessible"}
onClose={onClose}
widthClassName="w-[34rem]"
footer={
<>
<Button variant="ghost" onClick={onClose}>
Dismiss
</Button>
<Button variant="primary" onClick={handleRecheck}>
Re-check
</Button>
</>
}
>
<p className="text-[13px] text-[var(--text-secondary)] mb-3">
{state === "not_running"
? "Triple-C found Docker on this machine, but the Docker daemon is not answering. There is nothing to install."
: "The Docker daemon is up, but this user is not allowed to talk to it."}
</p>
{state === "not_running" ? (
<NotRunningHelp status={dockerStatus} />
) : (
<NoPermissionHelp status={dockerStatus} />
)}
{endpointLine}
{awsLine}
</Modal>
);
}
if (!options) {
return null;
}
@@ -61,7 +181,7 @@ export default function DockerInstallDialog({ onClose }: Props) {
return (
<Modal
title="Docker not detected"
title="Docker is not installed"
onClose={onClose}
widthClassName="w-[34rem]"
// Closing mid-install would orphan a privileged installer.
@@ -80,6 +200,8 @@ export default function DockerInstallDialog({ onClose }: Props) {
<span className="text-[var(--text-primary)]">{options.product_name}</span> for
you, or you can follow the official instructions.
</p>
{awsLine}
<div className="mb-4">{endpointLine}</div>
{phase === "idle" && (
<div className="flex flex-col gap-2">
+4 -2
View File
@@ -1,3 +1,4 @@
import { dockerFailLabel } from "../../lib/dockerStatus";
import { useState } from "react";
import { useShallow } from "zustand/react/shallow";
import MainTabs from "./MainTabs";
@@ -9,9 +10,10 @@ import HelpDialog from "./HelpDialog";
import StatusIndicator, { type StatusTone } from "../ui/StatusIndicator";
export default function TopBar() {
const { dockerAvailable, imageExists, updateInfo, imageUpdateInfo, appVersion, setUpdateInfo, setImageUpdateInfo } = useAppState(
const { dockerAvailable, dockerStatus, imageExists, updateInfo, imageUpdateInfo, appVersion, setUpdateInfo, setImageUpdateInfo } = useAppState(
useShallow(s => ({
dockerAvailable: s.dockerAvailable,
dockerStatus: s.dockerStatus,
imageExists: s.imageExists,
updateInfo: s.updateInfo,
imageUpdateInfo: s.imageUpdateInfo,
@@ -76,7 +78,7 @@ export default function TopBar() {
<HealthDot
state={dockerAvailable}
okLabel="Docker"
failLabel="Docker unavailable"
failLabel={dockerFailLabel(dockerStatus)}
pendingLabel="Docker — checking"
/>
<HealthDot
@@ -1,3 +1,4 @@
import { dockerFailLabel } from "../../lib/dockerStatus";
import { useState } from "react";
import { useDocker } from "../../hooks/useDocker";
import { useSettings } from "../../hooks/useSettings";
@@ -13,7 +14,7 @@ const IMAGE_SOURCE_OPTIONS: { value: ImageSource; label: string; description: st
];
export default function DockerSettings() {
const { dockerAvailable, imageExists, checkDocker, checkImage, buildImage, pullImage } =
const { dockerAvailable, dockerStatus, imageExists, checkDocker, checkImage, buildImage, pullImage } =
useDocker();
const { appSettings, saveSettings } = useSettings();
const [working, setWorking] = useState(false);
@@ -82,7 +83,7 @@ export default function DockerSettings() {
<div className="flex items-center justify-between">
<span className="text-[var(--text-secondary)]">Docker Status</span>
<span className={dockerAvailable ? "text-[var(--success)]" : "text-[var(--error)]"}>
{dockerAvailable === null ? "Checking..." : dockerAvailable ? "Connected" : "Not Available"}
{dockerAvailable === null ? "Checking..." : dockerAvailable ? "Connected" : dockerFailLabel(dockerStatus)}
</span>
</div>
+13 -7
View File
@@ -2,11 +2,11 @@ import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { act, renderHook } from "@testing-library/react";
import { useDocker } from "./useDocker";
const checkDocker = vi.fn();
const getDockerStatus = vi.fn();
const checkImageExists = vi.fn();
vi.mock("../lib/tauri-commands", () => ({
checkDocker: () => checkDocker(),
getDockerStatus: () => getDockerStatus(),
checkImageExists: () => checkImageExists(),
buildImage: vi.fn(),
pullImage: vi.fn(),
@@ -15,6 +15,8 @@ vi.mock("../lib/tauri-commands", () => ({
vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(async () => vi.fn()) }));
const setDockerAvailable = vi.fn();
const setDockerStatus = vi.fn();
const status = (state: string) => ({ state, endpoint: "unix:///var/run/docker.sock", detail: null, os: "linux" });
const setImageExists = vi.fn();
vi.mock("../store/appState", () => ({
@@ -22,6 +24,8 @@ vi.mock("../store/appState", () => ({
selector({
dockerAvailable: false,
setDockerAvailable,
dockerStatus: null,
setDockerStatus,
imageExists: false,
setImageExists,
}),
@@ -49,7 +53,7 @@ describe("useDocker.startDockerPolling", () => {
});
it("runs onAvailable once, after Docker is marked available and the image re-checked", async () => {
checkDocker.mockResolvedValueOnce(false).mockResolvedValue(true);
getDockerStatus.mockResolvedValueOnce(status("not_running")).mockResolvedValue(status("running"));
const onAvailable = vi.fn();
const { result } = renderHook(() => useDocker());
@@ -59,9 +63,11 @@ describe("useDocker.startDockerPolling", () => {
await tick();
expect(onAvailable).not.toHaveBeenCalled();
// The not-running state is published so the dialog can show it live.
expect(setDockerStatus).toHaveBeenLastCalledWith(status("not_running"));
await tick();
expect(setDockerAvailable).toHaveBeenCalledWith(true);
expect(setDockerStatus).toHaveBeenLastCalledWith(status("running"));
expect(setImageExists).toHaveBeenCalledWith(true);
expect(onAvailable).toHaveBeenCalledTimes(1);
@@ -71,7 +77,7 @@ describe("useDocker.startDockerPolling", () => {
});
it("still works without a callback and can be cancelled by its cleanup", async () => {
checkDocker.mockResolvedValue(true);
getDockerStatus.mockResolvedValue(status("running"));
const { result } = renderHook(() => useDocker());
let stop: () => void = () => {};
@@ -81,7 +87,7 @@ describe("useDocker.startDockerPolling", () => {
act(() => stop());
await tick();
expect(checkDocker).not.toHaveBeenCalled();
expect(setDockerAvailable).not.toHaveBeenCalled();
expect(getDockerStatus).not.toHaveBeenCalled();
expect(setDockerStatus).not.toHaveBeenCalled();
});
});
+18 -9
View File
@@ -7,12 +7,16 @@ import * as commands from "../lib/tauri-commands";
export function useDocker() {
const {
dockerAvailable,
dockerStatus,
setDockerStatus,
setDockerAvailable,
imageExists,
setImageExists,
} = useAppState(
useShallow(s => ({
dockerAvailable: s.dockerAvailable,
dockerStatus: s.dockerStatus,
setDockerStatus: s.setDockerStatus,
setDockerAvailable: s.setDockerAvailable,
imageExists: s.imageExists,
setImageExists: s.setImageExists,
@@ -21,14 +25,14 @@ export function useDocker() {
const checkDocker = useCallback(async () => {
try {
const available = await commands.checkDocker();
setDockerAvailable(available);
return available;
const status = await commands.getDockerStatus();
setDockerStatus(status);
return status.state === "running";
} catch {
setDockerAvailable(false);
return false;
}
}, [setDockerAvailable]);
}, [setDockerStatus, setDockerAvailable]);
const checkImage = useCallback(async () => {
try {
@@ -62,7 +66,9 @@ export function useDocker() {
const pollingRef = useRef<ReturnType<typeof setInterval> | null>(null);
/**
* Poll until Docker appears, then stop.
* Poll until Docker appears, then stop. Every tick stores the latest
* `dockerStatus`, so the Docker dialog follows "not running" → "no
* permission" → running live and closes itself.
*
* `onAvailable` runs exactly once, after `dockerAvailable` is set and the
* image has been re-checked. It exists because a session that started before
@@ -75,11 +81,11 @@ export function useDocker() {
const interval = setInterval(async () => {
try {
const available = await commands.checkDocker();
if (available) {
const status = await commands.getDockerStatus();
if (status.state === "running") {
clearInterval(interval);
pollingRef.current = null;
setDockerAvailable(true);
setDockerStatus(status);
// Also check image once Docker is available
try {
const exists = await commands.checkImageExists();
@@ -92,6 +98,8 @@ export function useDocker() {
} catch (e) {
console.error("Docker-available callback failed:", e);
}
} else {
setDockerStatus(status);
}
} catch {
// Still not available, keep polling
@@ -103,7 +111,7 @@ export function useDocker() {
clearInterval(interval);
pollingRef.current = null;
};
}, [setDockerAvailable, setImageExists]);
}, [setDockerStatus, setImageExists]);
const pullImage = useCallback(
async (imageName: string, onProgress?: (msg: string) => void) => {
@@ -125,6 +133,7 @@ export function useDocker() {
return {
dockerAvailable,
dockerStatus,
imageExists,
checkDocker,
checkImage,
+15
View File
@@ -0,0 +1,15 @@
import type { DockerStatus } from "./types";
/** Short label for status dots and checklists. */
export function dockerFailLabel(status: DockerStatus | null): string {
switch (status?.state) {
case "not_running":
return "Docker not running";
case "no_permission":
return "Docker access denied";
case "not_installed":
return "Docker not installed";
default:
return "Docker unavailable";
}
}
+2 -1
View File
@@ -1,8 +1,9 @@
import { invoke } from "@tauri-apps/api/core";
import type { Project, ProjectPath, NewProjectHost, RemoveProjectOptions, WipChoice, UnsavedWork, WorkspaceStatus, ProjectRemovalReport, ProjectResetOutcome, ContainerInfo, AppSettings, SettingsImportPreview, SettingsImportOutcome, UpdateInfo, ImageUpdateInfo, FileEntry, FileContents, WebTerminalInfo, SttStatus, GatewayStatus, InstallOptions, ClaudeSession, ContainerCapabilities, ScheduledTask, ScheduledTaskInput, SchedulerNotification, AuthBridgeStatus, BrowserViewStatus, BrowserViewPopoutState, BrowserPageState, PlaywrightDetection, BrowserSetupOutcome, BrowserInstallTarget, ContainerStaleness, MigrationOptions, MigrationReport, MigrationState, ClearTokenOutcome, CaCertInfo, UploadOutcome, Note, ViewerFile, ViewerPoll, ViewerSaved, ViewerState, FileDiff, InstallScope, ItemUpdate, Marketplace, MarketplaceAccount, MarketplaceItemRef, MarketplaceSnapshot, ProjectSyncResult, SyncReport, HostConnection, CallerIdentity, PermissionReport, PolicyFile, HourlyEstimate, AwsWorkspaceConfig, Tier, EnvironmentScan, NetworkChoice, ModuleKind, Ec2Choice, Ec2Compute, Ec2InstanceTable, Ec2Capacity, SavedBundle } from "./types";
import type { Project, ProjectPath, NewProjectHost, RemoveProjectOptions, WipChoice, UnsavedWork, WorkspaceStatus, ProjectRemovalReport, ProjectResetOutcome, ContainerInfo, AppSettings, SettingsImportPreview, SettingsImportOutcome, UpdateInfo, ImageUpdateInfo, FileEntry, FileContents, WebTerminalInfo, SttStatus, GatewayStatus, InstallOptions, DockerStatus, ClaudeSession, ContainerCapabilities, ScheduledTask, ScheduledTaskInput, SchedulerNotification, AuthBridgeStatus, BrowserViewStatus, BrowserViewPopoutState, BrowserPageState, PlaywrightDetection, BrowserSetupOutcome, BrowserInstallTarget, ContainerStaleness, MigrationOptions, MigrationReport, MigrationState, ClearTokenOutcome, CaCertInfo, UploadOutcome, Note, ViewerFile, ViewerPoll, ViewerSaved, ViewerState, FileDiff, InstallScope, ItemUpdate, Marketplace, MarketplaceAccount, MarketplaceItemRef, MarketplaceSnapshot, ProjectSyncResult, SyncReport, HostConnection, CallerIdentity, PermissionReport, PolicyFile, HourlyEstimate, AwsWorkspaceConfig, Tier, EnvironmentScan, NetworkChoice, ModuleKind, Ec2Choice, Ec2Compute, Ec2InstanceTable, Ec2Capacity, SavedBundle } from "./types";
// Docker
export const checkDocker = () => invoke<boolean>("check_docker");
export const getDockerStatus = () => invoke<DockerStatus>("check_docker_status");
export const checkImageExists = () => invoke<boolean>("check_image_exists");
export const buildImage = () => invoke<void>("build_image");
export const getContainerInfo = (projectId: string) =>
+11
View File
@@ -702,6 +702,17 @@ export interface FileContents {
size: number;
}
/** Mirrors `docker::status::DockerStatus` (src-tauri/src/docker/status.rs). */
export type DockerState = "running" | "not_running" | "no_permission" | "not_installed";
export interface DockerStatus {
state: DockerState;
/** The endpoint that was tried: `DOCKER_HOST` when set, else the default socket/pipe. */
endpoint: string;
detail: string | null;
os: "linux" | "macos" | "windows" | "unknown";
}
export interface InstallOptions {
os: "linux" | "macos" | "windows" | "unknown";
product_name: string;
+8
View File
@@ -3,6 +3,7 @@ import type {
Project,
TerminalSession,
AppSettings,
DockerStatus,
UpdateInfo,
ImageUpdateInfo,
Note,
@@ -243,6 +244,10 @@ interface AppState {
setNotesDockWidth: (width: number) => void;
dockerAvailable: boolean | null;
setDockerAvailable: (available: boolean | null) => void;
/** Why Docker is (un)available; `null` until the first check. */
dockerStatus: DockerStatus | null;
/** Sets `dockerStatus` and derives `dockerAvailable` from it. */
setDockerStatus: (status: DockerStatus) => void;
imageExists: boolean | null;
setImageExists: (exists: boolean | null) => void;
// App settings
@@ -569,6 +574,9 @@ export const useAppState = create<AppState>((set) => ({
},
dockerAvailable: null,
setDockerAvailable: (available) => set({ dockerAvailable: available }),
dockerStatus: null,
setDockerStatus: (status) =>
set({ dockerStatus: status, dockerAvailable: status.state === "running" }),
imageExists: null,
setImageExists: (exists) => set({ imageExists: exists }),
// App settings
+154
View File
@@ -0,0 +1,154 @@
# build-ssm-plugin.ps1 - build AWS's session-manager-plugin FROM SOURCE for
# Windows and put it where Tauri's bundle.externalBin expects it:
#
# app\src-tauri\binaries\session-manager-plugin-x86_64-pc-windows-msvc.exe
#
# The Windows runner's half of scripts/build-ssm-plugin.sh - read that header
# for the why. The same pins and the same build, so it must produce the same
# bytes (Go builds are reproducible across hosts); keep the two in step.
#
# 1. Source: AWS's tag 1.2.896.0 by COMMIT, as GitHub's archive of that
# commit, SHA-256 checked before extraction (and its top directory must
# name the commit).
# 2. Toolchain: Go, pinned, SHA-256 as published by go.dev, checked before use.
# 3. AWS's own build (GOPATH mode over the vendored deps, -ldflags "-s -w"),
# version stamped to the tag, made reproducible (-trimpath, no VCS stamp,
# empty build id, CGO off, GOAMD64=v1, nothing inherited).
# 4. The output must equal the pinned SHA-256.
#
# The result is UNSIGNED: in a release build Tauri presents it to the sign
# command (windows-sign.ps1 signs it with our certificate), and
# windows-verify-signatures.ps1 requires our signature on it in both installers.
#
# Needs tar.exe (bsdtar, in every Windows 10+). Idempotent.
$ErrorActionPreference = 'Stop'
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
Add-Type -AssemblyName System.IO.Compression.FileSystem
$PluginVersion = '1.2.896.0'
$PluginCommit = '6430675a44032a551be1937fb27a2d3fdfeb27f7'
$SourceUrl = "https://codeload.github.com/aws/session-manager-plugin/tar.gz/$PluginCommit"
$SourceSha = '7C95BE411AD5F43D14D01460500BFD5A5AA0E28BA94815F8B049AF33A2C381B0'
$GoVersion = '1.26.11'
$GoSha = '71AE086F0137E665F855A811CC119152B6A783E0BBC1B906E709F46D80141EB0' # go1.26.11.windows-amd64.zip, go.dev
$BinarySha = '6D428E5FD77E76D9713F0C42B8EC39F2DE1031E5F3C567FEB73C7FE11B14B226'
$Triple = 'x86_64-pc-windows-msvc'
$repoRoot = Split-Path -Parent $PSScriptRoot
$destDir = Join-Path $repoRoot 'app\src-tauri\binaries'
$dest = Join-Path $destDir "session-manager-plugin-$Triple.exe"
$notices = Join-Path $repoRoot 'app\src-tauri\THIRD_PARTY_NOTICES'
function Get-Sha256([string]$Path) { (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash.ToUpperInvariant() }
if (-not ((Select-String -LiteralPath $notices -SimpleMatch "Version: $PluginVersion" -Quiet) -and
(Select-String -LiteralPath $notices -SimpleMatch "Commit: $PluginCommit" -Quiet))) {
throw "$notices does not name plugin $PluginVersion at $PluginCommit - update it with the bump"
}
if ((Test-Path -LiteralPath $dest) -and ((Get-Sha256 $dest) -eq $BinarySha)) {
Write-Host "session-manager-plugin-$Triple.exe: already the pinned $PluginVersion build"
exit 0
}
# A short work root, not %TEMP% (on the runner that is deep under
# systemprofile): the longest extracted path is ~200 characters, and MAX_PATH
# is 260 for Windows PowerShell 5.1, tar.exe and the Go build alike.
$work = Join-Path "$env:SystemDrive\" ('ssm-' + [guid]::NewGuid().ToString('N').Substring(0, 8))
New-Item -ItemType Directory -Path $work | Out-Null
# A directory at the drive root inherits C:\'s ACL, where Authenticated Users
# may create and modify files - another local user could swap the source, the
# toolchain or the output between our checks and their use. So before anything
# lands in it: no inheritance, full control for SYSTEM, Administrators and this
# process's own user only. Mandatory on Windows; skipped only where there is no
# Windows ACL (the Linux pwsh test path).
if ($env:OS -eq 'Windows_NT') {
$me = [Security.Principal.WindowsIdentity]::GetCurrent().User.Value
& icacls.exe $work /inheritance:r /grant:r '*S-1-5-18:(OI)(CI)F' '*S-1-5-32-544:(OI)(CI)F' "*${me}:(OI)(CI)F" | Out-Null
if ($LASTEXITCODE -ne 0) {
Remove-Item -LiteralPath $work -Recurse -Force -ErrorAction SilentlyContinue
throw "icacls could not restrict $work ($LASTEXITCODE)"
}
}
$ProgressPreference = 'SilentlyContinue'
try {
$goZip = Join-Path $work 'go.zip'
Write-Host "Downloading Go $GoVersion (windows-amd64)"
Invoke-WebRequest -Uri "https://go.dev/dl/go$GoVersion.windows-amd64.zip" -OutFile $goZip -UseBasicParsing
$actual = Get-Sha256 $goZip
if ($actual -ne $GoSha) { throw "SHA-256 mismatch for the Go toolchain: got $actual, pinned $GoSha" }
[IO.Compression.ZipFile]::ExtractToDirectory($goZip, (Join-Path $work 'toolchain'))
$go = Join-Path $work 'toolchain\go\bin\go.exe'
$srcTgz = Join-Path $work 'source.tar.gz'
Write-Host "Downloading session-manager-plugin $PluginVersion source ($PluginCommit)"
Invoke-WebRequest -Uri $SourceUrl -OutFile $srcTgz -UseBasicParsing
$actual = Get-Sha256 $srcTgz
if ($actual -ne $SourceSha) { throw "SHA-256 mismatch for the plugin source: got $actual, pinned $SourceSha" }
$srcDir = Join-Path $work 'src'
New-Item -ItemType Directory -Path $srcDir | Out-Null
# Only what the build reads, as build-ssm-plugin.sh does: the vendored SDK's
# Java codegen/ tree reaches 258 characters inside the archive, past
# MAX_PATH, and its snapshot/ files are test data.
& tar.exe --exclude='*/codegen/*' --exclude='*/snapshot/*' -xzf $srcTgz -C $srcDir
if ($LASTEXITCODE -ne 0) { throw "tar.exe could not extract the source ($LASTEXITCODE)" }
$goSpace = Join-Path $srcDir "session-manager-plugin-$PluginCommit"
if (-not (Test-Path -LiteralPath (Join-Path $goSpace 'src\sessionmanagerplugin-main'))) {
throw "the source archive is not the pinned commit's tree"
}
# A clean, fully specified Go environment for everything below.
foreach ($v in 'GOFLAGS', 'GOROOT', 'GOBIN', 'GOEXPERIMENT', 'GOTMPDIR') { Remove-Item "env:$v" -ErrorAction SilentlyContinue }
$gopath = Join-Path $work 'gopath'
$env:GOENV = 'off'; $env:GOTOOLCHAIN = 'local'; $env:GO111MODULE = 'off'; $env:GOPROXY = 'off'; $env:GOWORK = 'off'
$env:GOPATH = "$gopath;$(Join-Path $goSpace 'vendor')"
$env:GOCACHE = Join-Path $work 'cache'; $env:GOMODCACHE = Join-Path $work 'modcache'
$env:CGO_ENABLED = '0'; $env:GOAMD64 = 'v1'; $env:GOARM64 = 'v8.0'
# makefile pre-build: stamp the version with AWS's own generator.
[IO.File]::WriteAllText((Join-Path $goSpace 'VERSION'), $PluginVersion)
# version-gen runs on this host, so no GOOS/GOARCH yet.
Remove-Item env:GOOS, env:GOARCH -ErrorAction SilentlyContinue
Push-Location $goSpace
try { & $go run ./src/version/versiongenerator/version-gen.go | Out-Null } finally { Pop-Location }
if ($LASTEXITCODE -ne 0) { throw "version-gen failed ($LASTEXITCODE)" }
if (-not (Select-String -LiteralPath (Join-Path $goSpace 'src\version\version.go') -SimpleMatch "const Version = `"$PluginVersion`"" -Quiet)) {
throw 'the version stamp did not take'
}
# makefile copy-src: GOPATH mode, from a copy at the import path.
$pkgRoot = Join-Path $gopath 'src\github.com\aws\session-manager-plugin'
New-Item -ItemType Directory -Force -Path $pkgRoot | Out-Null
Copy-Item -Recurse -LiteralPath (Join-Path $goSpace 'src') -Destination $pkgRoot
$out = Join-Path $work 'session-manager-plugin.exe'
Write-Host "Building session-manager-plugin $PluginVersion for windows/amd64"
$env:GOOS = 'windows'; $env:GOARCH = 'amd64'
Push-Location $pkgRoot
try {
& $go build -trimpath -buildvcs=false -ldflags '-s -w -buildid=' -o $out `
github.com/aws/session-manager-plugin/src/sessionmanagerplugin-main
} finally { Pop-Location }
if ($LASTEXITCODE -ne 0) { throw "go build failed ($LASTEXITCODE)" }
$actual = Get-Sha256 $out
if ($actual -ne $BinarySha) {
throw "the windows/amd64 build is not the pinned binary: got $actual, pinned $BinarySha (source, toolchain or build flags changed)"
}
New-Item -ItemType Directory -Force -Path $destDir | Out-Null
Move-Item -LiteralPath $out -Destination $dest -Force
# And what landed is still what was checked.
$actual = Get-Sha256 $dest
if ($actual -ne $BinarySha) {
Remove-Item -LiteralPath $dest -Force -ErrorAction SilentlyContinue
throw "$dest changed after it was verified: got $actual, pinned $BinarySha"
}
Write-Host "session-manager-plugin-$Triple.exe: session-manager-plugin $PluginVersion (unsigned; signed by the release build)"
} finally {
Remove-Item -LiteralPath $work -Recurse -Force -ErrorAction SilentlyContinue
# PS 5.1's Remove-Item can give up on read-only files and deep trees;
# rd /s /q is the fallback.
if (Test-Path -LiteralPath $work) { cmd /c rd /s /q "`"$work`"" | Out-Null }
if (Test-Path -LiteralPath $work) { Write-Warning "could not remove $work" }
}
+233
View File
@@ -0,0 +1,233 @@
#!/usr/bin/env bash
#
# build-ssm-plugin.sh [target-triple ...] - build AWS's session-manager-plugin
# FROM SOURCE and put it where Tauri's `bundle.externalBin` expects it:
#
# app/src-tauri/binaries/session-manager-plugin-<target-triple>[.exe]
#
# The app runs the plugin to connect to workspaces on AWS; bundling it means
# users do not have to install it. We build it ourselves from AWS's Apache-2.0
# source (github.com/aws/session-manager-plugin) rather than redistributing
# AWS's prebuilt binaries, which AWS ships as "AWS Content" under the AWS
# Customer Agreement.
#
# With no argument the host's triple is used (`rustc -vV`). Every target is a
# pure-Go cross-compile (CGO_ENABLED=0), so any host can build any of them; CI
# builds each platform's own targets in its own job. scripts/build-ssm-plugin.ps1
# is the same build for the Windows runner, which has no bash.
#
# Supported triples:
# x86_64-unknown-linux-gnu linux/amd64
# aarch64-unknown-linux-gnu linux/arm64
# x86_64-apple-darwin darwin/amd64
# aarch64-apple-darwin darwin/arm64
# universal-apple-darwin both darwin slices plus the two thin files,
# joined with lipo (`tauri build --target
# universal-apple-darwin` compiles each arch and
# tauri-build wants each arch's sidecar; the
# bundler then wants the universal one)
# x86_64-pc-windows-msvc windows/amd64 (for local cross-builds; CI uses
# the .ps1)
#
# Trust and reproducibility - the build fails on any miss:
# 1. The source is AWS's tag 1.2.896.0, pinned by COMMIT, downloaded as
# GitHub's archive of that commit and checked against a pinned SHA-256
# BEFORE extraction (the SHA-256 is the check; the archive's top
# directory, which names the commit, must also be there). Only what the
# build reads is extracted: the vendored SDK's Java `codegen/` tree and its
# test `snapshot/` files are skipped, which also keeps every path under
# Windows' MAX_PATH (the .ps1 extracts the same way, so both build the
# same tree).
# 2. The Go toolchain is a pinned release from go.dev, checked against the
# SHA-256 go.dev publishes (https://go.dev/dl/?mode=json), before use.
# 3. The build is AWS's own (its makefile: GOPATH mode over the vendored
# dependencies, `-ldflags "-s -w"`, package sessionmanagerplugin-main),
# with VERSION set to the tag so `--version` prints 1.2.896.0 (AWS's
# release pipeline stamps it; the repo's VERSION file says 1.3.0.0), plus
# what makes it reproducible: -trimpath, no VCS stamping, an empty build
# id, CGO off, explicit GOAMD64/GOARM64, no inherited GOFLAGS.
# 4. The output must equal a PINNED SHA-256 per target. Go builds are
# bit-for-bit reproducible across hosts, so every CI runner must produce
# exactly the binary recorded here; a mismatch means the source, the
# toolchain or the build changed.
#
# To bump the plugin or Go: change the pins in this script and in
# build-ssm-plugin.ps1, rebuild every target, record the new output hashes
# (both scripts), and update the version/commit lines in
# app/src-tauri/THIRD_PARTY_NOTICES (checked below) and its dependency licences.
#
# Idempotent: a destination that already holds the pinned binary is left alone.
set -euo pipefail
PLUGIN_VERSION="1.2.896.0"
PLUGIN_COMMIT="6430675a44032a551be1937fb27a2d3fdfeb27f7"
SOURCE_URL="https://codeload.github.com/aws/session-manager-plugin/tar.gz/${PLUGIN_COMMIT}"
SOURCE_SHA256="7c95be411ad5f43d14d01460500bfd5a5aa0e28ba94815f8b049af33a2c381b0"
GO_VERSION="1.26.11"
go_pin() { # <goos-goarch of the build host> -> SHA-256 published by go.dev
case "$1" in
linux-amd64) echo 9849f4e04ee35303714e34fbc3ac8ab44ea3e448a95aa182f91e3b9b79c710ec ;;
linux-arm64) echo 6c2f29b458b5add0835f18b776f69c8881a6d88428f1484a6da55755e620757e ;;
darwin-amd64) echo 394baae971332f2bc783d6e2004ae57101479bd3b06ed8209a3fe3570d4ce498 ;;
darwin-arm64) echo e3a42e67a7a8acf450ebada2b074c7ca863000ca514907b7185b45e8f5cdff57 ;;
*) return 1 ;;
esac
}
# target triple -> GOOS GOARCH SHA-256 of the binary we build
target_pin() {
case "$1" in
x86_64-unknown-linux-gnu) echo "linux amd64 414dafe49a90428cb4271a28ea964ad9242a26cb08a38d9679d808470c3b6b62" ;;
aarch64-unknown-linux-gnu) echo "linux arm64 79f00cd41536611e2906a9ea703175ab4f06f9b81107a0357b2304c8bfac61dd" ;;
x86_64-apple-darwin) echo "darwin amd64 fc61cd7e30bef3524a3681dc6b1a0f472506d9c98bccf62a67865067c9f2f059" ;;
aarch64-apple-darwin) echo "darwin arm64 9f3857f85cbcdc88e3ca686f84ac2a794e19e1778ad47ac3294c39e700de08f8" ;;
x86_64-pc-windows-msvc) echo "windows amd64 6d428e5fd77e76d9713f0c42b8ec39f2de1031e5f3c567feb73c7fe11b14b226" ;;
*) return 1 ;;
esac
}
repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
dest_dir="$repo_root/app/src-tauri/binaries"
notices="$repo_root/app/src-tauri/THIRD_PARTY_NOTICES"
die() { echo "build-ssm-plugin: $*" >&2; exit 1; }
sha256() {
if command -v sha256sum >/dev/null 2>&1; then
sha256sum "$1" | cut -d' ' -f1
else
shasum -a 256 "$1" | cut -d' ' -f1
fi
}
# The notices name the version and commit they describe; a bump updates both.
grep -qF "Version: ${PLUGIN_VERSION}" "$notices" && grep -qF "Commit: ${PLUGIN_COMMIT}" "$notices" \
|| die "$notices does not name plugin ${PLUGIN_VERSION} at ${PLUGIN_COMMIT} - update it with the bump"
work="$(mktemp -d)"
trap 'rm -rf "$work"' EXIT
prepared=false
download() { # <url> <out>
curl -fsSL --proto '=https' --tlsv1.2 --retry 3 --retry-delay 5 -o "$2" "$1" \
|| die "download failed: $1"
}
# Toolchain and source, once per run, both verified before they are unpacked.
prepare() {
[ "$prepared" = true ] && return 0
local host_os host_arch go_sha go_tgz
case "$(uname -s)" in Linux) host_os=linux ;; Darwin) host_os=darwin ;; *) die "unsupported build host $(uname -s)" ;; esac
case "$(uname -m)" in x86_64|amd64) host_arch=amd64 ;; arm64|aarch64) host_arch=arm64 ;; *) die "unsupported build host arch $(uname -m)" ;; esac
go_sha="$(go_pin "$host_os-$host_arch")" || die "no pinned Go for $host_os-$host_arch"
go_tgz="$work/go.tar.gz"
echo "Downloading Go ${GO_VERSION} (${host_os}-${host_arch})"
download "https://go.dev/dl/go${GO_VERSION}.${host_os}-${host_arch}.tar.gz" "$go_tgz"
[ "$(sha256 "$go_tgz")" = "$go_sha" ] \
|| die "SHA-256 mismatch for the Go toolchain: got $(sha256 "$go_tgz"), pinned $go_sha"
mkdir -p "$work/toolchain"
tar -xzf "$go_tgz" -C "$work/toolchain"
GO="$work/toolchain/go/bin/go"
local src_tgz="$work/source.tar.gz"
echo "Downloading session-manager-plugin ${PLUGIN_VERSION} source (${PLUGIN_COMMIT})"
download "$SOURCE_URL" "$src_tgz"
[ "$(sha256 "$src_tgz")" = "$SOURCE_SHA256" ] \
|| die "SHA-256 mismatch for the plugin source: got $(sha256 "$src_tgz"), pinned $SOURCE_SHA256"
mkdir -p "$work/src"
tar --exclude='*/codegen/*' --exclude='*/snapshot/*' -xzf "$src_tgz" -C "$work/src"
GO_SPACE="$work/src/session-manager-plugin-${PLUGIN_COMMIT}"
[ -d "$GO_SPACE/src/sessionmanagerplugin-main" ] || die "the source archive is not the pinned commit's tree"
# makefile `pre-build`: stamp the version with AWS's own generator.
printf '%s' "$PLUGIN_VERSION" >"$GO_SPACE/VERSION"
( cd "$GO_SPACE" && go_env "$(go_host_os)" "$(go_host_arch)" "$GO" run ./src/version/versiongenerator/version-gen.go >/dev/null )
grep -qF "const Version = \"${PLUGIN_VERSION}\"" "$GO_SPACE/src/version/version.go" \
|| die "the version stamp did not take"
# makefile `copy-src`: the code builds in GOPATH mode, from a copy at its
# import path, with the vendored dependencies as a second GOPATH entry.
GOPATH_DIR="$work/gopath"
mkdir -p "$GOPATH_DIR/src/github.com/aws/session-manager-plugin"
cp -R "$GO_SPACE/src" "$GOPATH_DIR/src/github.com/aws/session-manager-plugin/"
prepared=true
}
go_host_os() { "$GO" env GOHOSTOS; }
go_host_arch() { "$GO" env GOHOSTARCH; }
# Run with a clean, fully specified Go environment (nothing inherited).
go_env() { # <goos> <goarch> <cmd...>
local goos="$1" goarch="$2"; shift 2
env -u GOFLAGS -u GOROOT -u GOBIN -u GOEXPERIMENT \
GOENV=off GOTOOLCHAIN=local GO111MODULE=off GOPROXY=off GOWORK=off \
GOPATH="${GOPATH_DIR:-$work/gopath}:${GO_SPACE}/vendor" \
GOCACHE="$work/cache" GOMODCACHE="$work/modcache" GOTMPDIR= \
CGO_ENABLED=0 GOOS="$goos" GOARCH="$goarch" GOAMD64=v1 GOARM64=v8.0 \
"$@"
}
build_thin() { # <triple> <out>
local triple="$1" out="$2" pin goos goarch want
pin="$(target_pin "$triple")" || die "unsupported target $triple"
read -r goos goarch want <<<"$pin"
if [ -f "$out" ] && [ "$(sha256 "$out")" = "$want" ]; then
echo "$(basename "$out"): already the pinned ${PLUGIN_VERSION} build"
return 0
fi
prepare
echo "Building session-manager-plugin ${PLUGIN_VERSION} for ${goos}/${goarch}"
( cd "$GOPATH_DIR/src/github.com/aws/session-manager-plugin" && \
go_env "$goos" "$goarch" "$GO" build -trimpath -buildvcs=false \
-ldflags "-s -w -buildid=" -o "$work/out-$triple" \
github.com/aws/session-manager-plugin/src/sessionmanagerplugin-main )
local got
got="$(sha256 "$work/out-$triple")"
[ "$got" = "$want" ] || die "the ${goos}/${goarch} build is not the pinned binary: got $got, pinned $want (source, toolchain or build flags changed)"
mkdir -p "$(dirname "$out")"
chmod 0755 "$work/out-$triple"
mv -f "$work/out-$triple" "$out"
echo "$(basename "$out"): session-manager-plugin ${PLUGIN_VERSION}"
}
build_universal() {
local lipo
lipo="$(command -v lipo || command -v llvm-lipo || true)"
[ -n "$lipo" ] || die "universal-apple-darwin needs lipo (Xcode command line tools) or llvm-lipo"
local x86="$dest_dir/session-manager-plugin-x86_64-apple-darwin"
local arm="$dest_dir/session-manager-plugin-aarch64-apple-darwin"
local uni="$dest_dir/session-manager-plugin-universal-apple-darwin"
build_thin x86_64-apple-darwin "$x86"
build_thin aarch64-apple-darwin "$arm"
"$lipo" -create "$x86" "$arm" -output "$work/universal"
# Each slice must come back out byte-identical to its pinned thin binary.
local pair arch triple
for pair in x86_64:x86_64-apple-darwin arm64:aarch64-apple-darwin; do
arch="${pair%%:*}" triple="${pair#*:}"
"$lipo" "$work/universal" -thin "$arch" -output "$work/slice-$arch"
[ "$(sha256 "$work/slice-$arch")" = "$(target_pin "$triple" | cut -d' ' -f3)" ] \
|| die "the $arch slice of the universal binary is not the pinned binary"
done
chmod 0755 "$work/universal"
mv -f "$work/universal" "$uni"
echo "$(basename "$uni"): session-manager-plugin ${PLUGIN_VERSION} (x86_64 + arm64)"
}
targets=("$@")
if [ ${#targets[@]} -eq 0 ]; then
host="$(rustc -vV 2>/dev/null | sed -n 's/^host: //p')"
[ -n "$host" ] || die "no target given and rustc is not available to name the host's"
targets=("$host")
fi
for t in "${targets[@]}"; do
case "$t" in
universal-apple-darwin) build_universal ;;
*-windows-*) build_thin "$t" "$dest_dir/session-manager-plugin-$t.exe" ;;
*) build_thin "$t" "$dest_dir/session-manager-plugin-$t" ;;
esac
done
+16
View File
@@ -317,6 +317,22 @@ if [ "$pw_removed" = true ]; then
fi
[ -x "$out/usr/bin/triple-c" ] || fail "no executable usr/bin/triple-c."
# The bundled AWS Session Manager plugin (bundle.externalBin, built from
# source by build-ssm-plugin.sh) is what AWS workspaces connect through. Tauri copies it
# beside the app binary with the target triple stripped, which is where
# `host::ssm::find_plugin` looks. It must be the real plugin: an ELF, not the
# placeholder a debug build writes (build.rs refuses that for release, and this
# is the check on what actually shipped).
plugin="$out/usr/bin/session-manager-plugin"
[ -x "$plugin" ] || fail "no executable usr/bin/session-manager-plugin (the bundled AWS plugin)."
[ "$(head -c 4 "$plugin" | od -An -c | tr -d ' ')" = "177ELF" ] \
|| fail "usr/bin/session-manager-plugin is not an ELF binary (a placeholder?)."
"$plugin" --version >/dev/null 2>&1 \
|| fail "usr/bin/session-manager-plugin does not run (--version)."
# Its license and notices travel with it (bundle.resources).
notices=("$out"/usr/lib/*/THIRD_PARTY_NOTICES)
[ -f "${notices[0]}" ] || fail "THIRD_PARTY_NOTICES is not in the image."
# Every file readable by all, every program executable by all — what the
# `chmod -R a+rX` before the repack promised (AppRun.wrapped used to ship 0770).
# Files only: the AppImage runtime's --appimage-extract creates every
+10 -4
View File
@@ -10,9 +10,10 @@
# extension DLLs candle/light load, the NSIS plugins makensis embeds - and
# each signature is metered (about 1000 a month), so those are skipped. The
# allowlist below is the whole of what reaches users: the app binary, the MSI,
# the NSIS installer, and the uninstaller makensis writes to the job's temp
# directory. A file that already carries a valid signature is skipped too:
# Tauri presents the app binary once per bundle type.
# the NSIS installer, the uninstaller makensis writes to the job's temp
# directory, and the session-manager-plugin sidecar we build from source. A
# file that already carries a valid signature is skipped too: Tauri presents
# the app binary once per bundle type.
#
# This may run as 32-bit PowerShell: the NSIS uninstaller is signed from inside
# makensis, which is 32-bit and resolves `powershell` to the SysWOW64 copy. So
@@ -46,7 +47,12 @@ try {
$full = (Resolve-Path -LiteralPath $Path).ProviderPath
Write-Log "== $full"
$ships = ($full -match '\\target\\release\\[^\\]+\.exe$') -or
# The bundled session-manager-plugin sidecar (bundle.externalBin), which we
# build from AWS's source (scripts/build-ssm-plugin.ps1) and so ship unsigned
# unless signed here. Tauri presents a sidecar to the sign command, in place
# under app\src-tauri\binaries, only when `signtool verify /pa` rejects it.
$ships = ($full -match '\\src-tauri\\binaries\\session-manager-plugin-x86_64-pc-windows-msvc\.exe$') -or
($full -match '\\target\\release\\[^\\]+\.exe$') -or
($full -match '\\target\\release\\bundle\\(msi|nsis)\\[^\\]+\.(msi|exe)$') -or
$full.StartsWith($env:TRIPLE_C_SIGN_TMP.TrimEnd('\') + '\', [StringComparison]::OrdinalIgnoreCase)
if (-not $ships) {
+50 -1
View File
@@ -14,6 +14,10 @@
# unpacked with an administrative install and its binaries checked directly;
# the NSIS installer cannot be unpacked that way, so for it the signing log
# must show the app binary and the uninstaller were signed.
#
# The bundled session-manager-plugin (built from source, signed by us) is
# checked too: present in the MSI, and in both installers validly signed,
# timestamped, and by the same signing identity as the installer itself.
param([Parameter(Mandatory = $true, ValueFromRemainingArguments = $true)][string[]]$Patterns)
@@ -47,6 +51,24 @@ function Test-Signature([IO.FileInfo]$File, [string]$Label) {
return $false
}
# The session-manager-plugin sidecar is built from AWS's source
# (build-ssm-plugin.ps1), so it is unsigned until windows-sign.ps1 signs it. It
# must carry OUR signature: valid, timestamped, and from the same signing
# identity (subject and issuer) as the installer that ships it.
$sidecarName = 'session-manager-plugin.exe'
$sidecarSource = Join-Path (Split-Path -Parent $PSScriptRoot) 'app\src-tauri\binaries\session-manager-plugin-x86_64-pc-windows-msvc.exe'
function Test-OurSigner([IO.FileInfo]$File, [string]$Label, [IO.FileInfo]$Installer) {
if (-not (Test-Signature $File $Label)) { return $false }
$ours = (Get-AuthenticodeSignature -FilePath $Installer.FullName).SignerCertificate
$theirs = (Get-AuthenticodeSignature -FilePath $File.FullName).SignerCertificate
# Subject + Issuer, not the thumbprint: Azure Artifact Signing issues a
# fresh short-lived certificate (daily), so the plugin and the installer
# can legitimately carry different thumbprints within one build.
if ($ours -and $theirs -and $ours.Subject -eq $theirs.Subject -and $ours.Issuer -eq $theirs.Issuer) { return $true }
Write-Host "FAIL $Label - signed by '$($theirs.Subject)' (issuer '$($theirs.Issuer)'), not the identity that signed $($Installer.Name)"
return $false
}
function Get-SignedLog {
if ($env:TRIPLE_C_SIGN_LOG -and (Test-Path $env:TRIPLE_C_SIGN_LOG)) { return @(Get-Content $env:TRIPLE_C_SIGN_LOG) }
return @()
@@ -56,7 +78,7 @@ $failed = @()
$nsisBuilt = $false
foreach ($file in $files) {
if (-not (Test-Signature $file $file.Name)) { $failed += $file.Name }
if ($file.FullName -match '\\bundle\\nsis\\') { $nsisBuilt = $true }
if ($file.FullName -match '\\bundle\\nsis\\') { $nsisBuilt = $true; $nsisInstaller = $file }
if ($file.Extension -eq '.msi') {
$extract = Join-Path ([IO.Path]::GetTempPath()) ('msi-verify-' + [guid]::NewGuid().ToString('N'))
@@ -74,6 +96,21 @@ foreach ($file in $files) {
foreach ($f in $inner) {
if (-not (Test-Signature $f "$($file.Name) > $($f.Name)")) { $failed += "$($file.Name) > $($f.Name)" }
}
# Its licence notices travel with it (bundle.resources).
if ($proc.ExitCode -eq 0 -and -not @(Get-ChildItem -Path $extract -Recurse -File -Filter 'THIRD_PARTY_NOTICES').Count) {
Write-Host "FAIL $($file.Name) - carries no THIRD_PARTY_NOTICES"
$failed += "$($file.Name) > THIRD_PARTY_NOTICES (missing)"
}
# The bundled plugin must be in there, under our signature.
if ($proc.ExitCode -eq 0) {
$plugin = @($inner | Where-Object { $_.Name -eq $sidecarName })
if ($plugin.Count -ne 1) {
Write-Host "FAIL $($file.Name) - carries $($plugin.Count) $sidecarName, expected 1"
$failed += "$($file.Name) > $sidecarName (missing)"
} elseif (-not (Test-OurSigner $plugin[0] "$($file.Name) > $sidecarName" $file)) {
$failed += "$($file.Name) > $sidecarName (signer)"
}
}
Remove-Item -Recurse -Force $extract -ErrorAction SilentlyContinue
}
}
@@ -92,6 +129,18 @@ if ($nsisBuilt) {
} else {
Write-Host "OK app binary - signed before packaging ($($appSigned.Count)x)"
}
# makensis packs the sidecar straight from app\src-tauri\binaries, where
# Tauri had it signed in place before any bundle: so that file, and a
# logged signature for it, are what NSIS shipped.
if (-not (Test-Path -LiteralPath $sidecarSource)) {
Write-Host "FAIL $sidecarName - $sidecarSource is missing"
$failed += "NSIS > $sidecarName (missing)"
} elseif (-not (Test-OurSigner (Get-Item -LiteralPath $sidecarSource) "NSIS > $sidecarName (as packed)" $nsisInstaller)) {
$failed += "NSIS > $sidecarName (signer)"
} elseif (-not @($log | Where-Object { $_ -match '\\src-tauri\\binaries\\session-manager-plugin-x86_64-pc-windows-msvc\.exe$' }).Count) {
Write-Host "FAIL $sidecarName - no signature was logged for it"
$failed += "NSIS > $sidecarName (not logged)"
}
$tmp = $env:TRIPLE_C_SIGN_TMP
$uninstaller = @()
if ($tmp) { $uninstaller = @($log | Where-Object { $_.StartsWith($tmp, [StringComparison]::OrdinalIgnoreCase) }) }