fix(web): review fixes — bridge no-config connect in wizard + per-client Connect All backups

Codex review of the Spec 078 US2 slice found two majors and a minor; all
three verified against the code and fixed:

1. OnboardingWizard ClientRow rendered 'Not installed' for EVERY
   exists=false client, including bridge clients (Claude Desktop), which
   the backend explicitly marks connectable without a config file
   (internal/connect/connect.go:48; connect creates the file, returning an
   empty backup_path — connect_test.go:253). That made the wizard's
   "no prior file to back up" branch (FR-006 / US2 independent test)
   unreachable. ClientRow now gates on !exists && !bridge, matching
   ConnectModal's connectableClients predicate; non-bridge missing clients
   still show 'Not installed'.

2. ConnectModal connectAll() let each connect() overwrite
   resultBackupPath, so a bulk run over N modified configs displayed only
   the Nth backup (SC-005 requires 100%). connectAll now accumulates a
   per-client bulkBackups list ({name, path|no-prior-file} per successful
   connect, each with its own Copy affordance) and suppresses the single-
   result line for bulk runs. The loop also iterates a snapshot of
   connectableClients — connect() refetches the listing mid-loop, which
   mutated the computed while it was being iterated. Single connects
   (connectSingle) and disconnects clear the bulk list.

3. Minor: the wizard's open watcher reset connectMessage but not
   connectBackups/copiedBackupClient, so backup rows from a previous
   wizard session replayed on reopen. Both are now session-scoped.

TDD: 4 new failing cases first — wizard bridge-no-config connect,
wizard non-bridge stays 'Not installed', wizard reopen clears backup rows,
ConnectModal Connect All shows all three per-client outcomes (two paths +
one no-prior-file) with per-row copy. Full frontend suite: 32 files,
239 tests pass; vue-tsc clean; make build rebuilds the embedded dist;
golangci-lint v2 + go test -race ./internal/connect/... clean (no Go
changes in this commit).

npm-ci metadata churn in frontend/package-lock.json reverted again, not
committed (same as the base commit).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Dumbris

frontend/src/components/ConnectModal.vue

@@ -69,7 +69,7 @@
               </button>
               <button
                 v-else
-                @click="connect(client.id)"
+                @click="connectSingle(client.id)"
                 class="btn btn-primary btn-xs"
                 :disabled="loading.clients[client.id]"
               >
@@ -157,6 +157,37 @@
         >
           No prior config file existed, so no backup was needed.
         </div>
+        <!-- Spec 078 US2 / SC-005: Connect All renders EVERY successful
+             client's backup outcome — one line per client, each with its own
+             copy affordance — instead of only the last connect's path. -->
+        <div v-if="bulkBackups.length > 0" data-test="connect-bulk-backups" class="mt-2 space-y-1">
+          <div
+            v-for="b in bulkBackups"
+            :key="b.id"
+            :data-test="`connect-bulk-backup-${b.id}`"
+            class="flex items-start justify-between gap-2 rounded-lg bg-base-200 px-3 py-2"
+          >
+            <span class="text-xs leading-relaxed min-w-0">
+              <span class="font-medium">{{ b.name }}:</span>
+              <template v-if="b.backupPath">
+                a backup of your previous config was saved to
+                <code class="font-mono text-[11px] break-all" :title="b.backupPath">{{ b.backupPath }}</code>
+              </template>
+              <template v-else>
+                No prior config file existed, so no backup was needed.
+              </template>
+            </span>
+            <button
+              v-if="b.backupPath"
+              :data-test="`connect-bulk-copy-${b.id}`"
+              @click="copyBulkBackupPath(b)"
+              class="btn btn-ghost btn-xs shrink-0"
+              title="Copy this backup path to the clipboard"
+            >
+              {{ copiedBulkClient === b.id ? 'Copied ✓' : 'Copy path' }}
+            </button>
+          </div>
+        </div>
       </div>
 
       <div class="modal-action">
@@ -203,6 +234,12 @@ const resultSuccess = ref(false)
 // back up; undefined = no successful operation to report on.
 const resultBackupPath = ref<string | null | undefined>(undefined)
 const copiedBackup = ref(false)
