feat(desktop): custom installer + React UI refactor (monorepo, design system, frameless)

.github/workflows/ci.yml

@@ -4,6 +4,11 @@ on:
   push:
     branches: [main]
   pull_request:
+    # Include `edited` so the Conventional Commits PR-title check re-validates
+    # when a title is fixed (default types omit it, leaving the check stuck red
+    # — a rerun just replays the stale event payload, so only a new event
+    # helps).
+    types: [opened, synchronize, reopened, edited]
     branches: [main]
 
 permissions:

.github/workflows/installer.yml

@@ -65,6 +65,11 @@ jobs:
         working-directory: cmd/clawtool-installer
     steps:
       - uses: actions/checkout@v4
+        with:
+          # Pull namzu (and any future submodules) so desktop/submodules/namzu
+          # is populated — the desktop pnpm workspace links @namzu/sdk from
+          # there as the embedded agent runtime.
+          submodules: recursive
 
       - uses: actions/setup-go@v5
         with:
@@ -86,75 +91,118 @@ jobs:
       - name: wails doctor
         run: wails doctor || true
 
-      # ── Windows: build GUI → bundle headless binary → compile our
-      #    customized NSIS installer (build/windows/installer/project.nsi)
-      #    which installs BOTH the GUI + clawtool.exe into Program Files,
-      #    creates shortcuts + an uninstaller, and offers to run setup. ──
-      - name: Install NSIS (Windows)
-        if: runner.os == 'Windows'
-        run: choco install nsis -y --no-progress
-        shell: pwsh
-
-      - name: Build the GUI (Windows)
-        if: runner.os == 'Windows'
-        run: wails build -platform windows/amd64
-        shell: pwsh
+      # Build the React frontend monorepo (Vite) and place the app SPA's
+      # bundle where the Go binary embeds it (//go:embed all:frontend/dist).
+      # The same SPA serves every mode (app / installer / setup) by routing on
+      # App.Mode(), so one bundle is embedded by both the app and setup builds.
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
 
-      - name: Restore committed NSIS template (Windows)
-        if: runner.os == 'Windows'
-        working-directory: ${{ github.workspace }}
-        # `wails build` may regenerate wails_tools.nsh; restore our
-        # checked-in, customized project.nsi + wails_tools.nsh before
-        # compiling so the clawtool.exe bundling + tweaks survive.
-        run: git checkout -- cmd/clawtool-installer/build/windows/installer/
-        shell: pwsh
+      - name: Build desktop frontend (Vite)
+        working-directory: ${{ github.workspace }}/desktop
+        run: |
+          corepack enable
+          pnpm install --frozen-lockfile
+          # The desktop app imports types from @namzu/sdk, whose dist/ is the
+          # main entry — build it before app-ui so the import resolves.
+          pnpm --filter @namzu/sdk build
+          pnpm --filter @clawtool/app-ui build
+        shell: bash
 
