Add Rebirth button to Edge Manager node and device lists (#628)

## Summary

- Per-row Rebirth button on Node and Device lists in the Edge Manager
- Sends `Node Control/Rebirth` or `Device Control/Rebirth` via CmdEsc
- Button only shown if user has the Rebirth CCL permission (checked via
Auth HTTP API with wildcard support)
- Loading spinner during request, success/error toasts
- Tooltip on hover

## Changes

- `RebirthButton.vue` - new component with CmdEsc integration and
tooltip
- `useCanRebirth.js` - composable that checks Rebirth ACL per target
- `nodeColumns.ts` / `EdgeCluster.vue` - Rebirth column in node list
- `deviceColumns.ts` / `Node.vue` - Rebirth column in device list
- `useNodeStore.js` - added sparkplugAddress config

## Test Plan

- [x] Verify Rebirth button appears for nodes/devices the user has
permission on
- [x] Verify button is hidden for users without Rebirth CCL permission
- [x] Click Rebirth on a node - verify NBIRTH is re-published
- [x] Click Rebirth on a device - verify DBIRTH is re-published
- [x] Verify loading spinner and success toast
- [x] Verify tooltip shows on hover

Author: AlexGodbehere

acs-admin/src/components/EdgeManager/RebirthButton.vue

@@ -0,0 +1,64 @@
+<template>
+  <TooltipProvider v-if="canRebirth">
+    <Tooltip>
+      <TooltipTrigger as-child>
+        <Button
+          size="xs"
+          variant="outline"
+          :disabled="loading"
+          class="ml-auto flex items-center justify-center gap-1.5 hover:bg-gray-800 hover:text-white"
+          @click.stop="rebirth"
+        >
+          <i class="fa-solid" :class="loading ? 'fa-circle-notch animate-spin' : 'fa-tower-broadcast'"></i>
+        </Button>
+      </TooltipTrigger>
+      <TooltipContent>
+        <p>Rebirth</p>
+      </TooltipContent>
+    </Tooltip>
+  </TooltipProvider>
+</template>
+
+<script>
+import { useServiceClientStore } from '@store/serviceClientStore.js'
+import { Button } from '@components/ui/button/index.js'
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
+import { toast } from 'vue-sonner'
+
+export default {
+  components: { Button, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger },
+  props: {
+    address: { type: String, required: true },
+    name: { type: String, required: true },
+    isDevice: { type: Boolean, default: false },
+    canRebirth: { type: Boolean, default: false },
+  },
+  data () {
+    return { loading: false }
+  },
+  methods: {
+    async rebirth () {
+      this.loading = true
+      const ctrl = this.isDevice ? 'Device Control' : 'Node Control'
+      try {
+        await useServiceClientStore().client.CmdEsc.request_cmd({
+          address: this.address,
+          name: `${ctrl}/Rebirth`,
+          type: 'Boolean',
+          value: true,
+        })
+        toast.success(`Rebirth sent to ${this.name}`)
+      } catch (e) {
+        if (e.status === 403) {
+          toast.error(`Permission denied: cannot rebirth ${this.name}`)
+        } else {
+          toast.error(`Failed to rebirth ${this.name}`)
+        }
+        console.error(e)
+      } finally {
+        this.loading = false
+      }
+    }
+  }
+}
+</script>

acs-admin/src/composables/useCanRebirth.js

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) University of Sheffield AMRC 2025.
+ */
+
+import { ref, watch } from 'vue'
+import { useServiceClientStore } from '@store/serviceClientStore.js'
+
+const REBIRTH_PERMISSION = 'fbb9c25d-386d-4966-a325-f16471d9f7be'
+const WILDCARD = '00000000-0000-0000-0000-000000000000'
+
+export function useCanRebirth (targets) {
+  const permissions = ref(new Map())
+
+  watch(targets, async (uuids) => {
+    if (!uuids || uuids.length === 0) return
+
+    const s = useServiceClientStore()
+    const results = new Map()
+
+    // Fetch the full ACL via the Auth service HTTP API.
+    // We call ServiceInterface.fetch directly to avoid the
+    // RxClient notify-based override of fetch_raw_acl.
+    let acl
+    try {
+      const principal = `${s.username}@${s.baseUrl.toUpperCase()}`
+      const [st, json] = await s.client.Auth.fetch(
+        `v2/acl/kerberos/${principal}`
+      )
+      if (st !== 200) throw new Error(`ACL fetch returned ${st}`)
+      acl = json
+    } catch (e) {
+      console.error('Failed to fetch ACL for rebirth check:', e)
+      return
+    }
+
+    for (const uuid of uuids) {
+      const allowed = acl.some(ace =>
+        ace.permission === REBIRTH_PERMISSION
+        && (ace.target === uuid || ace.target === WILDCARD)
+      )
+      results.set(uuid, allowed)
+    }
+
+    permissions.value = results
+  }, { immediate: true })
+
+  return permissions
+}