+// Spec 078 US2 / SC-005: per-client backup outcomes for Connect All. Every
+// successful connect in the bulk run keeps its own entry (string = backup
+// created; null = no prior file), so no client's backup path is overwritten
+// by the next one. Empty when the last operation was a single connect.
+const bulkBackups = ref<Array<{ id: string; name: string; backupPath: string | null }>>([])
+const copiedBulkClient = ref<string | null>(null)
 const loading = reactive({
   initial: false,
   clients: {} as Record<string, boolean>,
@@ -289,7 +326,17 @@ async function fetchClients() {
   }
 }
 
-async function connect(clientId: string) {
+// Single-connect entry point (row button): a fresh single operation supersedes
+// any earlier Connect All per-client backup list.
+async function connectSingle(clientId: string) {
+  bulkBackups.value = []
+  copiedBulkClient.value = null
+  await connect(clientId)
+}
+
+// Returns the outcome so connectAll can accumulate per-client backup results
+// (ok=true with backupPath string = backup created; null = no prior file).
+async function connect(clientId: string): Promise<{ ok: boolean; backupPath: string | null }> {
   loading.clients[clientId] = true
   resultMessage.value = ''
   resultBackupPath.value = undefined
@@ -301,34 +348,38 @@ async function connect(clientId: string) {
       resultMessage.value = response.data.message || `Connected to ${clientId}`
       resultSuccess.value = true
       // Empty/absent backup_path on success means no prior file existed.
-      resultBackupPath.value = response.data.backup_path || null
+      const backupPath = response.data.backup_path || null
+      resultBackupPath.value = backupPath
       await fetchClients()
       systemStore.addToast({
         type: 'success',
         title: 'Client Connected',
         message: `MCPProxy registered in ${clientId}`,
       })
-    } else {
-      resultMessage.value = response.error || 'Failed to connect'
-      resultSuccess.value = false
-      // The write may have failed because macOS blocked the config. Resolve the
-      // access state in-band so a denial surfaces as the actionable banner.
-      void checkAccess(clientId)
+      return { ok: true, backupPath }
     }
+    resultMessage.value = response.error || 'Failed to connect'
+    resultSuccess.value = false
+    // The write may have failed because macOS blocked the config. Resolve the
+    // access state in-band so a denial surfaces as the actionable banner.
+    void checkAccess(clientId)
   } catch (err) {
     resultMessage.value = err instanceof Error ? err.message : 'Unknown error'
     resultSuccess.value = false
     void checkAccess(clientId)
   } finally {
     loading.clients[clientId] = false
   }
+  return { ok: false, backupPath: null }
 }
 
 async function disconnect(clientId: string) {
   loading.clients[clientId] = true
   resultMessage.value = ''
   resultBackupPath.value = undefined
   copiedBackup.value = false
+  bulkBackups.value = []
+  copiedBulkClient.value = null
 
   try {
     const client = clients.value.find(c => c.id === clientId)
@@ -429,16 +480,51 @@ async function copyBackupPath() {
   }
 }
 
+// Spec 078 US2 / SC-005: Connect All accumulates every successful client's
+// backup outcome instead of letting each connect() overwrite the previous
+// client's backup path.
 async function connectAll() {
-  for (const client of connectableClients.value) {
-    await connect(client.id)
+  bulkBackups.value = []
+  copiedBulkClient.value = null
+  // Snapshot: connect() refetches the client list mid-loop, which mutates the
+  // connectableClients computed while we iterate it.
+  const targets = [...connectableClients.value]
+  const collected: Array<{ id: string; name: string; backupPath: string | null }> = []
+  for (const client of targets) {
+    const outcome = await connect(client.id)
+    if (outcome.ok) {
+      collected.push({ id: client.id, name: client.name, backupPath: outcome.backupPath })
+    }
+  }
+  if (collected.length > 0) {
+    bulkBackups.value = collected
+    // The per-client list is authoritative for a bulk run; suppress the
+    // single-result line that would otherwise repeat only the last backup.
+    resultBackupPath.value = undefined
+  }
+}
+
+// Per-row copy for the Connect All backup list.
+async function copyBulkBackupPath(entry: { id: string; backupPath: string | null }) {
+  if (!entry.backupPath) return
+  try {
+    await navigator.clipboard.writeText(entry.backupPath)
+    copiedBulkClient.value = entry.id
+    setTimeout(() => {
+      if (copiedBulkClient.value === entry.id) copiedBulkClient.value = null
+    }, 2000)
+  } catch {
+    // Clipboard unavailable (e.g. insecure context): the full path is already
+    // rendered, so the user can select and copy it manually.
   }
 }
 
 function close() {
   resultMessage.value = ''
   resultBackupPath.value = undefined
   copiedBackup.value = false
+  bulkBackups.value = []
+  copiedBulkClient.value = null
   emit('close')
 }
 
@@ -452,6 +538,8 @@ watch(() => props.show, (newVal) => {
     resultMessage.value = ''
     resultBackupPath.value = undefined
     copiedBackup.value = false
+    bulkBackups.value = []
+    copiedBulkClient.value = null
   }
 })
 </script>

frontend/src/components/OnboardingWizard.vue

@@ -707,6 +707,10 @@ watch(() => props.show, async (open) => {
   if (open) {
     serverAddedJustNow.value = false
     connectMessage.value = ''
+    // Backup lines are session-scoped (Spec 078 US2): don't replay backup
+    // rows from connects performed in a previous wizard session.
+    for (const k of Object.keys(connectBackups)) delete connectBackups[k]
+    copiedBackupClient.value = null
     await onboarding.fetchState()
     await Promise.all([
       fetchClients(),
@@ -1160,7 +1164,11 @@ const ClientRow: FunctionalComponent<
       h('div', { class: 'shrink-0 ml-2' }, [
         !c.supported
           ? h('span', { class: 'badge badge-ghost badge-sm' }, c.reason || 'Not supported')
-          : !c.exists
+          // Bridge clients (e.g. Claude Desktop) are connectable even without
+          // an existing config file — Connect creates it (parity with
+          // ConnectModal's connectableClients gating; Spec 078 US2/FR-006:
+          // this is the path that produces the "no prior file" backup case).
+          : !c.exists && !c.bridge
             ? h('span', { class: 'text-xs opacity-40' }, 'Not installed')
             : c.connected
               ? h('span', { class: 'badge badge-success badge-sm' }, 'Connected')

frontend/tests/unit/connect-modal.spec.ts

@@ -513,6 +513,103 @@ describe('ConnectModal', () => {
     expect(backup.text()).toContain('opencode.json.bak.20260702-110000')
   })
 
+  // Spec 078 US2 / SC-005: Connect All must surface EVERY successful client's
+  // backup outcome, not just the last one — 100% of successful connects that
+  // modified an existing config display their backup path.
+  it('Connect All surfaces a per-client backup line for every successful connect', async () => {
+    ;(api.getConnectStatus as any).mockResolvedValue({
+      success: true,
+      data: [
+        {
+          id: 'cursor',
+          name: 'Cursor',
+          config_path: '/Users/test/.cursor/mcp.json',
+          exists: true,
+          connected: false,
+          supported: true,
+          icon: 'cursor',
+        },
+        {
+          id: 'codex',
+          name: 'Codex CLI',
+          config_path: '/Users/test/.codex/config.toml',
+          exists: true,
+          connected: false,
+          supported: true,
+          icon: 'codex',
+        },
+        {
+          // Bridge client with no config file: connect creates it → no backup.
+          id: 'claude-desktop',
+          name: 'Claude Desktop',
+          config_path: '/Users/test/Library/Application Support/Claude/claude_desktop_config.json',
+          exists: false,
+          connected: false,
+          supported: true,
+          bridge: true,
+          icon: 'claude-desktop',
+        },
+      ],
+    })
+    ;(api.connectClient as any).mockImplementation((id: string) => {
+      const backups: Record<string, string | undefined> = {
+        cursor: '/Users/test/.cursor/mcp.json.bak.20260702-101530',
+        codex: '/Users/test/.codex/config.toml.bak.20260702-101531',
+        'claude-desktop': undefined,
+      }
+      return Promise.resolve({
+        success: true,
+        data: {
+          success: true,
+          client: id,
+          config_path: '',
+          backup_path: backups[id],
+          server_name: 'mcpproxy',
+          action: 'added',
+          message: `MCPProxy registered in ${id}`,
+        },
+      })
+    })
+    const writeText = vi.fn().mockResolvedValue(undefined)
+    Object.assign(navigator, { clipboard: { writeText } })
+
+    const wrapper = mount(ConnectModal, {
+      props: { show: false },
+      global: { plugins: [pinia] },
+    })
+    await wrapper.setProps({ show: true })
+    await flushPromises()
+
+    const connectAllBtn = wrapper
+      .findAll('button')
+      .find(b => b.text().includes('Connect All'))!
+    expect(connectAllBtn).toBeTruthy()
+    await connectAllBtn.trigger('click')
+    await flushPromises()
+
+    expect(api.connectClient).toHaveBeenCalledTimes(3)
+
+    // Every modified-config client shows ITS backup path.
+    const cursorRow = wrapper.find('[data-test="connect-bulk-backup-cursor"]')
+    expect(cursorRow.exists()).toBe(true)
+    expect(cursorRow.text()).toContain('/Users/test/.cursor/mcp.json.bak.20260702-101530')
+    const codexRow = wrapper.find('[data-test="connect-bulk-backup-codex"]')
+    expect(codexRow.exists()).toBe(true)
+    expect(codexRow.text()).toContain('/Users/test/.codex/config.toml.bak.20260702-101531')
+    // The no-prior-file client states its case explicitly.
+    const desktopRow = wrapper.find('[data-test="connect-bulk-backup-claude-desktop"]')
+    expect(desktopRow.exists()).toBe(true)
+    expect(desktopRow.text()).toContain('No prior config file existed')
+
+    // The single-result backup line must not duplicate the last client's path.
+    expect(wrapper.find('[data-test="connect-backup-path"]').exists()).toBe(false)
+
+    // Per-row copy copies THAT client's path.
+    await wrapper.find('[data-test="connect-bulk-copy-cursor"]').trigger('click')
+    await flushPromises()
+    expect(writeText).toHaveBeenCalledWith('/Users/test/.cursor/mcp.json.bak.20260702-101530')
+  })
+
   // Spec 075 US1/US2: the explicit per-client "Check access" action reads one
   // client's config on demand (the only privacy-prompt-eligible call) and
   // resolves its access_state in-band, surfacing a denial without a full connect.