-      - name: Bundle headless clawtool.exe (Windows)
-        if: runner.os == 'Windows'
-        working-directory: ${{ github.workspace }}
-        run: go build -ldflags "-s -w" -o cmd/clawtool-installer/build/bin/clawtool.exe ./cmd/clawtool
+      # Bundle the namzu runtime the desktop spawns for local turns into a
+      # single self-contained CJS file. esbuild collapses the whole pnpm
+      # workspace + node_modules + the literal dynamic provider imports into
+      # one ~19 MB namzu.cjs — so the shipped .app needs only a node binary +
+      # this file, no node_modules tree. Generic: any node CLI bundles this way.
+      # macOS-only: only the macOS embed step below consumes namzu.cjs today;
+      # the Windows installer doesn't ship the namzu runtime yet (follow-up).
+      - name: Bundle namzu runtime (esbuild)
+        if: runner.os == 'macOS'
+        working-directory: ${{ github.workspace }}/desktop/submodules/namzu
+        run: |
+          # namzu's @types/node lives in ITS OWN node_modules — the desktop
+          # workspace doesn't include namzu's root package.json, so the earlier
+          # `pnpm install` in desktop/ doesn't provide it. Install namzu's own
+          # deps here (it has its own committed lockfile) or the cli build fails
+          # with TS2688 "Cannot find type definition file for 'node'".
+          pnpm install --frozen-lockfile
+          pnpm -r build
+          # esbuild is only a TRANSITIVE dep here, so `pnpm exec esbuild` can't
+          # find it — fetch + run it with pnpm dlx (pinned for reproducibility).
+          # ESM output (not CJS): the CLI uses import.meta, which esbuild only
+          # supports in --format=esm. The createRequire banner restores a
+          # working `require` so the bundle's CJS-interop deps still load.
+          # react-devtools-core: Ink imports it ONLY under DEV=true (never in
+          # our headless run-stream), but esbuild still tries to resolve it —
+          # alias it to an empty stub so the bundle stays self-contained.
+          printf 'export function connectToDevTools(){}\nexport default {};\n' > /tmp/devtools-stub.mjs
+          pnpm dlx esbuild@0.27.7 packages/cli/dist/bin.js \
+            --bundle --platform=node --format=esm --target=node20 \
+            --outfile=namzu.mjs \
+            --alias:react-devtools-core=/tmp/devtools-stub.mjs \
+            "--banner:js=import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);"
+          ls -la namzu.mjs
+          # Smoke-test the bundle in an isolated dir (no node_modules) so a
+          # broken bundle fails the build here, not on the user's machine.
+          mkdir -p /tmp/namzu-smoke && cp namzu.mjs /tmp/namzu-smoke/
+          node /tmp/namzu-smoke/namzu.mjs --help >/dev/null
+          echo "namzu bundle smoke OK"
+        shell: bash
 
-      - name: Bundle updater ClawtoolUpdate.exe (Windows)
-        if: runner.os == 'Windows'
+      - name: Place frontend bundle into the Go embed dir
         working-directory: ${{ github.workspace }}
-        run: go build -ldflags "-s -w" -o cmd/clawtool-installer/build/bin/ClawtoolUpdate.exe ./cmd/clawtool-updater
-        shell: pwsh
+        run: |
+          rm -rf cmd/clawtool-installer/frontend/dist
+          mkdir -p cmd/clawtool-installer/frontend/dist
+          cp -R desktop/apps/app-ui/dist/. cmd/clawtool-installer/frontend/dist/
+        shell: bash
 
-      - name: Fetch WebView2 bootstrapper (Windows)
+      # ── Windows: custom app-style installer via a 2-build flow ──────
+      #  No classic NSIS wizard. The same Wails binary is both the app and
+      #  the setup — payload presence (//go:embed all:payload) flips it
+      #  into "setup" mode (see payload.go / main.go).
+      #
+      #    Build 1 → the app, Clawtool.exe, with an empty payload/ → plain
+      #              "app" mode.
+      #    Stage   → copy that Clawtool.exe + the headless clawtool.exe +
+      #              ClawtoolUpdate.exe into payload/.
+      #    Build 2 → recompile; the payload is now embedded, so the binary
+      #              self-installs on launch. Rename it ClawtoolSetup.exe.
+      #
+      #  Running ClawtoolSetup.exe lays the embedded payload into
+      #  %LOCALAPPDATA%\Programs\Clawtool, wires shortcuts/PATH/uninstaller
+      #  (install/install.go), then launches the installed Clawtool.exe —
+      #  which, having no payload, runs as the app.
+      - name: Build 1 — the app GUI (Windows)
         if: runner.os == 'Windows'
-        working-directory: cmd/clawtool-installer/build/windows/installer
-        # The wails.webview2runtime NSIS macro bundles this so the
-        # installer can provision WebView2 on machines that lack it.
-        # `wails build -nsis` downloads it automatically; our manual
-        # makensis call must fetch it into tmp/ first.
-        run: |
-          New-Item -ItemType Directory -Force -Path tmp | Out-Null
-          Invoke-WebRequest "https://go.microsoft.com/fwlink/p/?LinkId=2124703" -OutFile "tmp\MicrosoftEdgeWebview2Setup.exe"
+        run: wails build -platform windows/amd64
         shell: pwsh
 
