bots-garden/sidekicks · e5fa637

modified .github/workflows/release.yml +10 -4 Viewed

@@ -52,10 +52,16 @@ jobs:
52	52	echo
53	53	echo "\| File \| System \|"
54	54	echo "\| --- \| --- \|"
55		- for name in $(scripts/package.sh names macos arm64); do echo "\| \`$name\` \| macOS 13 or later, Apple Silicon \|"; done
56		- for name in $(scripts/package.sh names windows amd64); do echo "\| \`$name\` \| Windows x86-64 \|"; done
57		- for name in $(scripts/package.sh names linux amd64); do echo "\| \`$name\` \| Linux x86-64 \|"; done
58		- echo "\| \`SHA256SUMS\` \| checksums: \`sha256sum -c SHA256SUMS --ignore-missing\` (\`shasum -a 256 -c\` on macOS) \|"
	55	+ for name in $(scripts/package.sh release-names); do
	56	+ case "$name" in
	57	+ macos-arm64) system="macOS 13 or later, Apple Silicon" ;;
	58	+ windows?amd64) system="Windows x86-64" ;;
	59	+ windows?arm64) system="Windows on Arm" ;;
	60	+ SHA256SUMS) system="checksums: \`shasum -a 256 -c SHA256SUMS\` (macOS), \`Get-FileHash\` (Windows)" ;;
	61	+ *) system="" ;;
	62	+ esac
	63	+ echo "\| \`$name\` \| $system \|"
	64	+ done
59	65	} > "$RUNNER_TEMP/release-notes.md"
60	66	cat "$RUNNER_TEMP/release-notes.md"
61	67	echo "path=$RUNNER_TEMP/release-notes.md" >> "$GITHUB_OUTPUT"

              echo
              echo "| File | System |"
              echo "| --- | --- |"
--            for name in $(scripts/package.sh names macos arm64); do echo "| \`$name\` | macOS 13 or later, Apple Silicon |"; done
++            for name in $(scripts/package.sh release-names); do
--            for name in $(scripts/package.sh names windows amd64); do echo "| \`$name\` | Windows x86-64 |"; done
++              case "$name" in
--            for name in $(scripts/package.sh names linux amd64); do echo "| \`$name\` | Linux x86-64 |"; done
++                *macos-arm64*) system="macOS 13 or later, Apple Silicon" ;;
--            echo "| \`SHA256SUMS\` | checksums: \`sha256sum -c SHA256SUMS --ignore-missing\` (\`shasum -a 256 -c\` on macOS) |"
++                *windows?amd64*) system="Windows x86-64" ;;
++                *windows?arm64*) system="Windows on Arm" ;;
++                SHA256SUMS) system="checksums: \`shasum -a 256 -c SHA256SUMS\` (macOS), \`Get-FileHash\` (Windows)" ;;
++                *) system="" ;;
++              esac
++              echo "| \`$name\` | $system |"
++            done
            } > "$RUNNER_TEMP/release-notes.md"
            cat "$RUNNER_TEMP/release-notes.md"
            echo "path=$RUNNER_TEMP/release-notes.md" >> "$GITHUB_OUTPUT"

modified .memory/history.md +2 -0 Viewed

@@ -191,3 +191,5 @@
191	191	- Follow-up (owner: "je préfère vérifier en local"): `.github/workflows/ci.yml` removed — only `release.yml` (tag push → release) remains. `make verify` (= `check` + `bindings-check`) is what to run before merging; `bindings-check` now also fails on binding files git does not know; `make check-linux` (`scripts/check-linux.sh`) runs `make check` in the Linux Docker image (now with jq and procps for the agents.sh tests). New guide check-before-merging / verifier-avant-de-fusionner (EN/FR, with an optional pre-push hook); run-the-tests, develop-the-application, commands reference, README, RELEASING and indexes no longer mention a CI.
192	192	- Follow-up: `make check-linux` checked in the sandbox (arm64): passes. Fixes on the way: the image needs `binutils-gold` (Go links cgo programs with `-fuse-ld=gold` on arm64: golangci-lint failed "cannot find 'ld'"), `jq` and `procps` (agents.sh tests); the container gets its own `frontend/node_modules` (volume `sidekicks-node-modules-<arch>`) so that its pnpm install never touches the Mac's node_modules, whose store (outside the repo on the Mac) it cannot see; its pnpm store lands in `.pnpm-store/` (ignored; pnpm 12 ignored `npm_config_store_dir`). Docker disk in the sandbox filled up once (image 4.1 GB → 2.6 GB after cleaning the Go/npm caches in the image; `docker builder prune` freed the rest).
193	193	- Follow-up (owner: no darwin amd64): macOS packages are Apple Silicon only — `scripts/package.sh macos` runs `darwin:package ARCH=arm64` (no universal build, no lipo); files `Sidekicks-<v>-macos-arm64.dmg`/`.zip` (names follow the arch like Linux/Windows); tag-release, build-release, release notes, tests, install guide (Apple Silicon M1+, macOS 13+, no Intel build), RELEASING and commands reference updated (EN/FR).
	194	+- Follow-up: owner ran `make release-build` on the Mac: macOS arm64 .dmg/.zip built and signed ad hoc; stopped on the missing `makensis`. `build-release.sh` now checks every prerequisite (macOS host, makensis, zip, Docker) before building anything and before emptying dist/.
	195	+- Follow-up (owner: release only macOS arm and Windows arm + amd for now): `scripts/package.sh` gets `RELEASE_TARGETS="macos/arm64 windows/amd64 windows/arm64"` and `release-names` (single list used by tag-release.sh and the release notes); `package.sh windows <amd64\|arm64>` (one NSIS installer per arch; the NSIS stub is always x86, fine on Windows on Arm); `build-release.sh`: `WINDOWS_ARCHES` (default `amd64 arm64`), Linux only when `LINUX_ARCHES` is set (empty by default; Docker checked only then); `make package-windows` builds both arches. Windows amd64 + arm64 built in the sandbox (`sidekicks.exe` of the arm64 zip is PE32+ ARM64). Install guide: Windows section covers both, Linux moved to "build it from the repository"; RELEASING, publish-a-release, commands reference, README and indexes updated (EN/FR). Linux packaging and `make check-linux` stay.

  - **Follow-up (owner: "je préfère vérifier en local")**: `.github/workflows/ci.yml` removed — only `release.yml` (tag push → release) remains. `make verify` (= `check` + `bindings-check`) is what to run before merging; `bindings-check` now also fails on binding files git does not know; `make check-linux` (`scripts/check-linux.sh`) runs `make check` in the Linux Docker image (now with jq and procps for the agents.sh tests). New guide check-before-merging / verifier-avant-de-fusionner (EN/FR, with an optional pre-push hook); run-the-tests, develop-the-application, commands reference, README, RELEASING and indexes no longer mention a CI.
  - **Follow-up**: `make check-linux` checked in the sandbox (arm64): passes. Fixes on the way: the image needs `binutils-gold` (Go links cgo programs with `-fuse-ld=gold` on arm64: golangci-lint failed "cannot find 'ld'"), `jq` and `procps` (agents.sh tests); the container gets its own `frontend/node_modules` (volume `sidekicks-node-modules-<arch>`) so that its pnpm install never touches the Mac's node_modules, whose store (outside the repo on the Mac) it cannot see; its pnpm store lands in `.pnpm-store/` (ignored; pnpm 12 ignored `npm_config_store_dir`). Docker disk in the sandbox filled up once (image 4.1 GB → 2.6 GB after cleaning the Go/npm caches in the image; `docker builder prune` freed the rest).
  - **Follow-up (owner: no darwin amd64)**: macOS packages are Apple Silicon only — `scripts/package.sh macos` runs `darwin:package ARCH=arm64` (no universal build, no lipo); files `Sidekicks-<v>-macos-arm64.dmg`/`.zip` (names follow the arch like Linux/Windows); tag-release, build-release, release notes, tests, install guide (Apple Silicon M1+, macOS 13+, no Intel build), RELEASING and commands reference updated (EN/FR).
++- **Follow-up**: owner ran `make release-build` on the Mac: macOS arm64 .dmg/.zip built and signed ad hoc; stopped on the missing `makensis`. `build-release.sh` now checks every prerequisite (macOS host, makensis, zip, Docker) before building anything and before emptying dist/.
++- **Follow-up (owner: release only macOS arm and Windows arm + amd for now)**: `scripts/package.sh` gets `RELEASE_TARGETS="macos/arm64 windows/amd64 windows/arm64"` and `release-names` (single list used by tag-release.sh and the release notes); `package.sh windows <amd64|arm64>` (one NSIS installer per arch; the NSIS stub is always x86, fine on Windows on Arm); `build-release.sh`: `WINDOWS_ARCHES` (default `amd64 arm64`), Linux only when `LINUX_ARCHES` is set (empty by default; Docker checked only then); `make package-windows` builds both arches. Windows amd64 + arm64 built in the sandbox (`sidekicks.exe` of the arm64 zip is PE32+ ARM64). Install guide: Windows section covers both, Linux moved to "build it from the repository"; RELEASING, publish-a-release, commands reference, README and indexes updated (EN/FR). Linux packaging and `make check-linux` stay.

modified .memory/summary.md +1 -1 Viewed

