feat(desktop): in-app MCP popup to connect Duckle to an AI

Add a small MCP button (robot icon) to the designer top bar that opens a
compact popup for connecting Duckle to an MCP client. It bundles the
duckle-mcp server with the app and fills in the real resolved paths:

- duckle-mcp is embedded into the desktop binary (build.rs include_bytes!,
  same mechanism as the runner) and extracted on demand to an app-data dir,
  with the runner written alongside it so the server resolves it for builds.
- mcp_connection_info stages the server and returns the paths plus a
  ready-to-paste `claude mcp add` command and an mcpServers JSON config.
- connect_claude_code runs `claude mcp add duckle ...` in one click (cmd
  raw_arg on Windows to resolve the claude.cmd shim); falls back to copy if
  the CLI is absent.
- McpModal shows status (bundled / DuckDB found), the one-click connect, copy
  buttons for the command + config, and per-client guidance.
- CI / release / GitLab now build + stage duckle-mcp alongside the runner so
  the desktop embed has it.

Docs: the in-app popup is the easiest connect path in docs/current/mcp.md.

Author: SouravRoy-ETL

.github/workflows/ci.yml

@@ -72,20 +72,22 @@ jobs:
         run: |
           "$DUCKLE_DUCKDB_BIN" :memory: -c "INSTALL postgres; INSTALL mysql; INSTALL sqlite; INSTALL excel; INSTALL httpfs; INSTALL iceberg; INSTALL delta; INSTALL ducklake; INSTALL vss; INSTALL fts; INSTALL inet;"
 
-      # The desktop crate embeds duckle-runner at compile time via build.rs
-      # include_bytes!, so the runner binary must exist before anything that
-      # compiles apps/desktop. Build it in the dev profile so the engine
+      # The desktop crate embeds duckle-runner AND duckle-mcp at compile time
+      # via build.rs include_bytes!, so both binaries must exist before anything
+      # that compiles apps/desktop. Build them in the dev profile so the engine
       # compilation is shared with the cargo test below.
-      - name: Build + stage duckle-runner (embedded into the desktop app)
+      - name: Build + stage duckle-runner + duckle-mcp (embedded into the desktop app)
         shell: bash
         run: |
           set -e
-          cargo build -p duckle-runner
+          cargo build -p duckle-runner -p duckle-mcp
           mkdir -p apps/desktop/bin
           if [ "$RUNNER_OS" = "Windows" ]; then
             cp target/debug/duckle-runner.exe apps/desktop/bin/duckle-runner.exe
+            cp target/debug/duckle-mcp.exe apps/desktop/bin/duckle-mcp.exe
           else
             cp target/debug/duckle-runner apps/desktop/bin/duckle-runner
+            cp target/debug/duckle-mcp apps/desktop/bin/duckle-mcp
           fi
 
       - name: Test
@@ -129,15 +131,16 @@ jobs:
           sudo apt-get install -y \
             libwebkit2gtk-4.1-dev libgtk-3-dev \
             libayatana-appindicator3-dev librsvg2-dev libsoup-3.0-dev
-      # Build + stage duckle-runner first: the desktop crate embeds it at
-      # compile time (build.rs include_bytes!). Release profile so the engine
-      # build is shared with the desktop release build below.
-      - name: Build + stage duckle-runner (embedded into the desktop app)
+      # Build + stage duckle-runner + duckle-mcp first: the desktop crate embeds
+      # both at compile time (build.rs include_bytes!). Release profile so the
+      # engine build is shared with the desktop release build below.
+      - name: Build + stage duckle-runner + duckle-mcp (embedded into the desktop app)
         run: |
           set -e
-          cargo build --release -p duckle-runner
+          cargo build --release -p duckle-runner -p duckle-mcp
           mkdir -p apps/desktop/bin
           cp target/release/duckle-runner apps/desktop/bin/duckle-runner
+          cp target/release/duckle-mcp apps/desktop/bin/duckle-mcp
       - name: Build raw Duckle binary (release workflow command)
         run: cargo build --release --manifest-path apps/desktop/Cargo.toml --features custom-protocol
       - name: Verify embedded frontend (not devUrl) is in binary

.github/workflows/release.yml

@@ -97,22 +97,24 @@ jobs:
             libwebkit2gtk-4.1-dev libgtk-3-dev \
             libayatana-appindicator3-dev librsvg2-dev libsoup-3.0-dev
 
-      - name: Build duckle-runner (bundled into the app)
+      - name: Build duckle-runner + duckle-mcp (bundled into the app)
         shell: bash
         run: |
           set -e
           if [ -n "${{ matrix.target }}" ]; then