acs-admin/src/pages/EdgeManager/EdgeClusters/EdgeCluster.vue

@@ -159,9 +159,11 @@
 </template>
 
 <script>
+import { computed } from 'vue'
 import { useServiceClientStore } from '@store/serviceClientStore.js'
 import { useEdgeClusterStore } from '@store/useEdgeClusterStore.js'
 import { useNodeStore } from '@store/useNodeStore.js'
+import { useCanRebirth } from '@/composables/useCanRebirth.js'
 import { UUIDs } from '@amrc-factoryplus/service-client'
 import EdgeContainer from '@components/Containers/EdgeContainer.vue'
 import EdgePageSkeleton from '@components/EdgeManager/EdgePageSkeleton.vue'
@@ -213,10 +215,15 @@ export default {
   },
 
   setup () {
+    const n = useNodeStore()
+    const nodeUuids = computed(() => n.data?.map(e => e.uuid) ?? [])
+    const canRebirthMap = useCanRebirth(nodeUuids)
+
     return {
       e: useEdgeClusterStore(),
       dp: useDeploymentStore(),
-      n: useNodeStore(),
+      n,
+      canRebirthMap,
       hostColumns,
       nodeColumns,
       deploymentColumns,
@@ -234,7 +241,11 @@ export default {
     },
 
     nodes () {
-      return Array.isArray(this.n.data) ? this.n.data.filter(e => e.deployment?.cluster === this.cluster.uuid) : []
+      const filtered = Array.isArray(this.n.data) ? this.n.data.filter(e => e.deployment?.cluster === this.cluster.uuid) : []
+      return filtered.map(n => ({
+        ...n,
+        _canRebirth: this.canRebirthMap?.get(n.uuid) ?? false
+      }))
     },
 
     deployments () {

acs-admin/src/pages/EdgeManager/EdgeClusters/nodeColumns.ts

@@ -6,6 +6,7 @@ import type {ColumnDef} from '@tanstack/vue-table'
 import {h} from 'vue'
 
 import DataTableColumnHeader from '@/components/ui/data-table/DataTableColumnHeader.vue'
+import RebirthButton from '@/components/EdgeManager/RebirthButton.vue'
 
 export interface Host {
     uuid: string,
@@ -52,5 +53,22 @@ export const nodeColumns: ColumnDef<Host>[] = [
         filterFn: (row, id, value) => {
             return value.includes(row.getValue(id))
         },
+    },
+    {
+        id: 'actions',
+        header: () => null,
+        cell: ({row}) => {
+            const addr = row.original.sparkplugAddress
+            if (!addr) return null
+            const addressStr = `${addr.group_id}/${addr.node_id}`
+            return h(RebirthButton, {
+                address: addressStr,
+                name: row.original.name,
+                canRebirth: row.original._canRebirth ?? false,
+                class: 'ml-auto'
+            })
+        },
+        enableSorting: false,
+        enableHiding: false,
     }
 ]

acs-admin/src/pages/EdgeManager/Nodes/Node.vue

@@ -129,10 +129,12 @@
 </template>
 
 <script>
+import { computed } from 'vue'
 import { useNodeStore } from '@store/useNodeStore.js'
 import { useEdgeClusterStore } from '@store/useEdgeClusterStore.js'
 import { useDeviceStore } from '@store/useDeviceStore.js'
 import { useConnectionStore } from '@store/useConnectionStore.js'
+import { useCanRebirth } from '@/composables/useCanRebirth.js'
 import EdgeContainer from '@components/Containers/EdgeContainer.vue'
 import { Label } from '@components/ui/label/index.js'
 import { Input } from '@components/ui/input/index.js'
@@ -176,11 +178,16 @@ export default {
   },
 
   setup () {
+    const d = useDeviceStore()
+    const deviceUuids = computed(() => d.data?.map(e => e.uuid) ?? [])
+    const canRebirthMap = useCanRebirth(deviceUuids)
+
     return {
       c: useEdgeClusterStore(),
       n: useNodeStore(),
-      d: useDeviceStore(),
+      d,
       cn: useConnectionStore(),
+      canRebirthMap,
       inop,
       deviceColumns,
       connectionColumns,
@@ -206,7 +213,12 @@ export default {
     },
 
     devices () {
-      return Array.isArray(this.d.data) ? this.d.data.filter(e => e.deviceInformation?.node === this.node.uuid) : []
+      const filtered = Array.isArray(this.d.data) ? this.d.data.filter(e => e.deviceInformation?.node === this.node.uuid) : []
+      return filtered.map(d => ({
+        ...d,
+        _nodeAddress: this.node.sparkplugAddress,
+        _canRebirth: this.canRebirthMap?.get(d.uuid) ?? false
+      }))
     },
 
     connections () {

acs-admin/src/pages/EdgeManager/Nodes/deviceColumns.ts

@@ -6,6 +6,7 @@ import type {ColumnDef} from '@tanstack/vue-table'
 import {h} from 'vue'
 
 import DataTableColumnHeader from '@/components/ui/data-table/DataTableColumnHeader.vue'
+import RebirthButton from '@/components/EdgeManager/RebirthButton.vue'
 
 export interface Device {
     uuid: string,
@@ -31,6 +32,24 @@ export const deviceColumns: ColumnDef<Device>[] = [
         filterFn: (row, id, value) => {
             return value.includes(row.getValue(id))
         },
+    },
+    {
+        id: 'actions',
+        header: () => null,
+        cell: ({row}) => {
+            const addr = row.original._nodeAddress
+            const sparkplugName = row.original.deviceInformation?.sparkplugName
+            if (!addr || !sparkplugName) return null
+            const addressStr = `${addr.group_id}/${addr.node_id}/${sparkplugName}`
+            return h(RebirthButton, {
+                address: addressStr,
+                name: row.original.name,
+                isDevice: true,
+                canRebirth: row.original._canRebirth ?? false,
+            })
+        },
+        enableSorting: false,
+        enableHiding: false,
     }
     // {
     //     accessorKey: 'schema',

acs-admin/src/store/useNodeStore.js

@@ -6,5 +6,6 @@ import { useStore } from '@store/useStore.ts'
 import { UUIDs } from '@amrc-factoryplus/service-client'
 
 export const useNodeStore = useStore('node', UUIDs.Class.EdgeAgent, {
-  deployment: UUIDs.App.EdgeAgentDeployment
+  deployment: UUIDs.App.EdgeAgentDeployment,
+  sparkplugAddress: UUIDs.App.SparkplugAddress
 })

docs/plans/2026-04-09-rebirth-button-design.md

@@ -0,0 +1,102 @@
+# Rebirth Button in Admin UI
+
+Date: 2026-04-09
+Author: Alex Godbehere
+
+## Problem
+
+There is no way to trigger a Sparkplug Rebirth (NBIRTH/DBIRTH) from the
+Admin UI. When edge agents get stuck (e.g. after a ConfigDB migration
+changes device UUIDs), the only option is to manually restart pods or
+use kubectl. A Rebirth button in the UI would let operators force a
+re-publish of the birth certificate without restarting the agent.
+
+## Solution
+
+Add a per-row "Rebirth" button to the Node list and Device list views
+in the Edge Manager. The button is only shown if the current user has
+the Rebirth CCL permission on that specific node/device.
+
+### Key UUIDs
+
+- **Rebirth CCL permission**: `fbb9c25d-386d-4966-a325-f16471d9f7be`
+- **Command Definition app**: `60e99f28-67fe-4344-a6ab-b1edb8b8e810`
+- **CmdEsc permission set group**: `9584ee09-a35a-4278-bc13-21a8be1f007c`
+
+### How Rebirth works
+
+The `CmdEsc.rebirth(address)` method in `lib/js-service-client/lib/service/cmdesc.js`
+sends a Sparkplug NCMD/DCMD via the Command Escalation service:
+
+- For nodes: `Node Control/Rebirth` (Boolean, true)
+- For devices: `Device Control/Rebirth` (Boolean, true)
+
+The CmdEsc service validates the user's ACL before forwarding the
+command. The edge agent handles the NCMD at
+`acs-edge/lib/sparkplugNode.ts:339-341` and re-publishes its birth
+certificate.
+
+### Changes
+
+#### 1. Node store  - add Sparkplug address
+
+**File:** `acs-admin/src/store/useNodeStore.js`
+
+Add `sparkplugAddress: UUIDs.App.SparkplugAddress` to the loaded
+configs. The device store already loads this; the node store does not.
+
+#### 2. ACL check composable
+
+**File:** `acs-admin/src/composables/useCanRebirth.js` (new)
+
+A Vue composable that, given a list of node/device UUIDs, checks
+whether the current user has the Rebirth permission
+(`fbb9c25d-386d-4966-a325-f16471d9f7be`) on each target via
+`client.Auth.check_acl()`.
+
+Returns a reactive `Map<uuid, boolean>` so the template can look up
+each row.
+
+The current user's principal is resolved from `serviceClientStore.username`
+(a Kerberos principal name) which `Auth.fetch_acl()` accepts directly.
+
+Calls are made per target UUID. Results are cached for the lifetime of
+the composable.
+
+#### 3. Node list  - Rebirth column
+
+**File:** `acs-admin/src/pages/EdgeManager/EdgeClusters/EdgeCluster.vue`
+**File:** `acs-admin/src/pages/EdgeManager/EdgeClusters/nodeColumns.ts`
+
+Add a new column to the node DataTable with a Rebirth button per row.
+The column uses a custom cell renderer (Vue `h()` function or inline
+component) that:
+
+- Checks `canRebirth.get(row.original.uuid)` to show/hide the button
+- On click, calls `client.CmdEsc.rebirth(address)` where `address` is
+  built from the node's `sparkplugAddress` config
+- Shows a loading spinner on the button while the request is in flight
+- Shows a success toast on completion, error toast on failure
+
+#### 4. Device list  - Rebirth column
+
+**File:** `acs-admin/src/pages/EdgeManager/Nodes/Node.vue`
+**File:** `acs-admin/src/pages/EdgeManager/Nodes/deviceColumns.ts`
+
+Same pattern as the node list. The device's Sparkplug address is already
+available in the device store.
+
+### UX
+
+- Button style: small ghost/secondary button with a refresh icon
+- Loading: spinner replaces the icon while the request is in flight
+- Success: toast "Rebirth sent to {name}"
+- Error (403): toast "Permission denied: cannot rebirth {name}"
+- Error (other): toast "Failed to rebirth {name}"
+- Button hidden entirely if user lacks permission on that target
+
+### What this doesn't change
+
+- No backend changes  - CmdEsc and the edge agent already support Rebirth
+- No new permissions  - the Rebirth CCL already exists
+- No changes to the Sparkplug protocol handling