@@ -59,6 +59,6 @@ What exists:
59	59	- How to exec a shell / read files inside an `sbx` sandbox (issue #28).
60	60	- Quality gate: `qlty` is not in this sandbox → no qlty measurement yet (issue #38: build a sandbox kit with qlty). golangci-lint (go tool) is the stopgap.
61	61	- On the shared Mac⇄Linux folder, the `mkdir` lock of `scripts/agents.sh` is not exclusive: two agents starting at the same instant could exceed the slot limit in the sandbox. Not seen; on the Mac's own disk mkdir is atomic.
62		-- Release procedure (RELEASING.md): `make release-build` on the Mac (everything into dist/, Linux in Docker), `make release-tag` (pushes `v<version>`), the tag push makes `.github/workflows/release.yml` create the release (notes only, softprops), files attached by hand on the release page. The workflow has not run on Rickub yet; `make release-build` has not run on the Mac yet (Linux arm64 in Docker checked in the sandbox).
	62	+- Release procedure (RELEASING.md): `make release-build` on the Mac (macOS arm64 + Windows amd64/arm64 into dist/; Linux only with LINUX_ARCHES, in Docker), `make release-tag` (pushes `v<version>`), the tag push makes `.github/workflows/release.yml` create the release (notes only, softprops), files attached by hand on the release page. The workflow has not run on Rickub yet; `make release-build` has not run on the Mac yet (Linux arm64 in Docker checked in the sandbox).
63	63	- `make package-macos` (arm64 .dmg) and the Windows installer have not been run on their systems; the folder dialog of the assistant (`ChooseFolder`) not tried on the Mac.
64	64	- Whether `.claude/skills/*` (kit files) should be committed with the project is the owner's call.

  - How to exec a shell / read files inside an `sbx` sandbox (issue #28).
  - Quality gate: `qlty` is not in this sandbox → no qlty measurement yet (issue #38: build a sandbox kit with qlty). golangci-lint (go tool) is the stopgap.
  - On the shared Mac⇄Linux folder, the `mkdir` lock of `scripts/agents.sh` is not exclusive: two agents starting at the same instant could exceed the slot limit in the sandbox. Not seen; on the Mac's own disk mkdir is atomic.
--- Release procedure (RELEASING.md): `make release-build` on the Mac (everything into dist/, Linux in Docker), `make release-tag` (pushes `v<version>`), the tag push makes `.github/workflows/release.yml` create the release (notes only, softprops), files attached by hand on the release page. The workflow has not run on Rickub yet; `make release-build` has not run on the Mac yet (Linux arm64 in Docker checked in the sandbox).
++- Release procedure (RELEASING.md): `make release-build` on the Mac (macOS arm64 + Windows amd64/arm64 into dist/; Linux only with LINUX_ARCHES, in Docker), `make release-tag` (pushes `v<version>`), the tag push makes `.github/workflows/release.yml` create the release (notes only, softprops), files attached by hand on the release page. The workflow has not run on Rickub yet; `make release-build` has not run on the Mac yet (Linux arm64 in Docker checked in the sandbox).
  - `make package-macos` (arm64 .dmg) and the Windows installer have not been run on their systems; the folder dialog of the assistant (`ChooseFolder`) not tried on the Mac.
  - Whether `.claude/skills/*` (kit files) should be committed with the project is the owner's call.

modified Makefile +4 -3 Viewed

@@ -40,13 +40,14 @@ package: ## Package the application (macOS: bin/sidekicks.app)
40	40	package-linux: ## Release packages for Linux (deb, rpm, AppImage, tar.gz) into dist/
41	41	@scripts/package.sh linux
42	42
43		-package-windows: ## Release packages for Windows amd64 (installer, zip) into dist/, cross-built
44		- @scripts/package.sh windows
	43	+package-windows: ## Release packages for Windows amd64 and arm64 (installer, zip) into dist/, cross-built
	44	+ @scripts/package.sh windows amd64
	45	+ @scripts/package.sh windows arm64
45	46
46	47	package-macos: ## Release packages for macOS on Apple Silicon (dmg, zip) into dist/; on macOS only
47	48	@scripts/package.sh macos
48	49
49		-release-build: ## On the Mac: every release package (macOS, Windows, Linux in Docker) and SHA256SUMS into dist/
	50	+release-build: ## On the Mac: every release package (macOS arm64, Windows amd64 and arm64) and SHA256SUMS into dist/
50	51	@scripts/build-release.sh
51	52
52	53	release-tag: ## Tag v<version> on main and push it: the Release workflow creates the release

  package-linux: ## Release packages for Linux (deb, rpm, AppImage, tar.gz) into dist/
  	@scripts/package.sh linux
--package-windows: ## Release packages for Windows amd64 (installer, zip) into dist/, cross-built
++package-windows: ## Release packages for Windows amd64 and arm64 (installer, zip) into dist/, cross-built
--	@scripts/package.sh windows
++	@scripts/package.sh windows amd64
++	@scripts/package.sh windows arm64
  package-macos: ## Release packages for macOS on Apple Silicon (dmg, zip) into dist/; on macOS only
  	@scripts/package.sh macos
--release-build: ## On the Mac: every release package (macOS, Windows, Linux in Docker) and SHA256SUMS into dist/
++release-build: ## On the Mac: every release package (macOS arm64, Windows amd64 and arm64) and SHA256SUMS into dist/
  	@scripts/build-release.sh
  release-tag: ## Tag v<version> on main and push it: the Release workflow creates the release

modified README.md +2 -2 Viewed

@@ -9,7 +9,7 @@
9	9
10	10	A desktop application to talk with AI agents in channels, for people who are not developers. Agents are reached through the [Agent Client Protocol](https://agentclientprotocol.com) (ACP), so any ACP agent can join. Built with Go and [Wails v3](https://wails.io), interface in Svelte 5.
11	11
12		-> Status — version 0.1, the first release: packages for macOS, Linux and Windows; an assistant adds agents (on this computer, in Docker or in an sbx sandbox) without writing YAML; channels kept from one launch to the next, several agents per channel with `@` mentions, agent commands with `/`, direct conversations, each agent's folder with an editor and a terminal; answers stream as Markdown with coloured code, tool calls ask permission in plain words, errors say what to do, and a command palette (⌘K) and shortcuts drive it from the keyboard. Backlog and roadmap: `.tickets/` (IssueSpec).
	12	+> Status — version 0.1, the first release: packages for macOS (Apple Silicon) and Windows (x86-64 and Arm); an assistant adds agents (on this computer, in Docker or in an sbx sandbox) without writing YAML; channels kept from one launch to the next, several agents per channel with `@` mentions, agent commands with `/`, direct conversations, each agent's folder with an editor and a terminal; answers stream as Markdown with coloured code, tool calls ask permission in plain words, errors say what to do, and a command palette (⌘K) and shortcuts drive it from the keyboard. Backlog and roadmap: `.tickets/` (IssueSpec).
13	13
14	14	Install: download the package for your system from the [releases](https://rickub.com/bots-garden/sidekicks/releases), then follow [How to install Sidekicks](docs/en/how-to/install-sidekicks.md).
15	15
@@ -25,7 +25,7 @@ make dev # run the application with hot reload
25	25	make check # lint + every test
26	26	make verify # before merging: check + bindings up to date (there is no CI)
27	27	make package # macOS: bin/sidekicks.app
28		-make package-linux # release packages into dist/ (also package-windows, package-macos)
	28	+make release-build # release packages into dist/ (see RELEASING.md)
29	29	make help # every target
30	30	```
31	31

  A desktop application to talk with AI agents in channels, for people who are not developers. Agents are reached through the [Agent Client Protocol](https://agentclientprotocol.com) (ACP), so any ACP agent can join. Built with Go and [Wails v3](https://wails.io), interface in Svelte 5.
--> **Status — version 0.1, the first release**: packages for macOS, Linux and Windows; an assistant adds agents (on this computer, in Docker or in an sbx sandbox) without writing YAML; channels kept from one launch to the next, several agents per channel with `@` mentions, agent commands with `/`, direct conversations, each agent's folder with an editor and a terminal; answers stream as Markdown with coloured code, tool calls ask permission in plain words, errors say what to do, and a command palette (⌘K) and shortcuts drive it from the keyboard. Backlog and roadmap: `.tickets/` (IssueSpec).
++> **Status — version 0.1, the first release**: packages for macOS (Apple Silicon) and Windows (x86-64 and Arm); an assistant adds agents (on this computer, in Docker or in an sbx sandbox) without writing YAML; channels kept from one launch to the next, several agents per channel with `@` mentions, agent commands with `/`, direct conversations, each agent's folder with an editor and a terminal; answers stream as Markdown with coloured code, tool calls ask permission in plain words, errors say what to do, and a command palette (⌘K) and shortcuts drive it from the keyboard. Backlog and roadmap: `.tickets/` (IssueSpec).
  **Install**: download the package for your system from the [releases](https://rickub.com/bots-garden/sidekicks/releases), then follow [How to install Sidekicks](docs/en/how-to/install-sidekicks.md).
  make check         # lint + every test
  make verify        # before merging: check + bindings up to date (there is no CI)
  make package       # macOS: bin/sidekicks.app
--make package-linux # release packages into dist/ (also package-windows, package-macos)
++make release-build # release packages into dist/ (see RELEASING.md)
  make help          # every target
  ```

modified RELEASING.fr.md +5 -5 Viewed

@@ -6,7 +6,7 @@ Trois étapes, sur le Mac : tout construire, tagger, attacher les fichiers.
6	6
7	7	\| Étape \| Commande \| Résultat \|
8	8	\| --- \| --- \| --- \|
9		-\| 1. Construire \| `make release-build` \| `dist/` : les paquets macOS, Windows et Linux, et `SHA256SUMS` \|
	9	+\| 1. Construire \| `make release-build` \| `dist/` : les paquets macOS (Apple Silicon) et Windows (x86-64 et Arm), et `SHA256SUMS` \|
10	10	\| 2. Tagger \| `make release-tag` \| le tag `v<version>` est poussé ; le workflow Release crée la release sur Rickub, avec ses notes \|
11	11	\| 3. Attacher \| à la main, sur la page de la release \| tous les fichiers de `dist/` attachés à la release \|
12	12
@@ -29,11 +29,11 @@ Il construit, dans `dist/` :
29	29	\| Fichiers \| Comment \|
30	30	\| --- \| --- \|
31	31	\| `Sidekicks-<v>-macos-arm64.dmg`, `.zip` \| en natif, pour Apple Silicon seulement (outils en ligne de commande de Xcode) \|
32		-\| `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` \| compilés depuis le Mac (demande `brew install makensis zip`) \|
33		-\| `sidekicks_<v>_linux_amd64.deb`, `.rpm`, `.tar.gz`, `Sidekicks-<v>-x86_64.AppImage` \| dans un conteneur Docker (Docker doit tourner ; amd64 est émulé sur Apple Silicon, c'est donc un peu long) \|
	32	+\| `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` \| compilés depuis le Mac (demande `brew install makensis`) \|
	33	+\| `Sidekicks-<v>-windows-arm64-installer.exe`, `sidekicks_<v>_windows_arm64.zip` \| compilés depuis le Mac, pour Windows sur Arm \|
34	34	\| `SHA256SUMS` \| sur tous les fichiers ci-dessus \|
35	35
36		-`LINUX_ARCHES="amd64 arm64" make release-build` ajoute les paquets Linux arm64 ; `SKIP="linux"` (ou `macos`, `windows`) laisse un système de côté.
	36	+Pas de paquets Linux dans les releases pour le moment : `LINUX_ARCHES=amd64 make release-build` les construit aussi, dans Docker. `SKIP="windows"` (ou `macos`) laisse un système de côté ; `WINDOWS_ARCHES=amd64` ne construit qu'une architecture Windows. La liste des fichiers d'une release est `scripts/package.sh release-names`.
37	37
38	38	## 2. Tagger
39	39
@@ -51,7 +51,7 @@ Ouvrez la release sur Rickub (Releases → v<version>) et attachez tous les
51	51
52	52	\| Symptôme \| Que faire \|
53	53	\| --- \| --- \|
54		-\| `makensis is missing` / `Docker is not running` \| `brew install makensis zip` / lancez Docker Desktop — ou laissez ce système de côté avec `SKIP`. \|
	54	+\| `makensis is missing` \| `brew install makensis` — ou `SKIP=windows`. \|
55	55	\| `the tag v… already exists` \| Cette version a déjà été publiée : augmentez `info.version`. \|
56	56	\| Le workflow a échoué : « The tag is … but build/config.yml says … » \| Supprimez le tag (`git push origin :refs/tags/v…` et `git tag -d v…`), corrigez `info.version`, recommencez. \|
57	57	\| Le workflow a tourné mais aucune release n'est apparue \| Le journal du job dit pourquoi (un `403` veut dire que le jeton n'a pas pu écrire : `permissions: contents: write` doit rester dans `release.yml`). Créez la release à la main sur Rickub depuis le tag ; les notes sont dans le journal du job. \|

  | Étape | Commande | Résultat |
  | --- | --- | --- |
--| 1. Construire | `make release-build` | `dist/` : les paquets macOS, Windows et Linux, et `SHA256SUMS` |
++| 1. Construire | `make release-build` | `dist/` : les paquets macOS (Apple Silicon) et Windows (x86-64 et Arm), et `SHA256SUMS` |
  | 2. Tagger | `make release-tag` | le tag `v<version>` est poussé ; le workflow **Release** crée la release sur Rickub, avec ses notes |
  | 3. Attacher | à la main, sur la page de la release | tous les fichiers de `dist/` attachés à la release |
  | Fichiers | Comment |
  | --- | --- |
  | `Sidekicks-<v>-macos-arm64.dmg`, `.zip` | en natif, pour Apple Silicon seulement (outils en ligne de commande de Xcode) |
--| `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` | compilés depuis le Mac (demande `brew install makensis zip`) |
++| `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` | compilés depuis le Mac (demande `brew install makensis`) |
--| `sidekicks_<v>_linux_amd64.deb`, `.rpm`, `.tar.gz`, `Sidekicks-<v>-x86_64.AppImage` | dans un conteneur Docker (Docker doit tourner ; amd64 est émulé sur Apple Silicon, c'est donc un peu long) |
++| `Sidekicks-<v>-windows-arm64-installer.exe`, `sidekicks_<v>_windows_arm64.zip` | compilés depuis le Mac, pour Windows sur Arm |
  | `SHA256SUMS` | sur tous les fichiers ci-dessus |
--`LINUX_ARCHES="amd64 arm64" make release-build` ajoute les paquets Linux arm64 ; `SKIP="linux"` (ou `macos`, `windows`) laisse un système de côté.
++Pas de paquets Linux dans les releases pour le moment : `LINUX_ARCHES=amd64 make release-build` les construit aussi, dans Docker. `SKIP="windows"` (ou `macos`) laisse un système de côté ; `WINDOWS_ARCHES=amd64` ne construit qu'une architecture Windows. La liste des fichiers d'une release est `scripts/package.sh release-names`.
  ## 2. Tagger
  | Symptôme | Que faire |
  | --- | --- |
--| `makensis is missing` / `Docker is not running` | `brew install makensis zip` / lancez Docker Desktop — ou laissez ce système de côté avec `SKIP`. |
++| `makensis is missing` | `brew install makensis` — ou `SKIP=windows`. |
  | `the tag v… already exists` | Cette version a déjà été publiée : augmentez `info.version`. |
  | Le workflow a échoué : « The tag is … but build/config.yml says … » | Supprimez le tag (`git push origin :refs/tags/v…` et `git tag -d v…`), corrigez `info.version`, recommencez. |
  | Le workflow a tourné mais aucune release n'est apparue | Le journal du job dit pourquoi (un `403` veut dire que le jeton n'a pas pu écrire : `permissions: contents: write` doit rester dans `release.yml`). Créez la release à la main sur Rickub depuis le tag ; les notes sont dans le journal du job. |

modified RELEASING.md +5 -5 Viewed

@@ -6,7 +6,7 @@ Three steps, on the Mac: build everything, tag, attach the files.
6	6
7	7	\| Step \| Command \| Result \|
8	8	\| --- \| --- \| --- \|
9		-\| 1. Build \| `make release-build` \| `dist/`: the macOS, Windows and Linux packages, and `SHA256SUMS` \|
	9	+\| 1. Build \| `make release-build` \| `dist/`: the macOS (Apple Silicon) and Windows (x86-64 and Arm) packages, and `SHA256SUMS` \|
10	10	\| 2. Tag \| `make release-tag` \| the tag `v<version>` is pushed; the Release workflow creates the release on Rickub, with its notes \|
11	11	\| 3. Attach \| by hand, on the release page \| every file of `dist/` attached to the release \|
12	12
@@ -29,11 +29,11 @@ It builds, into `dist/`:
29	29	\| Files \| How \|
30	30	\| --- \| --- \|
31	31	\| `Sidekicks-<v>-macos-arm64.dmg`, `.zip` \| natively, for Apple Silicon only (Xcode command line tools) \|
32		-\| `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` \| cross-built (needs `brew install makensis zip`) \|
33		-\| `sidekicks_<v>_linux_amd64.deb`, `.rpm`, `.tar.gz`, `Sidekicks-<v>-x86_64.AppImage` \| in a Docker container (needs Docker running; amd64 is emulated on Apple Silicon, so it takes a while) \|
	32	+\| `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` \| cross-built (needs `brew install makensis`) \|
	33	+\| `Sidekicks-<v>-windows-arm64-installer.exe`, `sidekicks_<v>_windows_arm64.zip` \| cross-built, for Windows on Arm \|
34	34	\| `SHA256SUMS` \| over all the files above \|
35	35
36		-`LINUX_ARCHES="amd64 arm64" make release-build` adds the Linux arm64 packages; `SKIP="linux"` (or `macos`, `windows`) leaves a system out.
	36	+No Linux packages in the releases for now: `LINUX_ARCHES=amd64 make release-build` builds them too, in Docker. `SKIP="windows"` (or `macos`) leaves a system out; `WINDOWS_ARCHES=amd64` builds one Windows architecture only. The list of the files of a release is `scripts/package.sh release-names`.
37	37
38	38	## 2. Tag
39	39
@@ -51,7 +51,7 @@ Open the release on Rickub (Releases → v<version>), and attach every file
51	51
52	52	\| Symptom \| What to do \|
53	53	\| --- \| --- \|
54		-\| `makensis is missing` / `Docker is not running` \| `brew install makensis zip` / start Docker Desktop — or leave that system out with `SKIP`. \|
	54	+\| `makensis is missing` \| `brew install makensis` — or `SKIP=windows`. \|
55	55	\| `the tag v… already exists` \| That version was released already: raise `info.version`. \|
56	56	\| The workflow failed: "The tag is … but build/config.yml says …" \| Delete the tag (`git push origin :refs/tags/v…` and `git tag -d v…`), fix `info.version`, start again. \|
57	57	\| The workflow ran but no release appeared \| The job's log tells why (a `403` means the token could not write: `permissions: contents: write` must stay in `release.yml`). Create the release by hand on Rickub from the tag; the notes are in the job's log. \|

  | Step | Command | Result |
  | --- | --- | --- |
--| 1. Build | `make release-build` | `dist/`: the macOS, Windows and Linux packages, and `SHA256SUMS` |
++| 1. Build | `make release-build` | `dist/`: the macOS (Apple Silicon) and Windows (x86-64 and Arm) packages, and `SHA256SUMS` |
  | 2. Tag | `make release-tag` | the tag `v<version>` is pushed; the **Release** workflow creates the release on Rickub, with its notes |
  | 3. Attach | by hand, on the release page | every file of `dist/` attached to the release |
  | Files | How |
  | --- | --- |
  | `Sidekicks-<v>-macos-arm64.dmg`, `.zip` | natively, for Apple Silicon only (Xcode command line tools) |
--| `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` | cross-built (needs `brew install makensis zip`) |
++| `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` | cross-built (needs `brew install makensis`) |
--| `sidekicks_<v>_linux_amd64.deb`, `.rpm`, `.tar.gz`, `Sidekicks-<v>-x86_64.AppImage` | in a Docker container (needs Docker running; amd64 is emulated on Apple Silicon, so it takes a while) |
++| `Sidekicks-<v>-windows-arm64-installer.exe`, `sidekicks_<v>_windows_arm64.zip` | cross-built, for Windows on Arm |
  | `SHA256SUMS` | over all the files above |
--`LINUX_ARCHES="amd64 arm64" make release-build` adds the Linux arm64 packages; `SKIP="linux"` (or `macos`, `windows`) leaves a system out.
++No Linux packages in the releases for now: `LINUX_ARCHES=amd64 make release-build` builds them too, in Docker. `SKIP="windows"` (or `macos`) leaves a system out; `WINDOWS_ARCHES=amd64` builds one Windows architecture only. The list of the files of a release is `scripts/package.sh release-names`.
  ## 2. Tag
  | Symptom | What to do |
  | --- | --- |
--| `makensis is missing` / `Docker is not running` | `brew install makensis zip` / start Docker Desktop — or leave that system out with `SKIP`. |
++| `makensis is missing` | `brew install makensis` — or `SKIP=windows`. |
  | `the tag v… already exists` | That version was released already: raise `info.version`. |
  | The workflow failed: "The tag is … but build/config.yml says …" | Delete the tag (`git push origin :refs/tags/v…` and `git tag -d v…`), fix `info.version`, start again. |
  | The workflow ran but no release appeared | The job's log tells why (a `403` means the token could not write: `permissions: contents: write` must stay in `release.yml`). Create the release by hand on Rickub from the tag; the notes are in the job's log. |

modified docs/en/README.md +1 -1 Viewed

@@ -1,6 +1,6 @@
1	1	# Sidekicks documentation (English)
2	2
3		-Sidekicks is a desktop application to talk with AI agents in channels, through the Agent Client Protocol, designed for people who are not developers. Version 0.1 is the first release: packages for macOS, Linux and Windows, an assistant that adds agents without writing YAML, error messages in plain words, keyboard shortcuts and a command palette — on top of channels with several agents (`@`, `/`, history kept across restarts), each agent's folder with an editor and a terminal (on this computer, in Docker or in an sbx sandbox), formatted answers and tools that need your approval.
	3	+Sidekicks is a desktop application to talk with AI agents in channels, through the Agent Client Protocol, designed for people who are not developers. Version 0.1 is the first release: packages for macOS (Apple Silicon) and Windows (x86-64 and Arm), an assistant that adds agents without writing YAML, error messages in plain words, keyboard shortcuts and a command palette — on top of channels with several agents (`@`, `/`, history kept across restarts), each agent's folder with an editor and a terminal (on this computer, in Docker or in an sbx sandbox), formatted answers and tools that need your approval.
4	4
5	5	This documentation follows [Diátaxis](https://diataxis.fr): pick the section that matches what you need right now.
6	6

  # Sidekicks documentation (English)
--Sidekicks is a desktop application to talk with AI agents in channels, through the Agent Client Protocol, designed for people who are not developers. Version 0.1 is the first release: packages for macOS, Linux and Windows, an assistant that adds agents without writing YAML, error messages in plain words, keyboard shortcuts and a command palette — on top of channels with several agents (`@`, `/`, history kept across restarts), each agent's folder with an editor and a terminal (on this computer, in Docker or in an sbx sandbox), formatted answers and tools that need your approval.
++Sidekicks is a desktop application to talk with AI agents in channels, through the Agent Client Protocol, designed for people who are not developers. Version 0.1 is the first release: packages for macOS (Apple Silicon) and Windows (x86-64 and Arm), an assistant that adds agents without writing YAML, error messages in plain words, keyboard shortcuts and a command palette — on top of channels with several agents (`@`, `/`, history kept across restarts), each agent's folder with an editor and a terminal (on this computer, in Docker or in an sbx sandbox), formatted answers and tools that need your approval.
  This documentation follows [Diátaxis](https://diataxis.fr): pick the section that matches what you need right now.

modified docs/en/how-to/install-sidekicks.md +15 -16 Viewed

@@ -1,6 +1,6 @@
1	1	# How to install Sidekicks
2	2
3		-This guide shows how to install Sidekicks from the packages of a release, on macOS, Linux or Windows. The packages are on the project's releases page, `https://rickub.com/bots-garden/sidekicks/releases`; `SHA256SUMS` lists their checksums.
	3	+This guide shows how to install Sidekicks from the packages of a release, on macOS or Windows (Linux: built from the repository). The packages are on the project's releases page, `https://rickub.com/bots-garden/sidekicks/releases`; `SHA256SUMS` lists their checksums.
4	4
5	5	Sidekicks talks with agents; it does not contain one. Install your agent's program too (for instance `mm`).
6	6
@@ -15,32 +15,31 @@ Sidekicks needs a Mac with Apple Silicon (M1 or later) and macOS 13 (Ventura) or
15	15
16	16	From then on, Sidekicks opens normally.
17	17
18		-## Linux (x86-64)
	18	+## Windows (x86-64 and Arm)
19	19
20		-Sidekicks needs GTK 4 and WebKitGTK 6 (Ubuntu 24.04 or later, Debian 13, Fedora 40 or later).
	20	+1. Download the installer of your processor and run it: `Sidekicks-<version>-windows-amd64-installer.exe` (Intel and AMD) or `Sidekicks-<version>-windows-arm64-installer.exe` (Windows on Arm, e.g. Snapdragon). Settings → System → About → System type tells which one you have.
	21	+2. The installer is not signed: Windows SmartScreen may say "Windows protected your PC". Click More info, then Run anyway.
	22	+3. The installer adds Microsoft Edge WebView2 when it is missing, then a Sidekicks shortcut.
21	23
22		-- Debian, Ubuntu: `sudo apt install ./sidekicks_<version>_linux_amd64.deb`
23		-- Fedora: `sudo dnf install ./sidekicks_<version>_linux_amd64.rpm`
24		-- Any distribution, without installing: `chmod +x Sidekicks-<version>-x86_64.AppImage`, then run it. If it complains about FUSE, run it with `--appimage-extract-and-run`.
25		-- The bare program: `sidekicks_<version>_linux_amd64.tar.gz` holds `sidekicks`; the GTK 4 and WebKitGTK 6 libraries must be installed.
	24	+`sidekicks_<version>_windows_amd64.zip` and `sidekicks_<version>_windows_arm64.zip` hold the bare `sidekicks.exe`, for a machine where WebView2 is already present.
26	25
27		-The `.deb` and `.rpm` add Sidekicks to the applications menu.
	26	+On Windows, the Terminal tab of an agent is not available yet; files, conversations and agents in Docker work.
28	27
29		-## Windows (x86-64)
	28	+## Linux
30	29
31		-1. Download `Sidekicks-<version>-windows-amd64-installer.exe` and run it.
32		-2. The installer is not signed: Windows SmartScreen may say "Windows protected your PC". Click More info, then Run anyway.
33		-3. The installer adds Microsoft Edge WebView2 when it is missing, then a Sidekicks shortcut.
	30	+The releases do not hold Linux packages for now. Build them from the repository, on Linux (`make package-linux`) or on a Mac with Docker (`LINUX_ARCHES=amd64 make release-build`), then:
34	31
35		-`sidekicks_<version>_windows_amd64.zip` holds the bare `sidekicks.exe`, for a machine where WebView2 is already present.
	32	+- Debian, Ubuntu: `sudo apt install ./sidekicks_<version>_linux_amd64.deb`
	33	+- Fedora: `sudo dnf install ./sidekicks_<version>_linux_amd64.rpm`
	34	+- Any distribution, without installing: `chmod +x Sidekicks-<version>-x86_64.AppImage`, then run it. If it complains about FUSE, run it with `--appimage-extract-and-run`.
36	35
37		-On Windows, the Terminal tab of an agent is not available yet; files, conversations and agents in Docker work.
	36	+Sidekicks needs GTK 4 and WebKitGTK 6 (Ubuntu 24.04 or later, Debian 13, Fedora 40 or later).
38	37
39	38	## Variants
40	39
41		-- Check a download: `shasum -a 256 <file>` (macOS) or `sha256sum <file>` (Linux), and compare with `SHA256SUMS`.
	40	+- Check a download: `shasum -a 256 <file>` (macOS) or `Get-FileHash <file>` in PowerShell (Windows), and compare with `SHA256SUMS`.
42	41	- macOS, from a terminal: `xattr -dr com.apple.quarantine /Applications/sidekicks.app` lifts the quarantine instead of step 4.
43		-- Build it yourself: `make package-macos`, `make package-linux` or `make package-windows` (see [How to publish a release](publish-a-release.md)).
	42	+- Build it yourself: `make package-macos` or `make package-windows` (see [How to publish a release](publish-a-release.md)).
44	43
45	44	## See also
46	45

  # How to install Sidekicks
--This guide shows how to install Sidekicks from the packages of a release, on macOS, Linux or Windows. The packages are on the project's releases page, `https://rickub.com/bots-garden/sidekicks/releases`; `SHA256SUMS` lists their checksums.
++This guide shows how to install Sidekicks from the packages of a release, on macOS or Windows (Linux: built from the repository). The packages are on the project's releases page, `https://rickub.com/bots-garden/sidekicks/releases`; `SHA256SUMS` lists their checksums.
  Sidekicks talks with agents; it does not contain one. Install your agent's program too (for instance `mm`).
  From then on, Sidekicks opens normally.
--## Linux (x86-64)
++## Windows (x86-64 and Arm)
--Sidekicks needs GTK 4 and WebKitGTK 6 (Ubuntu 24.04 or later, Debian 13, Fedora 40 or later).
++1. Download the installer of your processor and run it: `Sidekicks-<version>-windows-amd64-installer.exe` (Intel and AMD) or `Sidekicks-<version>-windows-arm64-installer.exe` (Windows on Arm, e.g. Snapdragon). **Settings → System → About → System type** tells which one you have.
++2. The installer is not signed: Windows SmartScreen may say "Windows protected your PC". Click **More info**, then **Run anyway**.
++3. The installer adds Microsoft Edge WebView2 when it is missing, then a Sidekicks shortcut.
--- **Debian, Ubuntu**: `sudo apt install ./sidekicks_<version>_linux_amd64.deb`
++`sidekicks_<version>_windows_amd64.zip` and `sidekicks_<version>_windows_arm64.zip` hold the bare `sidekicks.exe`, for a machine where WebView2 is already present.
--- **Fedora**: `sudo dnf install ./sidekicks_<version>_linux_amd64.rpm`
--- **Any distribution, without installing**: `chmod +x Sidekicks-<version>-x86_64.AppImage`, then run it. If it complains about FUSE, run it with `--appimage-extract-and-run`.
--- **The bare program**: `sidekicks_<version>_linux_amd64.tar.gz` holds `sidekicks`; the GTK 4 and WebKitGTK 6 libraries must be installed.
--The `.deb` and `.rpm` add Sidekicks to the applications menu.
++On Windows, the **Terminal** tab of an agent is not available yet; files, conversations and agents in Docker work.
--## Windows (x86-64)
++## Linux
--1. Download `Sidekicks-<version>-windows-amd64-installer.exe` and run it.
++The releases do not hold Linux packages for now. Build them from the repository, on Linux (`make package-linux`) or on a Mac with Docker (`LINUX_ARCHES=amd64 make release-build`), then:
--2. The installer is not signed: Windows SmartScreen may say "Windows protected your PC". Click **More info**, then **Run anyway**.
--3. The installer adds Microsoft Edge WebView2 when it is missing, then a Sidekicks shortcut.
--`sidekicks_<version>_windows_amd64.zip` holds the bare `sidekicks.exe`, for a machine where WebView2 is already present.
++- **Debian, Ubuntu**: `sudo apt install ./sidekicks_<version>_linux_amd64.deb`
++- **Fedora**: `sudo dnf install ./sidekicks_<version>_linux_amd64.rpm`
++- **Any distribution, without installing**: `chmod +x Sidekicks-<version>-x86_64.AppImage`, then run it. If it complains about FUSE, run it with `--appimage-extract-and-run`.
--On Windows, the **Terminal** tab of an agent is not available yet; files, conversations and agents in Docker work.
++Sidekicks needs GTK 4 and WebKitGTK 6 (Ubuntu 24.04 or later, Debian 13, Fedora 40 or later).
  ## Variants
--- **Check a download**: `shasum -a 256 <file>` (macOS) or `sha256sum <file>` (Linux), and compare with `SHA256SUMS`.
++- **Check a download**: `shasum -a 256 <file>` (macOS) or `Get-FileHash <file>` in PowerShell (Windows), and compare with `SHA256SUMS`.
  - **macOS, from a terminal**: `xattr -dr com.apple.quarantine /Applications/sidekicks.app` lifts the quarantine instead of step 4.
--- **Build it yourself**: `make package-macos`, `make package-linux` or `make package-windows` (see [How to publish a release](publish-a-release.md)).
++- **Build it yourself**: `make package-macos` or `make package-windows` (see [How to publish a release](publish-a-release.md)).
  ## See also

modified docs/en/how-to/publish-a-release.md +5 -5 Viewed

@@ -1,21 +1,21 @@
1	1	# How to publish a release
2	2
3		-This guide shows how to publish a Sidekicks release from a Mac: build every package, tag, attach the files to the release that Rickub creates. It assumes the development tools of [How to develop the application](develop-the-application.md), Docker Desktop running, `brew install makensis zip`, and the right to push tags. [RELEASING.md](../../../RELEASING.md) is the same procedure as a checklist.
	3	+This guide shows how to publish a Sidekicks release from a Mac: build every package, tag, attach the files to the release that Rickub creates. It assumes the development tools of [How to develop the application](develop-the-application.md), `brew install makensis`, and the right to push tags. [RELEASING.md](../../../RELEASING.md) is the same procedure as a checklist.
4	4
5	5	## Steps
6	6
7	7	1. Set the version in `build/config.yml` (`info.version`), run `wails3 task common:update:build-assets`, put `LSMinimumSystemVersion` back to `13.0.0` in `build/darwin/Info.plist` and `Info.dev.plist`, then commit, merge into `main` and `git checkout main && git pull`.
8		-2. Build everything: `make release-build`. `dist/` then holds the macOS packages (`.dmg` and `.zip` for Apple Silicon), the Windows ones (installer and `.zip`), the Linux amd64 ones (`.deb`, `.rpm`, `.AppImage`, `.tar.gz`, built in Docker) and `SHA256SUMS`.
	8	+2. Build everything: `make release-build`. `dist/` then holds the macOS packages (`.dmg` and `.zip` for Apple Silicon), the Windows ones (installer and `.zip`, for x86-64 and for Arm) and `SHA256SUMS`.
9	9	3. Tag: `make release-tag`. The tag `v<version>` is pushed, and the Release workflow creates the release on Rickub with notes listing the files.
10	10	4. Attach the files: on Rickub, open Releases → v<version> and attach every file of `dist/`.
11	11
12	12	## Variants
13	13
14		-- Linux arm64 too: `LINUX_ARCHES="amd64 arm64" make release-build`.
15		-- Leave a system out: `SKIP="linux"` (or `macos`, `windows`, several separated by spaces) before `make release-build`.
	14	+- Linux packages too (not released for now): `LINUX_ARCHES=amd64 make release-build`, with Docker Desktop running.
	15	+- Leave a system out: `SKIP="windows"` (or `macos`) before `make release-build`; `WINDOWS_ARCHES=amd64` for one Windows architecture.
16	16	- Tag without pushing: `scripts/tag-release.sh --no-push`, then `git push origin v<version>` when ready.
17	17	- Wrong tag: `git push origin :refs/tags/v<version>` and `git tag -d v<version>`, delete the release if it was created, fix the version and tag again.
18		-- One package only: `make package-macos`, `make package-windows` or `make package-linux` (Linux only, for the machine's architecture).
	18	+- One system only: `make package-macos`, `make package-windows` (both architectures) or `make package-linux` (on Linux, for the machine's architecture).
19	19
20	20	## See also
21	21

  # How to publish a release
--This guide shows how to publish a Sidekicks release from a Mac: build every package, tag, attach the files to the release that Rickub creates. It assumes the development tools of [How to develop the application](develop-the-application.md), Docker Desktop running, `brew install makensis zip`, and the right to push tags. [RELEASING.md](../../../RELEASING.md) is the same procedure as a checklist.
++This guide shows how to publish a Sidekicks release from a Mac: build every package, tag, attach the files to the release that Rickub creates. It assumes the development tools of [How to develop the application](develop-the-application.md), `brew install makensis`, and the right to push tags. [RELEASING.md](../../../RELEASING.md) is the same procedure as a checklist.
  ## Steps
 . **Set the version** in `build/config.yml` (`info.version`), run `wails3 task common:update:build-assets`, put `LSMinimumSystemVersion` back to `13.0.0` in `build/darwin/Info.plist` and `Info.dev.plist`, then commit, merge into `main` and `git checkout main && git pull`.
--2. **Build everything**: `make release-build`. `dist/` then holds the macOS packages (`.dmg` and `.zip` for Apple Silicon), the Windows ones (installer and `.zip`), the Linux amd64 ones (`.deb`, `.rpm`, `.AppImage`, `.tar.gz`, built in Docker) and `SHA256SUMS`.
++2. **Build everything**: `make release-build`. `dist/` then holds the macOS packages (`.dmg` and `.zip` for Apple Silicon), the Windows ones (installer and `.zip`, for x86-64 and for Arm) and `SHA256SUMS`.
 . **Tag**: `make release-tag`. The tag `v<version>` is pushed, and the **Release** workflow creates the release on Rickub with notes listing the files.
 . **Attach the files**: on Rickub, open **Releases → v<version>** and attach every file of `dist/`.
  ## Variants
--- **Linux arm64 too**: `LINUX_ARCHES="amd64 arm64" make release-build`.
++- **Linux packages too** (not released for now): `LINUX_ARCHES=amd64 make release-build`, with Docker Desktop running.
--- **Leave a system out**: `SKIP="linux"` (or `macos`, `windows`, several separated by spaces) before `make release-build`.
++- **Leave a system out**: `SKIP="windows"` (or `macos`) before `make release-build`; `WINDOWS_ARCHES=amd64` for one Windows architecture.
  - **Tag without pushing**: `scripts/tag-release.sh --no-push`, then `git push origin v<version>` when ready.
  - **Wrong tag**: `git push origin :refs/tags/v<version>` and `git tag -d v<version>`, delete the release if it was created, fix the version and tag again.
--- **One package only**: `make package-macos`, `make package-windows` or `make package-linux` (Linux only, for the machine's architecture).
++- **One system only**: `make package-macos`, `make package-windows` (both architectures) or `make package-linux` (on Linux, for the machine's architecture).
  ## See also

modified docs/en/reference/commands.md +9 -7 Viewed

@@ -26,8 +26,8 @@ The order is detailed in the [configuration reference](configuration.md#location
26	26	\| `build` \| `wails3 build`: `bin/sidekicks`. \|
27	27	\| `package` \| `wails3 package`: on macOS `bin/sidekicks.app`. \|
28	28	\| `package-linux` \| `scripts/package.sh linux`: `.deb`, `.rpm`, `.AppImage` and `.tar.gz` for the machine's architecture, into `dist/`. Needs `file` (AppImage) and `rpm`. \|
29		-\| `package-windows` \| `scripts/package.sh windows`: NSIS installer and `.zip` for Windows amd64, cross-built, into `dist/`. Needs `makensis` and `zip`. \|
30		-\| `release-build` \| `scripts/build-release.sh`: on the Mac, every release package into `dist/` and `SHA256SUMS`. \|
	29	+\| `package-windows` \| `scripts/package.sh windows amd64` then `arm64`: NSIS installer and `.zip` for each, cross-built, into `dist/`. Needs `makensis` and `zip`. \|
	30	+\| `release-build` \| `scripts/build-release.sh`: on the Mac, every release package (macOS arm64, Windows amd64 and arm64) into `dist/` and `SHA256SUMS`. \|
31	31	\| `release-tag` \| `scripts/tag-release.sh`: tags `v<version>` on `main` and pushes it. \|
32	32	\| `package-macos` \| `scripts/package.sh macos`: `.dmg` and `.zip` for Apple Silicon (arm64, signed ad hoc; no Intel build), into `dist/`. macOS only. \|
33	33	\| `install-test-config` \| `scripts/install-test-config.sh`: writes `examples/test-agents.yaml` at the default configuration location with absolute paths to the repository: each agent is `mm -acp -config agent.yaml` started in its folder, with `afterStop: [<repo>/scripts/agents.sh, unload, <agent>]` to unload its model when it stops, `mm` written with its absolute path (`MM_BIN`, or the one in `PATH`), and the current `PATH` in each agent's `env`; an existing file is kept as `config.yaml.<date>.bak`. \|
@@ -56,8 +56,9 @@ Lists the source files (`.go .ts .js .svelte .css .html .sh .py .yml .yaml`, `Ma
56	56	## `scripts/package.sh`
57	57
58	58	```text
59		-scripts/package.sh linux \| windows \| macos
	59	+scripts/package.sh linux \| windows [amd64\|arm64] \| macos
60	60	scripts/package.sh names <system> <arch>
	61	+scripts/package.sh release-names
61	62	scripts/package.sh version
62	63	```
63	64
@@ -65,21 +66,22 @@ scripts/package.sh version
65	66	\| --- \| --- \|
66	67	\| `linux`, `windows`, `macos` \| Builds the packages of that system into `dist/` (see the `package-*` targets), then lists `dist/`. \|
67	68	\| `names <system> <arch>` \| Prints the file names a build produces, one per line; builds nothing. \|
	69	+\| `release-names` \| Prints the files of a release: the names of each target of `RELEASE_TARGETS` (`macos/arm64 windows/amd64 windows/arm64`), then `SHA256SUMS`. Used by `tag-release.sh` and the Release workflow. \|
68	70	\| `version` \| Prints `info.version` of `build/config.yml`. \|
69	71
70	72	\| System \| Files (`<v>` = version) \|
71	73	\| --- \| --- \|
72	74	\| `linux` \| `sidekicks_<v>_linux_<arch>.deb`, `.rpm`, `.tar.gz`, `Sidekicks-<v>-<x86_64\\|aarch64>.AppImage` \|
73		-\| `windows` \| `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` \|
	75	+\| `windows` \| `Sidekicks-<v>-windows-<amd64\\|arm64>-installer.exe`, `sidekicks_<v>_windows_<amd64\\|arm64>.zip` \|
74	76	\| `macos` \| `Sidekicks-<v>-macos-arm64.dmg`, `Sidekicks-<v>-macos-arm64.zip` \|
75	77
76	78	## `scripts/build-release.sh`
77	79
78	80	```text
79		-[LINUX_ARCHES="amd64 arm64"] [SKIP="macos windows linux"] scripts/build-release.sh
	81	+[WINDOWS_ARCHES="amd64 arm64"] [LINUX_ARCHES="amd64"] [SKIP="macos windows"] scripts/build-release.sh
80	82	```
81	83
82		-Empties `dist/`, then builds: macOS with `scripts/package.sh macos` (macOS only), Windows with `scripts/package.sh windows` (needs `makensis`), Linux with `scripts/package.sh linux` in a container per architecture of `LINUX_ARCHES` (default `amd64`), built from `scripts/linux-packages.Dockerfile` (`ubuntu:26.04`, Go of `go.mod`, pnpm of `frontend/package.json`, Wails CLI) with the repository mounted at `/src` and the Go module cache in the volume `sidekicks-gomod-<arch>`. Finally writes `dist/SHA256SUMS`. `SKIP` leaves the systems it names out. Fails when `makensis` is missing or Docker is not running, naming the system to skip.
	84	+Checks every prerequisite first, then empties `dist/` and builds: macOS with `scripts/package.sh macos` (macOS only), Windows with `scripts/package.sh windows <arch>` for each of `WINDOWS_ARCHES` (default `amd64 arm64`; needs `makensis` and `zip`), and, only when `LINUX_ARCHES` is set (empty by default: no Linux in the releases for now), Linux with `scripts/package.sh linux` in a container per architecture, built from `scripts/linux-packages.Dockerfile` (`ubuntu:26.04`, Go of `go.mod`, pnpm of `frontend/package.json`, Wails CLI) with the repository mounted at `/src` and the Go module cache in the volume `sidekicks-gomod-<arch>`. Finally writes `dist/SHA256SUMS`. `SKIP` leaves the systems it names out. Fails, before building anything, when a prerequisite is missing (macOS host, `makensis`, `zip`, Docker for Linux).
83	85
84	86	## `scripts/tag-release.sh`
85	87
@@ -91,4 +93,4 @@ Creates the annotated tag `v<version>` (`info.version` of `build/config.yml`, me
91	93
92	94	## Release workflow
93	95
94		-`.github/workflows/release.yml`, on the push of a tag `v*`, with `permissions: contents: write`: fails when the tag is not `v` + `info.version` of `build/config.yml`, then creates the release `<tag>` named `Sidekicks <tag>` (`softprops/action-gh-release@v2`, through Rickub's GitHub-compatible API behind `GITHUB_API_URL`), with notes giving the commit, the install guides and the table of the files to expect (from `scripts/package.sh names`). It attaches no file: the packages are attached by hand.
	96	+`.github/workflows/release.yml`, on the push of a tag `v*`, with `permissions: contents: write`: fails when the tag is not `v` + `info.version` of `build/config.yml`, then creates the release `<tag>` named `Sidekicks <tag>` (`softprops/action-gh-release@v2`, through Rickub's GitHub-compatible API behind `GITHUB_API_URL`), with notes giving the commit, the install guides and the table of the files to expect (from `scripts/package.sh release-names`). It attaches no file: the packages are attached by hand.

  | `build` | `wails3 build`: `bin/sidekicks`. |
  | `package` | `wails3 package`: on macOS `bin/sidekicks.app`. |
  | `package-linux` | `scripts/package.sh linux`: `.deb`, `.rpm`, `.AppImage` and `.tar.gz` for the machine's architecture, into `dist/`. Needs `file` (AppImage) and `rpm`. |
--| `package-windows` | `scripts/package.sh windows`: NSIS installer and `.zip` for Windows amd64, cross-built, into `dist/`. Needs `makensis` and `zip`. |
++| `package-windows` | `scripts/package.sh windows amd64` then `arm64`: NSIS installer and `.zip` for each, cross-built, into `dist/`. Needs `makensis` and `zip`. |
--| `release-build` | `scripts/build-release.sh`: on the Mac, every release package into `dist/` and `SHA256SUMS`. |
++| `release-build` | `scripts/build-release.sh`: on the Mac, every release package (macOS arm64, Windows amd64 and arm64) into `dist/` and `SHA256SUMS`. |
  | `release-tag` | `scripts/tag-release.sh`: tags `v<version>` on `main` and pushes it. |
  | `package-macos` | `scripts/package.sh macos`: `.dmg` and `.zip` for Apple Silicon (arm64, signed ad hoc; no Intel build), into `dist/`. macOS only. |
  | `install-test-config` | `scripts/install-test-config.sh`: writes `examples/test-agents.yaml` at the default configuration location with absolute paths to the repository: each agent is `mm -acp -config agent.yaml` started in its folder, with `afterStop: [<repo>/scripts/agents.sh, unload, <agent>]` to unload its model when it stops, `mm` written with its absolute path (`MM_BIN`, or the one in `PATH`), and the current `PATH` in each agent's `env`; an existing file is kept as `config.yaml.<date>.bak`. |
  ## `scripts/package.sh`
  ```text
--scripts/package.sh linux | windows | macos
++scripts/package.sh linux | windows [amd64|arm64] | macos
  scripts/package.sh names <system> <arch>
++scripts/package.sh release-names
  scripts/package.sh version
  ```
  | --- | --- |
  | `linux`, `windows`, `macos` | Builds the packages of that system into `dist/` (see the `package-*` targets), then lists `dist/`. |
  | `names <system> <arch>` | Prints the file names a build produces, one per line; builds nothing. |
++| `release-names` | Prints the files of a release: the names of each target of `RELEASE_TARGETS` (`macos/arm64 windows/amd64 windows/arm64`), then `SHA256SUMS`. Used by `tag-release.sh` and the Release workflow. |
  | `version` | Prints `info.version` of `build/config.yml`. |
  | System | Files (`<v>` = version) |
  | --- | --- |
  | `linux` | `sidekicks_<v>_linux_<arch>.deb`, `.rpm`, `.tar.gz`, `Sidekicks-<v>-<x86_64\|aarch64>.AppImage` |
--| `windows` | `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` |
++| `windows` | `Sidekicks-<v>-windows-<amd64\|arm64>-installer.exe`, `sidekicks_<v>_windows_<amd64\|arm64>.zip` |
  | `macos` | `Sidekicks-<v>-macos-arm64.dmg`, `Sidekicks-<v>-macos-arm64.zip` |
  ## `scripts/build-release.sh`
  ```text
--[LINUX_ARCHES="amd64 arm64"] [SKIP="macos windows linux"] scripts/build-release.sh
++[WINDOWS_ARCHES="amd64 arm64"] [LINUX_ARCHES="amd64"] [SKIP="macos windows"] scripts/build-release.sh
  ```
--Empties `dist/`, then builds: macOS with `scripts/package.sh macos` (macOS only), Windows with `scripts/package.sh windows` (needs `makensis`), Linux with `scripts/package.sh linux` in a container per architecture of `LINUX_ARCHES` (default `amd64`), built from `scripts/linux-packages.Dockerfile` (`ubuntu:26.04`, Go of `go.mod`, pnpm of `frontend/package.json`, Wails CLI) with the repository mounted at `/src` and the Go module cache in the volume `sidekicks-gomod-<arch>`. Finally writes `dist/SHA256SUMS`. `SKIP` leaves the systems it names out. Fails when `makensis` is missing or Docker is not running, naming the system to skip.
++Checks every prerequisite first, then empties `dist/` and builds: macOS with `scripts/package.sh macos` (macOS only), Windows with `scripts/package.sh windows <arch>` for each of `WINDOWS_ARCHES` (default `amd64 arm64`; needs `makensis` and `zip`), and, only when `LINUX_ARCHES` is set (empty by default: no Linux in the releases for now), Linux with `scripts/package.sh linux` in a container per architecture, built from `scripts/linux-packages.Dockerfile` (`ubuntu:26.04`, Go of `go.mod`, pnpm of `frontend/package.json`, Wails CLI) with the repository mounted at `/src` and the Go module cache in the volume `sidekicks-gomod-<arch>`. Finally writes `dist/SHA256SUMS`. `SKIP` leaves the systems it names out. Fails, before building anything, when a prerequisite is missing (macOS host, `makensis`, `zip`, Docker for Linux).
  ## `scripts/tag-release.sh`
  ## Release workflow
--`.github/workflows/release.yml`, on the push of a tag `v*`, with `permissions: contents: write`: fails when the tag is not `v` + `info.version` of `build/config.yml`, then creates the release `<tag>` named `Sidekicks <tag>` (`softprops/action-gh-release@v2`, through Rickub's GitHub-compatible API behind `GITHUB_API_URL`), with notes giving the commit, the install guides and the table of the files to expect (from `scripts/package.sh names`). It attaches no file: the packages are attached by hand.
++`.github/workflows/release.yml`, on the push of a tag `v*`, with `permissions: contents: write`: fails when the tag is not `v` + `info.version` of `build/config.yml`, then creates the release `<tag>` named `Sidekicks <tag>` (`softprops/action-gh-release@v2`, through Rickub's GitHub-compatible API behind `GITHUB_API_URL`), with notes giving the commit, the install guides and the table of the files to expect (from `scripts/package.sh release-names`). It attaches no file: the packages are attached by hand.

modified docs/fr/README.md +1 -1 Viewed

@@ -1,6 +1,6 @@
1	1	# Documentation de Sidekicks (français)
2	2
3		-Sidekicks est une application de bureau pour converser avec des agents d'IA dans des channels, grâce à l'Agent Client Protocol, pensée pour des personnes qui ne sont pas développeuses. La version 0.1 est la première release : des paquets pour macOS, Linux et Windows, un assistant qui ajoute des agents sans écrire de YAML, des messages d'erreur en phrases claires, des raccourcis clavier et une palette de commandes — en plus des channels à plusieurs agents (`@`, `/`, historique gardé d'un lancement à l'autre), du dossier de chaque agent avec un éditeur et un terminal (sur cet ordinateur, dans Docker ou dans une sandbox sbx), des réponses mises en forme et des outils qui demandent votre accord.
	3	+Sidekicks est une application de bureau pour converser avec des agents d'IA dans des channels, grâce à l'Agent Client Protocol, pensée pour des personnes qui ne sont pas développeuses. La version 0.1 est la première release : des paquets pour macOS (Apple Silicon) et Windows (x86-64 et Arm), un assistant qui ajoute des agents sans écrire de YAML, des messages d'erreur en phrases claires, des raccourcis clavier et une palette de commandes — en plus des channels à plusieurs agents (`@`, `/`, historique gardé d'un lancement à l'autre), du dossier de chaque agent avec un éditeur et un terminal (sur cet ordinateur, dans Docker ou dans une sandbox sbx), des réponses mises en forme et des outils qui demandent votre accord.
4	4
5	5	Cette documentation suit la méthode [Diátaxis](https://diataxis.fr) : choisissez la section qui correspond à votre besoin du moment.
6	6

  # Documentation de Sidekicks (français)
--Sidekicks est une application de bureau pour converser avec des agents d'IA dans des channels, grâce à l'Agent Client Protocol, pensée pour des personnes qui ne sont pas développeuses. La version 0.1 est la première release : des paquets pour macOS, Linux et Windows, un assistant qui ajoute des agents sans écrire de YAML, des messages d'erreur en phrases claires, des raccourcis clavier et une palette de commandes — en plus des channels à plusieurs agents (`@`, `/`, historique gardé d'un lancement à l'autre), du dossier de chaque agent avec un éditeur et un terminal (sur cet ordinateur, dans Docker ou dans une sandbox sbx), des réponses mises en forme et des outils qui demandent votre accord.
++Sidekicks est une application de bureau pour converser avec des agents d'IA dans des channels, grâce à l'Agent Client Protocol, pensée pour des personnes qui ne sont pas développeuses. La version 0.1 est la première release : des paquets pour macOS (Apple Silicon) et Windows (x86-64 et Arm), un assistant qui ajoute des agents sans écrire de YAML, des messages d'erreur en phrases claires, des raccourcis clavier et une palette de commandes — en plus des channels à plusieurs agents (`@`, `/`, historique gardé d'un lancement à l'autre), du dossier de chaque agent avec un éditeur et un terminal (sur cet ordinateur, dans Docker ou dans une sandbox sbx), des réponses mises en forme et des outils qui demandent votre accord.
  Cette documentation suit la méthode [Diátaxis](https://diataxis.fr) : choisissez la section qui correspond à votre besoin du moment.

modified docs/fr/how-to/installer-sidekicks.md +15 -16 Viewed

@@ -1,6 +1,6 @@
1	1	# Installer Sidekicks
2	2
3		-Ce guide montre comment installer Sidekicks à partir des paquets d'une release, sous macOS, Linux ou Windows. Les paquets sont sur la page des releases du projet, `https://rickub.com/bots-garden/sidekicks/releases` ; `SHA256SUMS` donne leurs sommes de contrôle.
	3	+Ce guide montre comment installer Sidekicks à partir des paquets d'une release, sous macOS ou Windows (Linux : construit depuis le dépôt). Les paquets sont sur la page des releases du projet, `https://rickub.com/bots-garden/sidekicks/releases` ; `SHA256SUMS` donne leurs sommes de contrôle.
4	4
5	5	Sidekicks discute avec des agents, il n'en contient pas. Installez aussi le programme de votre agent (par exemple `mm`).
6	6
@@ -15,32 +15,31 @@ Sidekicks demande un Mac Apple Silicon (M1 ou plus récent) et macOS 13 (Ventura
15	15
16	16	Ensuite, Sidekicks s'ouvre normalement.
17	17
18		-## Linux (x86-64)
	18	+## Windows (x86-64 et Arm)
19	19
20		-Sidekicks a besoin de GTK 4 et de WebKitGTK 6 (Ubuntu 24.04 ou plus récent, Debian 13, Fedora 40 ou plus récent).
	20	+1. Téléchargez l'installateur de votre processeur et lancez-le : `Sidekicks-<version>-windows-amd64-installer.exe` (Intel et AMD) ou `Sidekicks-<version>-windows-arm64-installer.exe` (Windows sur Arm, par exemple Snapdragon). Paramètres → Système → Informations système → Type du système indique lequel vous avez.
	21	+2. L'installateur n'est pas signé : Windows SmartScreen peut afficher « Windows a protégé votre ordinateur ». Cliquez sur Informations complémentaires, puis Exécuter quand même.
	22	+3. L'installateur ajoute Microsoft Edge WebView2 s'il manque, puis un raccourci Sidekicks.
21	23
22		-- Debian, Ubuntu : `sudo apt install ./sidekicks_<version>_linux_amd64.deb`
23		-- Fedora : `sudo dnf install ./sidekicks_<version>_linux_amd64.rpm`
24		-- Toute distribution, sans installer : `chmod +x Sidekicks-<version>-x86_64.AppImage`, puis lancez-le. S'il se plaint de FUSE, lancez-le avec `--appimage-extract-and-run`.
25		-- Le programme seul : `sidekicks_<version>_linux_amd64.tar.gz` contient `sidekicks` ; les bibliothèques GTK 4 et WebKitGTK 6 doivent être installées.
	24	+`sidekicks_<version>_windows_amd64.zip` et `sidekicks_<version>_windows_arm64.zip` contiennent `sidekicks.exe` seul, pour une machine où WebView2 est déjà présent.
26	25
27		-Le `.deb` et le `.rpm` ajoutent Sidekicks au menu des applications.
	26	+Sous Windows, l'onglet Terminal d'un agent n'est pas encore disponible ; les fichiers, les conversations et les agents dans Docker fonctionnent.
28	27
29		-## Windows (x86-64)
	28	+## Linux
30	29
31		-1. Téléchargez `Sidekicks-<version>-windows-amd64-installer.exe` et lancez-le.
32		-2. L'installateur n'est pas signé : Windows SmartScreen peut afficher « Windows a protégé votre ordinateur ». Cliquez sur Informations complémentaires, puis Exécuter quand même.
33		-3. L'installateur ajoute Microsoft Edge WebView2 s'il manque, puis un raccourci Sidekicks.
	30	+Les releases ne contiennent pas de paquets Linux pour le moment. Construisez-les depuis le dépôt, sous Linux (`make package-linux`) ou sur un Mac avec Docker (`LINUX_ARCHES=amd64 make release-build`), puis :
34	31
35		-`sidekicks_<version>_windows_amd64.zip` contient `sidekicks.exe` seul, pour une machine où WebView2 est déjà présent.
	32	+- Debian, Ubuntu : `sudo apt install ./sidekicks_<version>_linux_amd64.deb`
	33	+- Fedora : `sudo dnf install ./sidekicks_<version>_linux_amd64.rpm`
	34	+- Toute distribution, sans installer : `chmod +x Sidekicks-<version>-x86_64.AppImage`, puis lancez-le. S'il se plaint de FUSE, lancez-le avec `--appimage-extract-and-run`.
36	35
37		-Sous Windows, l'onglet Terminal d'un agent n'est pas encore disponible ; les fichiers, les conversations et les agents dans Docker fonctionnent.
	36	+Sidekicks a besoin de GTK 4 et de WebKitGTK 6 (Ubuntu 24.04 ou plus récent, Debian 13, Fedora 40 ou plus récent).
38	37
39	38	## Variantes
40	39
41		-- Vérifier un téléchargement : `shasum -a 256 <fichier>` (macOS) ou `sha256sum <fichier>` (Linux), à comparer avec `SHA256SUMS`.
	40	+- Vérifier un téléchargement : `shasum -a 256 <fichier>` (macOS) ou `Get-FileHash <fichier>` dans PowerShell (Windows), à comparer avec `SHA256SUMS`.
42	41	- macOS, depuis un terminal : `xattr -dr com.apple.quarantine /Applications/sidekicks.app` lève la quarantaine, à la place de l'étape 4.
43		-- Le construire soi-même : `make package-macos`, `make package-linux` ou `make package-windows` (voir [Publier une release](publier-une-release.md)).
	42	+- Le construire soi-même : `make package-macos` ou `make package-windows` (voir [Publier une release](publier-une-release.md)).
44	43
45	44	## Voir aussi
46	45

  # Installer Sidekicks
--Ce guide montre comment installer Sidekicks à partir des paquets d'une release, sous macOS, Linux ou Windows. Les paquets sont sur la page des releases du projet, `https://rickub.com/bots-garden/sidekicks/releases` ; `SHA256SUMS` donne leurs sommes de contrôle.
++Ce guide montre comment installer Sidekicks à partir des paquets d'une release, sous macOS ou Windows (Linux : construit depuis le dépôt). Les paquets sont sur la page des releases du projet, `https://rickub.com/bots-garden/sidekicks/releases` ; `SHA256SUMS` donne leurs sommes de contrôle.
  Sidekicks discute avec des agents, il n'en contient pas. Installez aussi le programme de votre agent (par exemple `mm`).
  Ensuite, Sidekicks s'ouvre normalement.
--## Linux (x86-64)
++## Windows (x86-64 et Arm)
--Sidekicks a besoin de GTK 4 et de WebKitGTK 6 (Ubuntu 24.04 ou plus récent, Debian 13, Fedora 40 ou plus récent).
++1. Téléchargez l'installateur de votre processeur et lancez-le : `Sidekicks-<version>-windows-amd64-installer.exe` (Intel et AMD) ou `Sidekicks-<version>-windows-arm64-installer.exe` (Windows sur Arm, par exemple Snapdragon). **Paramètres → Système → Informations système → Type du système** indique lequel vous avez.
++2. L'installateur n'est pas signé : Windows SmartScreen peut afficher « Windows a protégé votre ordinateur ». Cliquez sur **Informations complémentaires**, puis **Exécuter quand même**.
++3. L'installateur ajoute Microsoft Edge WebView2 s'il manque, puis un raccourci Sidekicks.
--- **Debian, Ubuntu** : `sudo apt install ./sidekicks_<version>_linux_amd64.deb`
++`sidekicks_<version>_windows_amd64.zip` et `sidekicks_<version>_windows_arm64.zip` contiennent `sidekicks.exe` seul, pour une machine où WebView2 est déjà présent.
--- **Fedora** : `sudo dnf install ./sidekicks_<version>_linux_amd64.rpm`
--- **Toute distribution, sans installer** : `chmod +x Sidekicks-<version>-x86_64.AppImage`, puis lancez-le. S'il se plaint de FUSE, lancez-le avec `--appimage-extract-and-run`.
--- **Le programme seul** : `sidekicks_<version>_linux_amd64.tar.gz` contient `sidekicks` ; les bibliothèques GTK 4 et WebKitGTK 6 doivent être installées.
--Le `.deb` et le `.rpm` ajoutent Sidekicks au menu des applications.
++Sous Windows, l'onglet **Terminal** d'un agent n'est pas encore disponible ; les fichiers, les conversations et les agents dans Docker fonctionnent.
--## Windows (x86-64)
++## Linux
--1. Téléchargez `Sidekicks-<version>-windows-amd64-installer.exe` et lancez-le.
++Les releases ne contiennent pas de paquets Linux pour le moment. Construisez-les depuis le dépôt, sous Linux (`make package-linux`) ou sur un Mac avec Docker (`LINUX_ARCHES=amd64 make release-build`), puis :
--2. L'installateur n'est pas signé : Windows SmartScreen peut afficher « Windows a protégé votre ordinateur ». Cliquez sur **Informations complémentaires**, puis **Exécuter quand même**.
--3. L'installateur ajoute Microsoft Edge WebView2 s'il manque, puis un raccourci Sidekicks.
--`sidekicks_<version>_windows_amd64.zip` contient `sidekicks.exe` seul, pour une machine où WebView2 est déjà présent.
++- **Debian, Ubuntu** : `sudo apt install ./sidekicks_<version>_linux_amd64.deb`
++- **Fedora** : `sudo dnf install ./sidekicks_<version>_linux_amd64.rpm`
++- **Toute distribution, sans installer** : `chmod +x Sidekicks-<version>-x86_64.AppImage`, puis lancez-le. S'il se plaint de FUSE, lancez-le avec `--appimage-extract-and-run`.
--Sous Windows, l'onglet **Terminal** d'un agent n'est pas encore disponible ; les fichiers, les conversations et les agents dans Docker fonctionnent.
++Sidekicks a besoin de GTK 4 et de WebKitGTK 6 (Ubuntu 24.04 ou plus récent, Debian 13, Fedora 40 ou plus récent).
  ## Variantes
--- **Vérifier un téléchargement** : `shasum -a 256 <fichier>` (macOS) ou `sha256sum <fichier>` (Linux), à comparer avec `SHA256SUMS`.
++- **Vérifier un téléchargement** : `shasum -a 256 <fichier>` (macOS) ou `Get-FileHash <fichier>` dans PowerShell (Windows), à comparer avec `SHA256SUMS`.
  - **macOS, depuis un terminal** : `xattr -dr com.apple.quarantine /Applications/sidekicks.app` lève la quarantaine, à la place de l'étape 4.
--- **Le construire soi-même** : `make package-macos`, `make package-linux` ou `make package-windows` (voir [Publier une release](publier-une-release.md)).
++- **Le construire soi-même** : `make package-macos` ou `make package-windows` (voir [Publier une release](publier-une-release.md)).
  ## Voir aussi

modified docs/fr/how-to/publier-une-release.md +5 -5 Viewed

@@ -1,21 +1,21 @@
1	1	# Publier une release
2	2
3		-Ce guide montre comment publier une release de Sidekicks depuis un Mac : construire tous les paquets, tagger, attacher les fichiers à la release que Rickub crée. Il suppose les outils de [Développer l'application](developper-l-application.md), Docker Desktop démarré, `brew install makensis zip`, et le droit de pousser des tags. [RELEASING.fr.md](../../../RELEASING.fr.md) donne la même procédure en liste de contrôle.
	3	+Ce guide montre comment publier une release de Sidekicks depuis un Mac : construire tous les paquets, tagger, attacher les fichiers à la release que Rickub crée. Il suppose les outils de [Développer l'application](developper-l-application.md), `brew install makensis`, et le droit de pousser des tags. [RELEASING.fr.md](../../../RELEASING.fr.md) donne la même procédure en liste de contrôle.
4	4
5	5	## Étapes
6	6
7	7	1. Fixez la version dans `build/config.yml` (`info.version`), lancez `wails3 task common:update:build-assets`, remettez `LSMinimumSystemVersion` à `13.0.0` dans `build/darwin/Info.plist` et `Info.dev.plist`, puis commitez, fusionnez dans `main` et `git checkout main && git pull`.
8		-2. Construisez tout : `make release-build`. `dist/` contient alors les paquets macOS (`.dmg` et `.zip` pour Apple Silicon), Windows (installateur et `.zip`), Linux amd64 (`.deb`, `.rpm`, `.AppImage`, `.tar.gz`, construits dans Docker) et `SHA256SUMS`.
	8	+2. Construisez tout : `make release-build`. `dist/` contient alors les paquets macOS (`.dmg` et `.zip` pour Apple Silicon), Windows (installateur et `.zip`, pour x86-64 et pour Arm) et `SHA256SUMS`.
9	9	3. Taggez : `make release-tag`. Le tag `v<version>` est poussé, et le workflow Release crée la release sur Rickub avec des notes qui listent les fichiers.
10	10	4. Attachez les fichiers : sur Rickub, ouvrez Releases → v<version> et attachez tous les fichiers de `dist/`.
11	11
12	12	## Variantes
13	13
14		-- Linux arm64 aussi : `LINUX_ARCHES="amd64 arm64" make release-build`.
15		-- Laisser un système de côté : `SKIP="linux"` (ou `macos`, `windows`, plusieurs séparés par des espaces) avant `make release-build`.
	14	+- Les paquets Linux aussi (pas publiés pour le moment) : `LINUX_ARCHES=amd64 make release-build`, avec Docker Desktop démarré.
	15	+- Laisser un système de côté : `SKIP="windows"` (ou `macos`) avant `make release-build` ; `WINDOWS_ARCHES=amd64` pour une seule architecture Windows.
16	16	- Tagger sans pousser : `scripts/tag-release.sh --no-push`, puis `git push origin v<version>` le moment venu.
17	17	- Mauvais tag : `git push origin :refs/tags/v<version>` et `git tag -d v<version>`, supprimez la release si elle a été créée, corrigez la version et taggez à nouveau.
18		-- Un seul paquet : `make package-macos`, `make package-windows` ou `make package-linux` (Linux seulement, pour l'architecture de la machine).
	18	+- Un seul système : `make package-macos`, `make package-windows` (les deux architectures) ou `make package-linux` (sous Linux, pour l'architecture de la machine).
19	19
20	20	## Voir aussi
21	21

  # Publier une release
--Ce guide montre comment publier une release de Sidekicks depuis un Mac : construire tous les paquets, tagger, attacher les fichiers à la release que Rickub crée. Il suppose les outils de [Développer l'application](developper-l-application.md), Docker Desktop démarré, `brew install makensis zip`, et le droit de pousser des tags. [RELEASING.fr.md](../../../RELEASING.fr.md) donne la même procédure en liste de contrôle.
++Ce guide montre comment publier une release de Sidekicks depuis un Mac : construire tous les paquets, tagger, attacher les fichiers à la release que Rickub crée. Il suppose les outils de [Développer l'application](developper-l-application.md), `brew install makensis`, et le droit de pousser des tags. [RELEASING.fr.md](../../../RELEASING.fr.md) donne la même procédure en liste de contrôle.
  ## Étapes
 . **Fixez la version** dans `build/config.yml` (`info.version`), lancez `wails3 task common:update:build-assets`, remettez `LSMinimumSystemVersion` à `13.0.0` dans `build/darwin/Info.plist` et `Info.dev.plist`, puis commitez, fusionnez dans `main` et `git checkout main && git pull`.
--2. **Construisez tout** : `make release-build`. `dist/` contient alors les paquets macOS (`.dmg` et `.zip` pour Apple Silicon), Windows (installateur et `.zip`), Linux amd64 (`.deb`, `.rpm`, `.AppImage`, `.tar.gz`, construits dans Docker) et `SHA256SUMS`.
++2. **Construisez tout** : `make release-build`. `dist/` contient alors les paquets macOS (`.dmg` et `.zip` pour Apple Silicon), Windows (installateur et `.zip`, pour x86-64 et pour Arm) et `SHA256SUMS`.
 . **Taggez** : `make release-tag`. Le tag `v<version>` est poussé, et le workflow **Release** crée la release sur Rickub avec des notes qui listent les fichiers.
 . **Attachez les fichiers** : sur Rickub, ouvrez **Releases → v<version>** et attachez tous les fichiers de `dist/`.
  ## Variantes
--- **Linux arm64 aussi** : `LINUX_ARCHES="amd64 arm64" make release-build`.
++- **Les paquets Linux aussi** (pas publiés pour le moment) : `LINUX_ARCHES=amd64 make release-build`, avec Docker Desktop démarré.
--- **Laisser un système de côté** : `SKIP="linux"` (ou `macos`, `windows`, plusieurs séparés par des espaces) avant `make release-build`.
++- **Laisser un système de côté** : `SKIP="windows"` (ou `macos`) avant `make release-build` ; `WINDOWS_ARCHES=amd64` pour une seule architecture Windows.
  - **Tagger sans pousser** : `scripts/tag-release.sh --no-push`, puis `git push origin v<version>` le moment venu.
  - **Mauvais tag** : `git push origin :refs/tags/v<version>` et `git tag -d v<version>`, supprimez la release si elle a été créée, corrigez la version et taggez à nouveau.
--- **Un seul paquet** : `make package-macos`, `make package-windows` ou `make package-linux` (Linux seulement, pour l'architecture de la machine).
++- **Un seul système** : `make package-macos`, `make package-windows` (les deux architectures) ou `make package-linux` (sous Linux, pour l'architecture de la machine).
  ## Voir aussi

modified docs/fr/reference/commandes.md +9 -7 Viewed

@@ -26,8 +26,8 @@ L'ordre est détaillé dans la [référence de la configuration](configuration.m
26	26	\| `build` \| `wails3 build` : `bin/sidekicks`. \|
27	27	\| `package` \| `wails3 package` : sous macOS `bin/sidekicks.app`. \|
28	28	\| `package-linux` \| `scripts/package.sh linux` : `.deb`, `.rpm`, `.AppImage` et `.tar.gz` pour l'architecture de la machine, dans `dist/`. Demande `file` (AppImage) et `rpm`. \|
29		-\| `package-windows` \| `scripts/package.sh windows` : installateur NSIS et `.zip` pour Windows amd64, compilés depuis Linux ou macOS, dans `dist/`. Demande `makensis` et `zip`. \|
30		-\| `release-build` \| `scripts/build-release.sh` : sur le Mac, tous les paquets de release dans `dist/` et `SHA256SUMS`. \|
	29	+\| `package-windows` \| `scripts/package.sh windows amd64` puis `arm64` : installateur NSIS et `.zip` pour chacun, compilés depuis Linux ou macOS, dans `dist/`. Demande `makensis` et `zip`. \|
	30	+\| `release-build` \| `scripts/build-release.sh` : sur le Mac, tous les paquets de release (macOS arm64, Windows amd64 et arm64) dans `dist/` et `SHA256SUMS`. \|
31	31	\| `release-tag` \| `scripts/tag-release.sh` : tague `v<version>` sur `main` et le pousse. \|
32	32	\| `package-macos` \| `scripts/package.sh macos` : `.dmg` et `.zip` pour Apple Silicon (arm64, signés ad hoc ; pas de build Intel), dans `dist/`. macOS seulement. \|
33	33	\| `install-test-config` \| `scripts/install-test-config.sh` : écrit `examples/test-agents.yaml` à l'emplacement par défaut de la configuration, avec des chemins absolus vers le dépôt : chaque agent est `mm -acp -config agent.yaml` lancé dans son dossier, avec `afterStop: [<dépôt>/scripts/agents.sh, unload, <agent>]` pour décharger son modèle à l'arrêt, `mm` écrit avec son chemin absolu (`MM_BIN`, ou celui du `PATH`), et le `PATH` courant dans l'`env` de chaque agent ; un fichier existant est gardé sous `config.yaml.<date>.bak`. \|
@@ -56,8 +56,9 @@ Liste les fichiers sources (`.go .ts .js .svelte .css .html .sh .py .yml .yaml`,
56	56	## `scripts/package.sh`
57	57
58	58	```text
59		-scripts/package.sh linux \| windows \| macos
	59	+scripts/package.sh linux \| windows [amd64\|arm64] \| macos
60	60	scripts/package.sh names <système> <arch>
	61	+scripts/package.sh release-names
61	62	scripts/package.sh version
62	63	```
63	64
@@ -65,21 +66,22 @@ scripts/package.sh version
65	66	\| --- \| --- \|
66	67	\| `linux`, `windows`, `macos` \| Construit les paquets de ce système dans `dist/` (voir les cibles `package-*`), puis liste `dist/`. \|
67	68	\| `names <système> <arch>` \| Affiche les noms des fichiers qu'un build produit, un par ligne ; ne construit rien. \|
	69	+\| `release-names` \| Affiche les fichiers d'une release : les noms de chaque cible de `RELEASE_TARGETS` (`macos/arm64 windows/amd64 windows/arm64`), puis `SHA256SUMS`. Utilisé par `tag-release.sh` et le workflow Release. \|
68	70	\| `version` \| Affiche `info.version` de `build/config.yml`. \|
69	71
70	72	\| Système \| Fichiers (`<v>` = version) \|
71	73	\| --- \| --- \|
72	74	\| `linux` \| `sidekicks_<v>_linux_<arch>.deb`, `.rpm`, `.tar.gz`, `Sidekicks-<v>-<x86_64\\|aarch64>.AppImage` \|
73		-\| `windows` \| `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` \|
	75	+\| `windows` \| `Sidekicks-<v>-windows-<amd64\\|arm64>-installer.exe`, `sidekicks_<v>_windows_<amd64\\|arm64>.zip` \|
74	76	\| `macos` \| `Sidekicks-<v>-macos-arm64.dmg`, `Sidekicks-<v>-macos-arm64.zip` \|
75	77
76	78	## `scripts/build-release.sh`
77	79
78	80	```text
79		-[LINUX_ARCHES="amd64 arm64"] [SKIP="macos windows linux"] scripts/build-release.sh
	81	+[WINDOWS_ARCHES="amd64 arm64"] [LINUX_ARCHES="amd64"] [SKIP="macos windows"] scripts/build-release.sh
80	82	```
81	83
82		-Vide `dist/`, puis construit : macOS avec `scripts/package.sh macos` (macOS seulement), Windows avec `scripts/package.sh windows` (demande `makensis`), Linux avec `scripts/package.sh linux` dans un conteneur par architecture de `LINUX_ARCHES` (par défaut `amd64`), construit depuis `scripts/linux-packages.Dockerfile` (`ubuntu:26.04`, Go de `go.mod`, pnpm de `frontend/package.json`, CLI Wails) avec le dépôt monté sur `/src` et le cache des modules Go dans le volume `sidekicks-gomod-<arch>`. Écrit enfin `dist/SHA256SUMS`. `SKIP` laisse de côté les systèmes qu'il nomme. Échoue si `makensis` manque ou si Docker ne tourne pas, en nommant le système à laisser de côté.
	84	+Vérifie d'abord tous les prérequis, puis vide `dist/` et construit : macOS avec `scripts/package.sh macos` (macOS seulement), Windows avec `scripts/package.sh windows <arch>` pour chaque architecture de `WINDOWS_ARCHES` (par défaut `amd64 arm64` ; demande `makensis` et `zip`), et, seulement si `LINUX_ARCHES` est défini (vide par défaut : pas de Linux dans les releases pour le moment), Linux avec `scripts/package.sh linux` dans un conteneur par architecture, construit depuis `scripts/linux-packages.Dockerfile` (`ubuntu:26.04`, Go de `go.mod`, pnpm de `frontend/package.json`, CLI Wails) avec le dépôt monté sur `/src` et le cache des modules Go dans le volume `sidekicks-gomod-<arch>`. Écrit enfin `dist/SHA256SUMS`. `SKIP` laisse de côté les systèmes qu'il nomme. Échoue, avant de rien construire, si un prérequis manque (hôte macOS, `makensis`, `zip`, Docker pour Linux).
83	85
84	86	## `scripts/tag-release.sh`
85	87
@@ -91,4 +93,4 @@ Crée le tag annoté `v<version>` (`info.version` de `build/config.yml`, message
91	93
92	94	## Workflow de release
93	95
94		-`.github/workflows/release.yml`, au push d'un tag `v*`, avec `permissions: contents: write` : échoue si le tag n'est pas `v` + `info.version` de `build/config.yml`, puis crée la release `<tag>` nommée `Sidekicks <tag>` (`softprops/action-gh-release@v2`, via l'API compatible GitHub de Rickub derrière `GITHUB_API_URL`), avec des notes qui donnent le commit, les guides d'installation et le tableau des fichiers attendus (tirés de `scripts/package.sh names`). Il n'attache aucun fichier : les paquets sont attachés à la main.
	96	+`.github/workflows/release.yml`, au push d'un tag `v*`, avec `permissions: contents: write` : échoue si le tag n'est pas `v` + `info.version` de `build/config.yml`, puis crée la release `<tag>` nommée `Sidekicks <tag>` (`softprops/action-gh-release@v2`, via l'API compatible GitHub de Rickub derrière `GITHUB_API_URL`), avec des notes qui donnent le commit, les guides d'installation et le tableau des fichiers attendus (tirés de `scripts/package.sh release-names`). Il n'attache aucun fichier : les paquets sont attachés à la main.

  | `build` | `wails3 build` : `bin/sidekicks`. |
  | `package` | `wails3 package` : sous macOS `bin/sidekicks.app`. |
  | `package-linux` | `scripts/package.sh linux` : `.deb`, `.rpm`, `.AppImage` et `.tar.gz` pour l'architecture de la machine, dans `dist/`. Demande `file` (AppImage) et `rpm`. |
--| `package-windows` | `scripts/package.sh windows` : installateur NSIS et `.zip` pour Windows amd64, compilés depuis Linux ou macOS, dans `dist/`. Demande `makensis` et `zip`. |
++| `package-windows` | `scripts/package.sh windows amd64` puis `arm64` : installateur NSIS et `.zip` pour chacun, compilés depuis Linux ou macOS, dans `dist/`. Demande `makensis` et `zip`. |
--| `release-build` | `scripts/build-release.sh` : sur le Mac, tous les paquets de release dans `dist/` et `SHA256SUMS`. |
++| `release-build` | `scripts/build-release.sh` : sur le Mac, tous les paquets de release (macOS arm64, Windows amd64 et arm64) dans `dist/` et `SHA256SUMS`. |
  | `release-tag` | `scripts/tag-release.sh` : tague `v<version>` sur `main` et le pousse. |
  | `package-macos` | `scripts/package.sh macos` : `.dmg` et `.zip` pour Apple Silicon (arm64, signés ad hoc ; pas de build Intel), dans `dist/`. macOS seulement. |
  | `install-test-config` | `scripts/install-test-config.sh` : écrit `examples/test-agents.yaml` à l'emplacement par défaut de la configuration, avec des chemins absolus vers le dépôt : chaque agent est `mm -acp -config agent.yaml` lancé dans son dossier, avec `afterStop: [<dépôt>/scripts/agents.sh, unload, <agent>]` pour décharger son modèle à l'arrêt, `mm` écrit avec son chemin absolu (`MM_BIN`, ou celui du `PATH`), et le `PATH` courant dans l'`env` de chaque agent ; un fichier existant est gardé sous `config.yaml.<date>.bak`. |
  ## `scripts/package.sh`
  ```text
--scripts/package.sh linux | windows | macos
++scripts/package.sh linux | windows [amd64|arm64] | macos
  scripts/package.sh names <système> <arch>
++scripts/package.sh release-names
  scripts/package.sh version
  ```
  | --- | --- |
  | `linux`, `windows`, `macos` | Construit les paquets de ce système dans `dist/` (voir les cibles `package-*`), puis liste `dist/`. |
  | `names <système> <arch>` | Affiche les noms des fichiers qu'un build produit, un par ligne ; ne construit rien. |
++| `release-names` | Affiche les fichiers d'une release : les noms de chaque cible de `RELEASE_TARGETS` (`macos/arm64 windows/amd64 windows/arm64`), puis `SHA256SUMS`. Utilisé par `tag-release.sh` et le workflow Release. |
  | `version` | Affiche `info.version` de `build/config.yml`. |
  | Système | Fichiers (`<v>` = version) |
  | --- | --- |
  | `linux` | `sidekicks_<v>_linux_<arch>.deb`, `.rpm`, `.tar.gz`, `Sidekicks-<v>-<x86_64\|aarch64>.AppImage` |
--| `windows` | `Sidekicks-<v>-windows-amd64-installer.exe`, `sidekicks_<v>_windows_amd64.zip` |
++| `windows` | `Sidekicks-<v>-windows-<amd64\|arm64>-installer.exe`, `sidekicks_<v>_windows_<amd64\|arm64>.zip` |
  | `macos` | `Sidekicks-<v>-macos-arm64.dmg`, `Sidekicks-<v>-macos-arm64.zip` |
  ## `scripts/build-release.sh`
  ```text
--[LINUX_ARCHES="amd64 arm64"] [SKIP="macos windows linux"] scripts/build-release.sh
++[WINDOWS_ARCHES="amd64 arm64"] [LINUX_ARCHES="amd64"] [SKIP="macos windows"] scripts/build-release.sh
  ```
--Vide `dist/`, puis construit : macOS avec `scripts/package.sh macos` (macOS seulement), Windows avec `scripts/package.sh windows` (demande `makensis`), Linux avec `scripts/package.sh linux` dans un conteneur par architecture de `LINUX_ARCHES` (par défaut `amd64`), construit depuis `scripts/linux-packages.Dockerfile` (`ubuntu:26.04`, Go de `go.mod`, pnpm de `frontend/package.json`, CLI Wails) avec le dépôt monté sur `/src` et le cache des modules Go dans le volume `sidekicks-gomod-<arch>`. Écrit enfin `dist/SHA256SUMS`. `SKIP` laisse de côté les systèmes qu'il nomme. Échoue si `makensis` manque ou si Docker ne tourne pas, en nommant le système à laisser de côté.
++Vérifie d'abord tous les prérequis, puis vide `dist/` et construit : macOS avec `scripts/package.sh macos` (macOS seulement), Windows avec `scripts/package.sh windows <arch>` pour chaque architecture de `WINDOWS_ARCHES` (par défaut `amd64 arm64` ; demande `makensis` et `zip`), et, seulement si `LINUX_ARCHES` est défini (vide par défaut : pas de Linux dans les releases pour le moment), Linux avec `scripts/package.sh linux` dans un conteneur par architecture, construit depuis `scripts/linux-packages.Dockerfile` (`ubuntu:26.04`, Go de `go.mod`, pnpm de `frontend/package.json`, CLI Wails) avec le dépôt monté sur `/src` et le cache des modules Go dans le volume `sidekicks-gomod-<arch>`. Écrit enfin `dist/SHA256SUMS`. `SKIP` laisse de côté les systèmes qu'il nomme. Échoue, avant de rien construire, si un prérequis manque (hôte macOS, `makensis`, `zip`, Docker pour Linux).
  ## `scripts/tag-release.sh`
  ## Workflow de release
--`.github/workflows/release.yml`, au push d'un tag `v*`, avec `permissions: contents: write` : échoue si le tag n'est pas `v` + `info.version` de `build/config.yml`, puis crée la release `<tag>` nommée `Sidekicks <tag>` (`softprops/action-gh-release@v2`, via l'API compatible GitHub de Rickub derrière `GITHUB_API_URL`), avec des notes qui donnent le commit, les guides d'installation et le tableau des fichiers attendus (tirés de `scripts/package.sh names`). Il n'attache aucun fichier : les paquets sont attachés à la main.
++`.github/workflows/release.yml`, au push d'un tag `v*`, avec `permissions: contents: write` : échoue si le tag n'est pas `v` + `info.version` de `build/config.yml`, puis crée la release `<tag>` nommée `Sidekicks <tag>` (`softprops/action-gh-release@v2`, via l'API compatible GitHub de Rickub derrière `GITHUB_API_URL`), avec des notes qui donnent le commit, les guides d'installation et le tableau des fichiers attendus (tirés de `scripts/package.sh release-names`). Il n'attache aucun fichier : les paquets sont attachés à la main.

modified scripts/build-release.sh +27 -13 Viewed

@@ -5,19 +5,20 @@
5	5	# writes dist/SHA256SUMS. The files are then attached by hand to the release
6	6	# that scripts/tag-release.sh starts (see RELEASING.md).
7	7	#
8		-# scripts/build-release.sh # macOS arm64, Windows amd64, Linux amd64
9		-# LINUX_ARCHES="amd64 arm64" scripts/build-release.sh
10		-# SKIP="linux" scripts/build-release.sh # skip systems (macos, windows, linux)
	8	+# scripts/build-release.sh # macOS arm64, Windows amd64 and arm64
	9	+# LINUX_ARCHES="amd64" scripts/build-release.sh # Linux packages too (not released for now)
	10	+# SKIP="windows" scripts/build-release.sh # skip systems (macos, windows)
11	11	#
12	12	# macOS: native (Xcode command line tools). Windows: cross-built (needs
13		-# makensis and zip: brew install makensis zip). Linux: in a Docker container
14		-# (scripts/linux-packages.Dockerfile, needs Docker running); another
15		-# architecture than the Mac's is emulated, hence slower.
	13	+# makensis and zip: brew install makensis zip). Linux, only with
	14	+# LINUX_ARCHES: in a Docker container (scripts/linux-packages.Dockerfile,
	15	+# needs Docker running); another architecture than the Mac's is emulated.
16	16	set -euo pipefail
17	17
18	18	root="$(cd "$(dirname "$0")/.." && pwd)"
19	19	dist="$root/dist"
20		-linux_arches="${LINUX_ARCHES:-amd64}"
	20	+linux_arches="${LINUX_ARCHES:-}"
	21	+windows_arches="${WINDOWS_ARCHES:-amd64 arm64}"
21	22	skip=" ${SKIP:-} "
22	23
23	24	die() { echo "build-release.sh: $*" >&2; exit 1; }
@@ -26,23 +27,36 @@ skipped() { [[ "$skip" == " $1 " ]]; }
26	27
27	28	cd "$root"
28	29	version="$(scripts/package.sh version)"
	30	+
	31	+# Every prerequisite is checked before anything is built, so that a missing
	32	+# tool does not stop the build halfway.
	33	+if ! skipped macos; then
	34	+ [ "$(uname -s)" = Darwin ] \|\| die "the macOS packages are built on macOS (or SKIP=macos)"
	35	+fi
	36	+if ! skipped windows; then
	37	+ command -v makensis >/dev/null \|\| die "makensis is missing: brew install makensis (or SKIP=windows)"
	38	+ command -v zip >/dev/null \|\| die "zip is missing: brew install zip (or SKIP=windows)"
	39	+fi
	40	+if [ -n "$linux_arches" ]; then
	41	+ command -v docker >/dev/null && docker info >/dev/null 2>&1 \|\| die "Docker is not running (or no LINUX_ARCHES)"
	42	+fi
	43	+
29	44	step "Sidekicks $version"
30	45	rm -rf "$dist"
31	46
32	47	if ! skipped macos; then
33		- [ "$(uname -s)" = Darwin ] \|\| die "the macOS packages are built on macOS (or SKIP=macos)"
34	48	step "macOS (arm64)"
35	49	scripts/package.sh macos
36	50	fi
37	51
38	52	if ! skipped windows; then
39		- command -v makensis >/dev/null \|\| die "makensis is missing: brew install makensis (or SKIP=windows)"
40		- step "Windows (amd64)"
41		- scripts/package.sh windows
	53	+ for arch in $windows_arches; do
	54	+ step "Windows ($arch)"
	55	+ scripts/package.sh windows "$arch"
	56	+ done
42	57	fi
43	58
44		-if ! skipped linux; then
45		- command -v docker >/dev/null && docker info >/dev/null 2>&1 \|\| die "Docker is not running (or SKIP=linux)"
	59	+if [ -n "$linux_arches" ]; then
46	60	go_version="$(awk '/^go /{print $2}' go.mod)"
47	61	pnpm="$(node -p "require('./frontend/package.json').packageManager")"
48	62	for arch in $linux_arches; do

  # writes dist/SHA256SUMS. The files are then attached by hand to the release
  # that scripts/tag-release.sh starts (see RELEASING.md).
  #
--#   scripts/build-release.sh                        # macOS arm64, Windows amd64, Linux amd64
++#   scripts/build-release.sh                        # macOS arm64, Windows amd64 and arm64
--#   LINUX_ARCHES="amd64 arm64" scripts/build-release.sh
++#   LINUX_ARCHES="amd64" scripts/build-release.sh   # Linux packages too (not released for now)
--#   SKIP="linux" scripts/build-release.sh           # skip systems (macos, windows, linux)
++#   SKIP="windows" scripts/build-release.sh         # skip systems (macos, windows)
  #
  # macOS: native (Xcode command line tools). Windows: cross-built (needs
--# makensis and zip: brew install makensis zip). Linux: in a Docker container
++# makensis and zip: brew install makensis zip). Linux, only with
--# (scripts/linux-packages.Dockerfile, needs Docker running); another
++# LINUX_ARCHES: in a Docker container (scripts/linux-packages.Dockerfile,
--# architecture than the Mac's is emulated, hence slower.
++# needs Docker running); another architecture than the Mac's is emulated.
  set -euo pipefail
  root="$(cd "$(dirname "$0")/.." && pwd)"
  dist="$root/dist"
--linux_arches="${LINUX_ARCHES:-amd64}"
++linux_arches="${LINUX_ARCHES:-}"
++windows_arches="${WINDOWS_ARCHES:-amd64 arm64}"
  skip=" ${SKIP:-} "
  die() { echo "build-release.sh: $*" >&2; exit 1; }
  cd "$root"
  version="$(scripts/package.sh version)"
++
++# Every prerequisite is checked before anything is built, so that a missing
++# tool does not stop the build halfway.
++if ! skipped macos; then
++    [ "$(uname -s)" = Darwin ] || die "the macOS packages are built on macOS (or SKIP=macos)"
++fi
++if ! skipped windows; then
++    command -v makensis >/dev/null || die "makensis is missing: brew install makensis (or SKIP=windows)"
++    command -v zip >/dev/null || die "zip is missing: brew install zip (or SKIP=windows)"
++fi
++if [ -n "$linux_arches" ]; then
++    command -v docker >/dev/null && docker info >/dev/null 2>&1 || die "Docker is not running (or no LINUX_ARCHES)"
++fi
++
  step "Sidekicks $version"
  rm -rf "$dist"
  if ! skipped macos; then
--    [ "$(uname -s)" = Darwin ] || die "the macOS packages are built on macOS (or SKIP=macos)"
      step "macOS (arm64)"
      scripts/package.sh macos
  fi
  if ! skipped windows; then
--    command -v makensis >/dev/null || die "makensis is missing: brew install makensis (or SKIP=windows)"
++    for arch in $windows_arches; do
--    step "Windows (amd64)"
++        step "Windows ($arch)"
--    scripts/package.sh windows
++        scripts/package.sh windows "$arch"
++    done
  fi
--if ! skipped linux; then
++if [ -n "$linux_arches" ]; then
--    command -v docker >/dev/null && docker info >/dev/null 2>&1 || die "Docker is not running (or SKIP=linux)"
      go_version="$(awk '/^go /{print $2}' go.mod)"
      pnpm="$(node -p "require('./frontend/package.json').packageManager")"
      for arch in $linux_arches; do

modified scripts/package.sh +23 -7 Viewed

@@ -5,9 +5,10 @@
5	5	# of build/config.yml, the system and the architecture.
6	6	#
7	7	# scripts/package.sh linux # .deb, .rpm, .AppImage and .tar.gz for this machine's architecture
8		-# scripts/package.sh windows # installer (NSIS) and .zip for Windows amd64, cross-built from Linux or macOS
	8	+# scripts/package.sh windows [amd64\|arm64] # installer (NSIS) and .zip for Windows (default amd64), cross-built from Linux or macOS
9	9	# scripts/package.sh macos # .dmg and .zip of the .app for Apple Silicon (arm64), on macOS only
10	10	# scripts/package.sh names linux arm64 # prints the file names, builds nothing
	11	+# scripts/package.sh release-names # the files of a release (RELEASE_TARGETS), SHA256SUMS last
11	12	#
12	13	# Linux needs GTK 4 and WebKitGTK 6 dev packages, plus file (AppImage) and
13	14	# rpm; Windows needs makensis (nsis); macOS needs the Xcode command line tools.
@@ -49,6 +50,17 @@ names() {
49	50	esac
50	51	}
51	52
	53	+# What a release holds, as <system>/<arch>: the targets scripts/build-release.sh
	54	+# builds and scripts/tag-release.sh expects in dist/. For now: macOS on Apple
	55	+# Silicon and Windows; Linux is built on demand (LINUX_ARCHES).
	56	+RELEASE_TARGETS="macos/arm64 windows/amd64 windows/arm64"
	57	+
	58	+release_names() {
	59	+ local target
	60	+ for target in $RELEASE_TARGETS; do names "${target%/}" "${target#/}"; done
	61	+ echo SHA256SUMS
	62	+}
	63	+
52	64	# The n-th name (1-based) of names.
53	65	name() { names "$1" "$2" \| sed -n "${3}p"; }
54	66
@@ -75,10 +87,13 @@ package_linux() {
75	87	}
76	88
77	89	package_windows() {
78		- wails windows:create:nsis:installer ARCH=amd64
	90	+ local arch="$1"
	91	+ case "$arch" in amd64 \| arm64) ;; *) die "Windows packages are amd64 or arm64, not $arch" ;; esac
	92	+ rm -f "$root/bin/sidekicks.exe"
	93	+ wails windows:create:nsis:installer ARCH="$arch"
79	94	mkdir -p "$dist"
80		- mv "$root/bin/sidekicks-amd64-installer.exe" "$dist/$(name windows amd64 1)"
81		- (cd "$root/bin" && zip -q -j "$dist/$(name windows amd64 2)" sidekicks.exe)
	95	+ mv "$root/bin/sidekicks-$arch-installer.exe" "$dist/$(name windows "$arch" 1)"
	96	+ (cd "$root/bin" && zip -q -j "$dist/$(name windows "$arch" 2)" sidekicks.exe)
82	97	}
83	98
84	99	package_macos() {
@@ -94,10 +109,11 @@ package_macos() {
94	109
95	110	case "${1:-}" in
96	111	linux) package_linux ;;
97		- windows) package_windows ;;
	112	+ windows) package_windows "${2:-amd64}" ;;
98	113	macos) package_macos ;;
99	114	names) names "${2:?system}" "${3:?arch}" ;;
100	115	version) version ;;
101		- *) die "usage: package.sh linux\|windows\|macos\|names <system> <arch>\|version" ;;
	116	+ release-names) release_names ;;
	117	+ *) die "usage: package.sh linux\|windows [amd64\|arm64]\|macos\|names <system> <arch>\|release-names\|version" ;;
102	118	esac
103		-[ "${1:-}" = names ] \|\| [ "${1:-}" = version ] \|\| ls -la "$dist"
	119	+case "${1:-}" in names \| version \| release-names) ;; *) ls -la "$dist" ;; esac

  # of build/config.yml, the system and the architecture.
  #
  #   scripts/package.sh linux     # .deb, .rpm, .AppImage and .tar.gz for this machine's architecture
--#   scripts/package.sh windows   # installer (NSIS) and .zip for Windows amd64, cross-built from Linux or macOS
++#   scripts/package.sh windows [amd64|arm64]  # installer (NSIS) and .zip for Windows (default amd64), cross-built from Linux or macOS
  #   scripts/package.sh macos     # .dmg and .zip of the .app for Apple Silicon (arm64), on macOS only
  #   scripts/package.sh names linux arm64   # prints the file names, builds nothing
++#   scripts/package.sh release-names       # the files of a release (RELEASE_TARGETS), SHA256SUMS last
  #
  # Linux needs GTK 4 and WebKitGTK 6 dev packages, plus file (AppImage) and
  # rpm; Windows needs makensis (nsis); macOS needs the Xcode command line tools.
      esac
  }
++# What a release holds, as <system>/<arch>: the targets scripts/build-release.sh
++# builds and scripts/tag-release.sh expects in dist/. For now: macOS on Apple
++# Silicon and Windows; Linux is built on demand (LINUX_ARCHES).
++RELEASE_TARGETS="macos/arm64 windows/amd64 windows/arm64"
++
++release_names() {
++    local target
++    for target in $RELEASE_TARGETS; do names "${target%/*}" "${target#*/}"; done
++    echo SHA256SUMS
++}
++
  # The n-th name (1-based) of names.
  name() { names "$1" "$2" | sed -n "${3}p"; }
  }
  package_windows() {
--    wails windows:create:nsis:installer ARCH=amd64
++    local arch="$1"
++    case "$arch" in amd64 | arm64) ;; *) die "Windows packages are amd64 or arm64, not $arch" ;; esac
++    rm -f "$root/bin/sidekicks.exe"
++    wails windows:create:nsis:installer ARCH="$arch"
      mkdir -p "$dist"
--    mv "$root/bin/sidekicks-amd64-installer.exe" "$dist/$(name windows amd64 1)"
++    mv "$root/bin/sidekicks-$arch-installer.exe" "$dist/$(name windows "$arch" 1)"
--    (cd "$root/bin" && zip -q -j "$dist/$(name windows amd64 2)" sidekicks.exe)
++    (cd "$root/bin" && zip -q -j "$dist/$(name windows "$arch" 2)" sidekicks.exe)
  }
  package_macos() {
  case "${1:-}" in
      linux) package_linux ;;
--    windows) package_windows ;;
++    windows) package_windows "${2:-amd64}" ;;
      macos) package_macos ;;
      names) names "${2:?system}" "${3:?arch}" ;;
      version) version ;;
--    *) die "usage: package.sh linux|windows|macos|names <system> <arch>|version" ;;
++    release-names) release_names ;;
++    *) die "usage: package.sh linux|windows [amd64|arm64]|macos|names <system> <arch>|release-names|version" ;;
  esac
--[ "${1:-}" = names ] || [ "${1:-}" = version ] || ls -la "$dist"
++case "${1:-}" in names | version | release-names) ;; *) ls -la "$dist" ;; esac

modified scripts/package_test.sh +8 -0 Viewed

@@ -44,6 +44,14 @@ sidekicks_${version}_windows_amd64.zip" names windows amd64
44	44	expect "macos names" "Sidekicks-${version}-macos-arm64.dmg
45	45	Sidekicks-${version}-macos-arm64.zip" names macos arm64
46	46
	47	+expect "release names: macOS arm64, Windows amd64 and arm64, then the checksums" "Sidekicks-${version}-macos-arm64.dmg
	48	+Sidekicks-${version}-macos-arm64.zip
	49	+Sidekicks-${version}-windows-amd64-installer.exe
	50	+sidekicks_${version}_windows_amd64.zip
	51	+Sidekicks-${version}-windows-arm64-installer.exe
	52	+sidekicks_${version}_windows_arm64.zip
	53	+SHA256SUMS" release-names
	54	+
47	55	if "$script" names plan9 386 >/dev/null 2>&1; then echo "FAIL an unknown system is refused"; failures=$((failures + 1)); else echo "ok an unknown system is refused"; fi
48	56
49	57	if [ "$failures" -gt 0 ]; then echo "$failures failed"; exit 1; fi

  expect "macos names" "Sidekicks-${version}-macos-arm64.dmg
  Sidekicks-${version}-macos-arm64.zip" names macos arm64
++expect "release names: macOS arm64, Windows amd64 and arm64, then the checksums" "Sidekicks-${version}-macos-arm64.dmg
++Sidekicks-${version}-macos-arm64.zip
++Sidekicks-${version}-windows-amd64-installer.exe
++sidekicks_${version}_windows_amd64.zip
++Sidekicks-${version}-windows-arm64-installer.exe
++sidekicks_${version}_windows_arm64.zip
++SHA256SUMS" release-names
++
  if "$script" names plan9 386 >/dev/null 2>&1; then echo "FAIL an unknown system is refused"; failures=$((failures + 1)); else echo "ok   an unknown system is refused"; fi
  if [ "$failures" -gt 0 ]; then echo "$failures failed"; exit 1; fi

modified scripts/tag-release.sh +1 -1 Viewed

@@ -41,7 +41,7 @@ if git rev-parse -q --verify "refs/tags/$tag" >/dev/null; then
41	41	fi
42	42
43	43	missing=""
44		-for name in $(scripts/package.sh names macos arm64) $(scripts/package.sh names windows amd64) $(scripts/package.sh names linux amd64) SHA256SUMS; do
	44	+for name in $(scripts/package.sh release-names); do
45	45	[ -f "dist/$name" ] \|\| missing="$missing $name"
46	46	done
47	47	[ -z "$missing" ] \|\| echo "tag-release.sh: warning: dist/ has no$missing (scripts/build-release.sh builds them)" >&2

  fi
  missing=""
--for name in $(scripts/package.sh names macos arm64) $(scripts/package.sh names windows amd64) $(scripts/package.sh names linux amd64) SHA256SUMS; do
++for name in $(scripts/package.sh release-names); do
      [ -f "dist/$name" ] || missing="$missing $name"
  done
  [ -z "$missing" ] || echo "tag-release.sh: warning: dist/ has no$missing (scripts/build-release.sh builds them)" >&2

modified scripts/tag-release_test.sh +1 -1 Viewed

@@ -58,7 +58,7 @@ printf 'info:\n version: "1.2.4"\n' > "$work/repo/build/config.yml"
58	58	git -C "$work/repo" commit -q -am "1.2.4"
59	59	git -C "$work/repo" push -q origin main
60	60	mkdir -p "$work/repo/dist"
61		-for name in $("$work/repo/scripts/package.sh" names macos arm64) $("$work/repo/scripts/package.sh" names windows amd64) $("$work/repo/scripts/package.sh" names linux amd64) SHA256SUMS; do : > "$work/repo/dist/$name"; done
	61	+for name in $("$work/repo/scripts/package.sh" release-names); do : > "$work/repo/dist/$name"; done
62	62	expect "--no-push tags locally only" 0 scripts/tag-release.sh --no-push
63	63	grep -q warning "$work/out" && fail "no warning when dist/ is complete" \|\| ok "no warning when dist/ is complete"
64	64	git -C "$work/repo" rev-parse -q --verify refs/tags/v1.2.4 >/dev/null && [ -z "$(git -C "$work/remote.git" tag -l v1.2.4)" ] && ok "the local tag is not pushed" \|\| fail "the local tag is not pushed"

  git -C "$work/repo" commit -q -am "1.2.4"
  git -C "$work/repo" push -q origin main
  mkdir -p "$work/repo/dist"
--for name in $("$work/repo/scripts/package.sh" names macos arm64) $("$work/repo/scripts/package.sh" names windows amd64) $("$work/repo/scripts/package.sh" names linux amd64) SHA256SUMS; do : > "$work/repo/dist/$name"; done
++for name in $("$work/repo/scripts/package.sh" release-names); do : > "$work/repo/dist/$name"; done
  expect "--no-push tags locally only" 0 scripts/tag-release.sh --no-push
  grep -q warning "$work/out" && fail "no warning when dist/ is complete" || ok "no warning when dist/ is complete"
  git -C "$work/repo" rev-parse -q --verify refs/tags/v1.2.4 >/dev/null && [ -z "$(git -C "$work/remote.git" tag -l v1.2.4)" ] && ok "the local tag is not pushed" || fail "the local tag is not pushed"

🛟 Updated.