-            cargo build --profile release-runner --target "${{ matrix.target }}" -p duckle-runner
-            src="target/${{ matrix.target }}/release-runner/duckle-runner"
+            cargo build --profile release-runner --target "${{ matrix.target }}" -p duckle-runner -p duckle-mcp
+            base="target/${{ matrix.target }}/release-runner"
           else
-            cargo build --profile release-runner -p duckle-runner
-            src="target/release-runner/duckle-runner"
+            cargo build --profile release-runner -p duckle-runner -p duckle-mcp
+            base="target/release-runner"
           fi
           mkdir -p apps/desktop/bin
           if [ "${{ runner.os }}" = "Windows" ]; then
-            cp "$src.exe" apps/desktop/bin/duckle-runner.exe
+            cp "$base/duckle-runner.exe" apps/desktop/bin/duckle-runner.exe
+            cp "$base/duckle-mcp.exe" apps/desktop/bin/duckle-mcp.exe
           else
-            cp "$src" apps/desktop/bin/duckle-runner
+            cp "$base/duckle-runner" apps/desktop/bin/duckle-runner
+            cp "$base/duckle-mcp" apps/desktop/bin/duckle-mcp
           fi
 
       - name: Build raw Duckle binary

.gitlab-ci.yml

@@ -138,12 +138,13 @@ desktop-build:linux:
     - npm --prefix frontend ci
   script:
     - npm --prefix frontend run build
-    # Build + stage duckle-runner first: the desktop crate embeds it at
-    # compile time (build.rs include_bytes!). Release profile so the engine
-    # build is shared with the desktop release build below.
-    - cargo build --release -p duckle-runner
+    # Build + stage duckle-runner + duckle-mcp first: the desktop crate embeds
+    # both at compile time (build.rs include_bytes!). Release profile so the
+    # engine build is shared with the desktop release build below.
+    - cargo build --release -p duckle-runner -p duckle-mcp
     - mkdir -p apps/desktop/bin
     - cp target/release/duckle-runner apps/desktop/bin/duckle-runner
+    - cp target/release/duckle-mcp apps/desktop/bin/duckle-mcp
     - cargo build --release --manifest-path apps/desktop/Cargo.toml --features custom-protocol
     # Verify the embedded frontend chunk is actually in the binary. If
     # tauri-codegen embedded devUrl instead this would be absent.

apps/desktop/build.rs

@@ -21,10 +21,59 @@ fn main() {
     println!("cargo:rerun-if-changed=.duckle-always-restamp-build-epoch");
 
     embed_runner();
+    embed_mcp();
 
     tauri_build::build()
 }
 
+/// Locate a freshly built `duckle-mcp` and expose its bytes to lib.rs via
+/// include_bytes!(env!("DUCKLE_EMBEDDED_MCP")). Unlike the runner (required for
+/// Build Pipeline), the MCP server is optional: when it is not staged we embed
+/// an empty file so the desktop still builds, and the in-app MCP popup reports
+/// that this build carries no bundled server. CI / release stage it for real.
+fn embed_mcp() {
+    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR");
+    let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR");
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    let name = if target_os == "windows" {
+        "duckle-mcp.exe"
+    } else {
+        "duckle-mcp"
+    };
+
+    let staged = std::path::Path::new(&manifest_dir).join("bin").join(name);
+    let profile_dir = std::path::Path::new(&out_dir)
+        .ancestors()
+        .nth(3)
+        .map(|p| p.join(name));
+    let source = if staged.exists() {
+        Some(staged)
+    } else {
+        profile_dir.filter(|p| p.exists())
+    };
+
+    let dst = std::path::Path::new(&out_dir).join("embedded-mcp.bin");
+    match source {
+        Some(src) => {
+            std::fs::copy(&src, &dst)
+                .unwrap_or_else(|e| panic!("copy {} -> {}: {}", src.display(), dst.display(), e));
+            println!("cargo:rerun-if-changed={}", src.display());
+        }
+        None => {
+            std::fs::write(&dst, [])
+                .unwrap_or_else(|e| panic!("write empty embedded-mcp: {}", e));
+            println!(
+                "cargo:warning=duckle-mcp not staged (apps/desktop/bin/{name}); the in-app MCP popup will report no bundled server. Stage it: cargo build --profile release-runner -p duckle-mcp"
+            );
+        }
+    }
+    println!("cargo:rustc-env=DUCKLE_EMBEDDED_MCP={}", dst.display());
+    println!(
+        "cargo:rerun-if-changed={}",
+        std::path::Path::new(&manifest_dir).join("bin").join(name).display()
+    );
+}
+
 /// Locate a freshly built `duckle-runner` and expose its bytes to lib.rs via
 /// include_bytes!(env!("DUCKLE_EMBEDDED_RUNNER")). The runner is captured at
 /// desktop-compile time, so developers must build duckle-runner BEFORE (or