-      - name: Fetch EnVar NSIS plugin (Windows)
+      - name: Stage payload — app + headless CLI + updater (Windows)
         if: runner.os == 'Windows'
-        working-directory: cmd/clawtool-installer/build/windows/installer
-        # project.nsi adds the install dir to the system PATH via the
-        # EnVar plugin (the only truncation-safe way — see the comment in
-        # project.nsi). makensis needs the DLL on its plugin search path;
-        # `!addplugindir ".\plugins"` points at the dir we drop it into.
-        # Unicode true ⇒ use the x86-unicode build of the plugin.
+        working-directory: ${{ github.workspace }}
+        # CLI goes under payload/bin/ — Clawtool.exe (app) and clawtool.exe
+        # (CLI) differ only in case, so they MUST NOT share a directory: on
+        # the case-insensitive runner the second write would clobber the
+        # first (this once dropped the app from the payload entirely).
         run: |
-          New-Item -ItemType Directory -Force -Path plugins | Out-Null
-          New-Item -ItemType Directory -Force -Path tmp | Out-Null
-          Invoke-WebRequest "https://nsis.sourceforge.io/mediawiki/images/7/7f/EnVar_plugin.zip" -OutFile "tmp\EnVar_plugin.zip"
-          Expand-Archive -Path "tmp\EnVar_plugin.zip" -DestinationPath "tmp\envar" -Force
-          Copy-Item "tmp\envar\Plugins\x86-unicode\EnVar.dll" -Destination "plugins\EnVar.dll" -Force
+          $payload = "cmd/clawtool-installer/payload"
+          New-Item -ItemType Directory -Force -Path "$payload/bin" | Out-Null
+          Copy-Item "cmd/clawtool-installer/build/bin/Clawtool.exe" "$payload/Clawtool.exe" -Force
+          go build -ldflags "-s -w" -o "$payload/bin/clawtool.exe" ./cmd/clawtool
+          go build -ldflags "-s -w" -o "$payload/ClawtoolUpdate.exe" ./cmd/clawtool-updater
         shell: pwsh
 
-      - name: Compile NSIS installer (Windows)
+      - name: Build 2 — self-installing ClawtoolSetup.exe (Windows)
         if: runner.os == 'Windows'
-        working-directory: cmd/clawtool-installer/build/windows/installer
-        # choco installs NSIS but doesn't refresh this step's PATH, so
-        # call makensis by its standard install path.
+        # Stamp the setup's display version from the release tag when called
+        # from release.yml; "dev" for branch / PR builds.
         run: |
-          & "C:\Program Files (x86)\NSIS\makensis.exe" "-DARG_WAILS_AMD64_BINARY=..\..\bin\Clawtool.exe" project.nsi
+          $ver = if ("${{ inputs.tag }}") { "${{ inputs.tag }}" -replace '^v','' } else { "dev" }
+          wails build -platform windows/amd64 -ldflags "-X main.setupVersion=$ver"
+          Move-Item "build/bin/Clawtool.exe" "build/bin/ClawtoolSetup.exe" -Force
         shell: pwsh
 
       # ── macOS: build .app, embed a universal headless clawtool, .dmg ──
@@ -170,22 +218,65 @@ jobs:
           if [ -z "$app" ]; then echo "no .app produced"; exit 1; fi
           GOARCH=amd64 go build -ldflags "-s -w" -o /tmp/clawtool-amd64 ./cmd/clawtool
           GOARCH=arm64 go build -ldflags "-s -w" -o /tmp/clawtool-arm64 ./cmd/clawtool
-          lipo -create -output "$app/Contents/MacOS/clawtool" /tmp/clawtool-amd64 /tmp/clawtool-arm64
-          echo "embedded universal clawtool at $app/Contents/MacOS/clawtool"
+          # CLI under MacOS/bin/ — the GUI binary and the headless CLI would
+          # otherwise case-collide in Contents/MacOS on case-insensitive macOS.
+          mkdir -p "$app/Contents/MacOS/bin"
+          lipo -create -output "$app/Contents/MacOS/bin/clawtool" /tmp/clawtool-amd64 /tmp/clawtool-arm64
+          echo "embedded universal clawtool at $app/Contents/MacOS/bin/clawtool"
           # Standalone updater alongside it (the app hands off to this to
           # swap binaries it can't overwrite while running, then relaunch).
           GOARCH=amd64 go build -ldflags "-s -w" -o /tmp/upd-amd64 ./cmd/clawtool-updater
           GOARCH=arm64 go build -ldflags "-s -w" -o /tmp/upd-arm64 ./cmd/clawtool-updater
           lipo -create -output "$app/Contents/MacOS/ClawtoolUpdate" /tmp/upd-amd64 /tmp/upd-arm64
           echo "embedded universal updater at $app/Contents/MacOS/ClawtoolUpdate"
 
+      # Ship a self-contained namzu runtime + Node inside the .app so a local
+      # turn runs with zero external dependencies (no Homebrew, no system
+      # node, no agent CLI). locateNamzu (namzu_runtime.go) resolves
+      # Contents/Resources/namzu/{node,namzu.cjs}.
+      - name: Embed namzu runtime + Node into .app (macOS)
+        if: runner.os == 'macOS'
+        working-directory: ${{ github.workspace }}
+        run: |
+          app=$(ls -d cmd/clawtool-installer/build/bin/*.app | head -1)
+          [ -n "$app" ] || { echo "no .app produced"; exit 1; }
+          res="$app/Contents/Resources/namzu"
+          mkdir -p "$res"
+          cp desktop/submodules/namzu/namzu.mjs "$res/namzu.mjs"
+          NODE_VER=v22.14.0
+          base="https://nodejs.org/dist/${NODE_VER}"
+          curl -fsSL "${base}/node-${NODE_VER}-darwin-arm64.tar.gz" -o /tmp/node-arm64.tgz
+          curl -fsSL "${base}/node-${NODE_VER}-darwin-x64.tar.gz"   -o /tmp/node-x64.tgz
+          mkdir -p /tmp/node-arm64 /tmp/node-x64
+          tar -xzf /tmp/node-arm64.tgz -C /tmp/node-arm64 --strip-components=1
+          tar -xzf /tmp/node-x64.tgz   -C /tmp/node-x64   --strip-components=1
+          lipo -create -output "$res/node" /tmp/node-arm64/bin/node /tmp/node-x64/bin/node
+          chmod +x "$res/node"
+          echo "embedded namzu runtime + node at $res"; ls -la "$res"
+          "$res/node" "$res/namzu.mjs" --help >/dev/null 2>&1 && echo "bundled namzu OK" || echo "bundled namzu --help nonzero (non-fatal)"
+
       - name: Package macOS .dmg
         if: runner.os == 'macOS'
         run: |
           app=$(ls -d build/bin/*.app | head -1)
           if [ -z "$app" ]; then echo "no .app produced"; exit 1; fi
+          # macOS convention: the bundle is just the product name — no
+          # "installer" suffix (that's a Windows thing). Rename here so the
+          # icon a user sees in Finder is "Clawtool.app".
+          if [ "$(basename "$app")" != "Clawtool.app" ]; then
+            mv "$app" "$(dirname "$app")/Clawtool.app"
+            app="$(dirname "$app")/Clawtool.app"
+          fi
+          # Drag-to-install .dmg layout: stage the app next to an
+          # Applications symlink, so opening the .dmg shows "Clawtool.app |
+          # Applications →" and the user drags one onto the other — the
+          # standard macOS install gesture.
+          stage="$(mktemp -d)/dmg"
+          mkdir -p "$stage"
+          cp -R "$app" "$stage/Clawtool.app"
+          ln -s /Applications "$stage/Applications"
           hdiutil create -volname "Clawtool" \
-            -srcfolder "$app" -ov -format UDZO \
+            -srcfolder "$stage" -ov -format UDZO \
             "build/bin/Clawtool.dmg"
 
       - name: Upload installer artifact

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "desktop/submodules/namzu"]
+	path = desktop/submodules/namzu
+	url = https://github.com/cogitave/namzu.git