bee/audit/internal/webui/raid_actions.go

package webui

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"os/exec"
	"strconv"
	"strings"
	"time"
)

func (h *handler) handleAPIRAIDStatus(w http.ResponseWriter, r *http.Request) {
	resp := raidStatusResp{Controllers: []raidControllerInfo{}}

	lsi2 := detectStorcli2Controllers()
	if lsi := detectLSIControllers(); len(lsi) > 0 {
		// storcli64 can enumerate a Tri-Mode controller (SAS3808-iMR/9500
		// series) at a basic level but its drive-listing JSON parser finds
		// no "Drive Information" for these — a zero-drives entry that
		// storcli2 (run above) already covers correctly. Only drop it when
		// storcli2 actually found something, so a genuinely drive-populated
		// classic controller elsewhere in a mixed setup is never hidden.
		for _, c := range lsi {
			if len(c.AllDrives) == 0 && len(lsi2) > 0 {
				continue
			}
			resp.Controllers = append(resp.Controllers, c)
		}
	}
	if len(lsi2) > 0 {
		resp.Controllers = append(resp.Controllers, lsi2...)
	}
	if vroc := detectVROCController(); vroc != nil {
		resp.Controllers = append(resp.Controllers, *vroc)
	}

	writeJSON(w, resp)
}

func (h *handler) handleAPIRAIDForeignAction(w http.ResponseWriter, r *http.Request) {
	var req struct {
		ControllerID string `json:"controller_id"`
		Action       string `json:"action"`
	}
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid JSON")
		return
	}
	if req.Action != "import" && req.Action != "clear" {
		writeError(w, http.StatusBadRequest, "action must be 'import' or 'clear'")
		return
	}
	ctrlIdx, ok := parseLSIControllerIndex(req.ControllerID)
	if !ok {
		writeError(w, http.StatusBadRequest, "invalid controller_id")
		return
	}

	target := "raid-foreign-clear"
	name := fmt.Sprintf("RAID Foreign Clear (ctrl %d)", ctrlIdx)
	if req.Action == "import" {
		target = "raid-foreign-import"
		name = fmt.Sprintf("RAID Foreign Import (ctrl %d)", ctrlIdx)
	}

	t := &Task{
		ID:        newJobID(target),
		Name:      name,
		Target:    target,
		Priority:  defaultTaskPriority(target, taskParams{}),
		Status:    TaskPending,
		CreatedAt: time.Now(),
		params:    taskParams{RAIDController: ctrlIdx},
	}
	globalQueue.enqueue(t)
	writeJSON(w, map[string]string{"task_id": t.ID})
}

func (h *handler) handleAPIRAIDCreateMirror(w http.ResponseWriter, r *http.Request) {
	var req struct {
		ControllerID string   `json:"controller_id"`
		Devices      []string `json:"devices"`
		ArrayName    string   `json:"array_name"`
	}
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid JSON")
		return
	}
	if len(req.Devices) < 2 {
		writeError(w, http.StatusBadRequest, "at least 2 devices required")
		return
	}

	var target, name string
	var params taskParams

	switch {
	case strings.HasPrefix(req.ControllerID, "lsi-"):
		ctrlIdx, ok := parseLSIControllerIndex(req.ControllerID)
		if !ok {
			writeError(w, http.StatusBadRequest, "invalid controller_id")
			return
		}
		target = "raid-lsi-create-mirror"
		name = fmt.Sprintf("Create RAID 1 Mirror (LSI ctrl %d)", ctrlIdx)
		params = taskParams{RAIDController: ctrlIdx, RAIDDevices: req.Devices}

	case req.ControllerID == "vroc-0":
		arrayName := strings.TrimSpace(req.ArrayName)
		if arrayName == "" {
			arrayName = "bee-mirror0"
		}
		target = "raid-vroc-create-mirror"
		name = fmt.Sprintf("Create VROC RAID 1 (%s)", arrayName)
		params = taskParams{RAIDDevices: req.Devices, RAIDArrayName: arrayName}

	default:
		writeError(w, http.StatusBadRequest, "unknown controller_id")
		return
	}

	t := &Task{
		ID:        newJobID(target),
		Name:      name,
		Target:    target,
		Priority:  defaultTaskPriority(target, taskParams{}),
		Status:    TaskPending,
		CreatedAt: time.Now(),
		params:    params,
	}
	globalQueue.enqueue(t)
	writeJSON(w, map[string]string{"task_id": t.ID})
}

func (h *handler) handleAPIRAIDPrepareDrive(w http.ResponseWriter, r *http.Request) {
	var req struct {
		ControllerID string `json:"controller_id"`
		Slot         string `json:"slot"`
	}
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid JSON")
		return
	}
	ctrlIdx, ok := parseLSIControllerIndex(req.ControllerID)
	if !ok {
		writeError(w, http.StatusBadRequest, "invalid controller_id")
		return
	}
	if _, _, ok := parseRAIDSlot(req.Slot); !ok {
		writeError(w, http.StatusBadRequest, "invalid slot")
		return
	}

	t := &Task{
		ID:        newJobID("raid-lsi-prepare-drive"),
		Name:      fmt.Sprintf("Prepare drive %s (LSI ctrl %d)", req.Slot, ctrlIdx),
		Target:    "raid-lsi-prepare-drive",
		Priority:  defaultTaskPriority("raid-lsi-prepare-drive", taskParams{}),
		Status:    TaskPending,
		CreatedAt: time.Now(),
		params:    taskParams{RAIDController: ctrlIdx, RAIDSlot: req.Slot},
	}
	globalQueue.enqueue(t)
	writeJSON(w, map[string]string{"task_id": t.ID})
}

func parseLSIControllerIndex(id string) (int, bool) {
	if !strings.HasPrefix(id, "lsi-") {
		return 0, false
	}
	n, err := strconv.Atoi(strings.TrimPrefix(id, "lsi-"))
	if err != nil || n < 0 {
		return 0, false
	}
	return n, true
}

// --- Task runner functions ---

func runRAIDForeignClearTask(ctx context.Context, j *jobState, ctrl int) error {
	j.append(fmt.Sprintf("Clearing foreign configuration on controller %d...", ctrl))
	cmd := exec.CommandContext(ctx, "storcli64", fmt.Sprintf("/c%d/fall", ctrl), "del", "noprompt")
	return streamCmdJob(j, cmd)
}

func runRAIDForeignImportTask(ctx context.Context, j *jobState, ctrl int) error {
	j.append(fmt.Sprintf("Importing foreign configuration on controller %d...", ctrl))
	cmd := exec.CommandContext(ctx, "storcli64", fmt.Sprintf("/c%d/fall", ctrl), "import", "noprompt")
	return streamCmdJob(j, cmd)
}

// raidPrepareAction says what (if anything) must be done to a drive in the
// given storcli state before it can join a new VD. Derived from the Broadcom
// StorCLI drive-state matrix: only UGood drives are accepted by "add vd";
// JBOD/UBad convert with "set good force"; hotspares must be released first;
// Frgn/Onln hold configuration data and must not be silently destroyed.
type raidPrepareAction int

const (
	raidPrepNone     raidPrepareAction = iota // UGood or unknown — try add vd as-is
	raidPrepSetGood                           // JBOD, UBad — "set good force"
	raidPrepHotspare                          // GHS, DHS — "delete hotsparedrive", then set good
	raidPrepBlockedFrgn
	raidPrepBlockedOnln
)

func classifyRAIDPrepareAction(state string) raidPrepareAction {
	switch strings.TrimSpace(state) {
	case "JBOD", "UBad":
		return raidPrepSetGood
	case "GHS", "DHS":
		return raidPrepHotspare
	case "Frgn":
		return raidPrepBlockedFrgn
	case "Onln", "Offln":
		return raidPrepBlockedOnln
	default: // "UGood", "" (state unknown — let add vd decide)
		return raidPrepNone
	}
}

// raidLSIDriveStates returns EID:Slt -> State for one controller, or nil if
// storcli/parsing fails (callers then fall back to unconditional prepare).
func raidLSIDriveStates(ctx context.Context, ctrl int) map[string]string {
	out, err := exec.CommandContext(ctx, "storcli64",
		fmt.Sprintf("/c%d/eall/sall", ctrl), "show", "all", "J").Output()
	if err != nil {
		return nil
	}
	var doc struct {
		Controllers []struct {
			ResponseData map[string]json.RawMessage `json:"Response Data"`
		} `json:"Controllers"`
	}
	if err := json.Unmarshal(out, &doc); err != nil || len(doc.Controllers) == 0 {
		return nil
	}
	states := map[string]string{}
	for _, c := range doc.Controllers {
		for _, d := range parseStorcliResponseDataDrives(c.ResponseData) {
			states[strings.TrimSpace(d.EIDSlt)] = strings.TrimSpace(d.State)
		}
	}
	return states
}

func runRAIDLSICreateMirrorTask(ctx context.Context, j *jobState, ctrl int, drives []string) error {
	driveList := strings.Join(drives, ",")
	states := raidLSIDriveStates(ctx, ctrl)

	// Non-UGood drives cannot be added to a VD directly — storcli fails with
	// "resources already in use" (exit 11) or similar. Fix what is safely
	// fixable (JBOD/UBad/hotspare), refuse what holds data (Frgn/Onln).
	for _, drive := range drives {
		eid, slt, ok := parseRAIDSlot(drive)
		if !ok {
			return fmt.Errorf("invalid drive slot %q", drive)
		}
		state := states[drive]
		slotPath := fmt.Sprintf("/c%d/e%d/s%d", ctrl, eid, slt)

		switch classifyRAIDPrepareAction(state) {
		case raidPrepBlockedFrgn:
			return fmt.Errorf("drive %s carries a foreign configuration; run the RAID Foreign Clear (or Import) task first, then retry", drive)
		case raidPrepBlockedOnln:
			return fmt.Errorf("drive %s is part of an existing virtual drive (state %s); delete that VD first", drive, state)
		case raidPrepHotspare:
			j.append(fmt.Sprintf("Drive %s is a hotspare (%s); releasing it...", drive, state))
			rel := exec.CommandContext(ctx, "storcli64", slotPath, "delete", "hotsparedrive")
			if err := streamCmdJob(j, rel); err != nil {
				return fmt.Errorf("release hotspare %s: %w", drive, err)
			}
		case raidPrepSetGood:
			j.append(fmt.Sprintf("Drive %s is %s; converting to Unconfigured Good (set good force)...", drive, state))
			prep := exec.CommandContext(ctx, "storcli64", slotPath, "set", "good", "force")
			if err := streamCmdJob(j, prep); err != nil {
				return fmt.Errorf("set good on %s: %w", drive, err)
			}
		case raidPrepNone:
			if state == "" {
				// Drive state unknown (storcli query failed) — attempt the
				// conversion anyway; harmless on an already-UGood drive with
				// force, and add vd below is the real verdict.
				j.append(fmt.Sprintf("Preparing drive %s (set good, force)...", drive))
				prep := exec.CommandContext(ctx, "storcli64", slotPath, "set", "good", "force")
				if err := streamCmdJob(j, prep); err != nil {
					j.append(fmt.Sprintf("note: set good on %s: %v (continuing)", drive, err))
				}
			}
		}
	}

	j.append(fmt.Sprintf("Creating RAID 1 on controller %d with drives: %s", ctrl, driveList))
	cmd := exec.CommandContext(ctx, "storcli64",
		fmt.Sprintf("/c%d", ctrl),
		"add", "vd", "type=raid1",
		fmt.Sprintf("drives=%s", driveList),
		"pdperarray=2",
	)
	if err := streamCmdJob(j, cmd); err != nil {
		// A blocked add vd is often preserved cache from a dead VD
		// ("controller has data in cache for offline or missing virtual
		// drives"). Surface it so the log is actionable.
		j.append("add vd failed; checking for preserved cache...")
		pc := exec.CommandContext(ctx, "storcli64", fmt.Sprintf("/c%d", ctrl), "show", "preservedcache")
		_ = streamCmdJob(j, pc)
		j.append(fmt.Sprintf("hint: if preserved cache is listed above, clear it with: storcli64 /c%d/vall delete preservedcache (invalidates cached data of dead VDs), then retry", ctrl))
		return err
	}
	return nil
}

// parseRAIDSlot splits a storcli "EID:Slt" identifier (e.g. "252:0") into
// enclosure and slot numbers.
func parseRAIDSlot(slot string) (eid int, slt int, ok bool) {
	parts := strings.SplitN(strings.TrimSpace(slot), ":", 2)
	if len(parts) != 2 {
		return 0, 0, false
	}
	eid, err1 := strconv.Atoi(strings.TrimSpace(parts[0]))
	slt, err2 := strconv.Atoi(strings.TrimSpace(parts[1]))
	if err1 != nil || err2 != nil {
		return 0, 0, false
	}
	return eid, slt, true
}

func runRAIDPrepareDriveTask(ctx context.Context, j *jobState, ctrl int, slot string) error {
	eid, slt, ok := parseRAIDSlot(slot)
	if !ok {
		return fmt.Errorf("invalid slot %q", slot)
	}
	j.append(fmt.Sprintf("Preparing drive %s on controller %d (set good, force)...", slot, ctrl))
	cmd := exec.CommandContext(ctx, "storcli64",
		fmt.Sprintf("/c%d/e%d/s%d", ctrl, eid, slt),
		"set", "good", "force",
	)
	return streamCmdJob(j, cmd)
}

func runRAIDVROCCreateMirrorTask(ctx context.Context, j *jobState, devices []string, arrayName string) error {
	if arrayName == "" {
		arrayName = "bee-mirror0"
	}
	devPath := "/dev/md/" + arrayName
	args := []string{
		"--create", devPath,
		"--level=1",
		fmt.Sprintf("--raid-devices=%d", len(devices)),
		"--run",
	}
	args = append(args, devices...)
	j.append(fmt.Sprintf("Creating VROC RAID 1 array %s with: %s", devPath, strings.Join(devices, " ")))
	cmd := exec.CommandContext(ctx, "mdadm", args...)
	return streamCmdJob(j, cmd)
}

// raidParseHumanSizeGB parses storcli size strings like "1.818 TB", "745.211 GB".
func raidParseHumanSizeGB(s string) float64 {
	s = strings.TrimSpace(s)
	if s == "" {
		return 0
	}
	upper := strings.ToUpper(s)
	var mul float64
	var numStr string
	switch {
	case strings.Contains(upper, " TB"):
		mul = 1024
		numStr = strings.TrimSpace(strings.SplitN(upper, " T", 2)[0])
	case strings.Contains(upper, " GB"):
		mul = 1
		numStr = strings.TrimSpace(strings.SplitN(upper, " G", 2)[0])
	case strings.Contains(upper, " MB"):
		mul = 1.0 / 1024
		numStr = strings.TrimSpace(strings.SplitN(upper, " M", 2)[0])
	default:
		return 0
	}
	v, err := strconv.ParseFloat(numStr, 64)
	if err != nil {
		return 0
	}
	return v * mul
}

// --- UI card ---

func renderRAIDMgmtCard() string {
	return `<div class="card"><div class="card-head card-head-actions">RAID Controller Management<div class="card-head-buttons"><button class="btn btn-sm btn-secondary" onclick="raidLoad()">&#8635; Refresh</button></div></div><div class="card-body">
<div id="raid-status" style="font-size:13px;color:var(--muted);margin-bottom:8px">Loading...</div>
<div id="raid-content"></div>
<div id="raid-out-wrap" style="display:none;margin-top:14px">
  <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:4px">
    <span id="raid-out-label" style="font-size:12px;font-weight:600;color:var(--muted)">Output</span>
    <span id="raid-out-status" style="font-size:12px"></span>
  </div>
  <div id="raid-terminal" class="terminal" style="max-height:260px;width:100%;box-sizing:border-box"></div>
</div>
</div></div>
<script>
(function(){
function escHtml(s) {
  return String(s||'').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
}

var _raidControllers = [];

function raidLoad() {
  var status = document.getElementById('raid-status');
  var content = document.getElementById('raid-content');
  status.textContent = 'Detecting RAID controllers...';
  status.style.color = 'var(--muted)';
  content.innerHTML = '';
  fetch('/api/tools/raid/status', {cache:'no-store'})
    .then(function(r) {
      if (!r.ok) return r.json().then(function(e) { throw new Error(e.error || r.statusText); });
      return r.json();
    })
    .then(function(data) {
      _raidControllers = data.controllers || [];
      if (_raidControllers.length === 0) {
        status.textContent = 'No RAID controllers detected.';
        return;
      }
      status.textContent = _raidControllers.length + ' controller(s) detected.';
      content.innerHTML = _raidControllers.map(function(c, i) {
        return raidRenderController(c, i);
      }).join('<hr style="margin:16px 0;border:none;border-top:1px solid var(--border)">');
    })
    .catch(function(e) {
      status.textContent = 'Error: ' + e.message;
      status.style.color = 'var(--crit-fg)';
    });
}

function raidRenderController(c, idx) {
  var html = '';
  var typeLabel = c.type === 'lsi' ? 'LSI / Broadcom' : 'Intel VROC';
  html += '<div style="font-weight:600;font-size:13px;margin-bottom:10px">' + typeLabel + ' &mdash; ' + escHtml(c.model) + '</div>';

  if (c.type === 'lsi') {
    var foreign = c.foreign_drives || [];
    if (foreign.length > 0) {
      html += '<div style="background:var(--warn-bg,rgba(240,192,0,0.1));border:1px solid var(--warn-border,#c8a800);border-radius:4px;padding:10px 12px;margin-bottom:12px">';
      html += '<div style="font-weight:600;font-size:13px;margin-bottom:6px">&#9888;&#xFE0E; Foreign Configuration Detected (' + foreign.length + ' drive(s))</div>';
      html += '<table style="margin-bottom:10px"><tr><th>Slot</th><th>Model</th><th>Size</th><th>State</th></tr>';
      foreign.forEach(function(d) {
        html += '<tr>'
          + '<td style="font-family:monospace">' + escHtml(d.slot) + '</td>'
          + '<td>' + escHtml(d.model||'—') + '</td>'
          + '<td>' + (d.size_gb > 0 ? Math.round(d.size_gb) + ' GB' : '—') + '</td>'
          + '<td><span class="badge badge-warn">' + escHtml(d.state) + '</span></td>'
          + '</tr>';
      });
      html += '</table>';
      html += '<div style="display:flex;gap:8px;flex-wrap:wrap">';
      html += '<button class="btn btn-sm btn-primary" onclick="raidForeignAction(\'' + escHtml(c.id) + '\',\'import\',this)">Import Foreign Config</button>';
      html += '<button class="btn btn-sm btn-secondary" style="color:var(--crit-fg)" onclick="raidForeignAction(\'' + escHtml(c.id) + '\',\'clear\',this)">Clear Foreign Config</button>';
      html += '</div></div>';
    }

    html += raidRenderAllDrives(c, idx);
    html += raidRenderMirrorSection(c, idx, 'lsi');
  }

  if (c.type === 'vroc') {
    var arrays = c.arrays || [];
    if (arrays.length > 0) {
      html += '<div style="font-size:12px;font-weight:600;color:var(--muted);margin-bottom:6px;text-transform:uppercase;letter-spacing:.04em">Active Arrays</div>';
      html += '<table style="margin-bottom:14px"><tr><th>Name</th><th>Level</th><th>Members</th><th>Status</th></tr>';
      arrays.forEach(function(a) {
        var badge = a.degraded
          ? '<span class="badge badge-err">Degraded</span>'
          : '<span class="badge badge-ok">OK</span>';
        html += '<tr>'
          + '<td style="font-family:monospace">' + escHtml(a.name) + '</td>'
          + '<td>' + escHtml(a.level||'—') + '</td>'
          + '<td style="font-family:monospace;font-size:12px">' + (a.members||[]).map(escHtml).join(', ') + '</td>'
          + '<td>' + badge + '</td>'
          + '</tr>';
      });
      html += '</table>';
    }

    html += raidRenderAllDrives(c, idx);
    html += raidRenderMirrorSection(c, idx, 'vroc');
  }

  return html;
}

var RAID_READY_STATES = {'UGood': true, 'JBOD': true, 'available': true};
var RAID_NO_PREPARE_STATES = {'UGood': true, 'JBOD': true, 'Frgn': true, 'Onln': true, 'Msng': true};

function raidRenderAllDrives(c, idx) {
  var drives = c.all_drives || [];
  var isLSI = c.type === 'lsi';
  if (drives.length === 0) {
    return '<p style="font-size:13px;color:var(--muted);margin-bottom:12px">No drives detected on this controller.</p>';
  }
  var html = '<div style="font-size:12px;font-weight:600;color:var(--muted);margin-bottom:6px;text-transform:uppercase;letter-spacing:.04em">All Drives on This Controller</div>';
  html += '<table style="margin-bottom:14px"><tr><th>' + (isLSI ? 'Slot' : 'Device') + '</th><th>Model</th><th>Size</th><th>State</th>' + (isLSI ? '<th></th>' : '') + '</tr>';
  drives.forEach(function(d) {
    var ready = !!RAID_READY_STATES[d.state];
    var badgeClass = ready ? 'badge-ok' : 'badge-warn';
    var actionCell = '';
    if (isLSI && !RAID_NO_PREPARE_STATES[d.state]) {
      actionCell = '<td><button class="btn btn-sm btn-secondary" onclick="raidPrepareDrive(\'' + escHtml(c.id) + '\',\'' + escHtml(d.slot) + '\',this)">Prepare</button></td>';
    } else if (isLSI) {
      actionCell = '<td></td>';
    }
    html += '<tr>'
      + '<td style="font-family:monospace">' + escHtml(isLSI ? d.slot : d.device) + '</td>'
      + '<td>' + escHtml(d.model||'—') + (d.serial ? ' [' + escHtml(d.serial) + ']' : '') + '</td>'
      + '<td>' + (d.size_gb > 0 ? Math.round(d.size_gb) + ' GB' : '—') + '</td>'
      + '<td><span class="badge ' + badgeClass + '">' + escHtml(d.state||'—') + '</span></td>'
      + actionCell
      + '</tr>';
  });
  html += '</table>';
  return html;
}

function raidPrepareDrive(ctrlID, slot, btn) {
  if (!confirm('Prepare drive ' + slot + ' on ' + ctrlID + ' for array creation?\n\nThis forces the drive into Unconfigured Good state. If it currently belongs to a virtual drive or holds data, that data will become inaccessible.')) {
    return;
  }
  var original = btn ? btn.textContent : '';
  if (btn) { btn.disabled = true; btn.textContent = 'Preparing...'; }
  raidShowOutput('Prepare drive ' + slot, '', '');
  fetch('/api/tools/raid/prepare-drive', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({controller_id: ctrlID, slot: slot})
  })
    .then(function(r) { return r.json(); })
    .then(function(d) {
      if (d.error) throw new Error(d.error);
      raidStreamTask(d.task_id, 'Prepare drive ' + slot, function() {
        if (btn) { btn.disabled = false; btn.textContent = original; }
        raidLoad();
      });
    })
    .catch(function(e) {
      raidShowOutput('Error', 'failed', e.message);
      if (btn) { btn.disabled = false; btn.textContent = original; }
    });
}

function raidRenderMirrorSection(c, idx, kind) {
  var free = c.free_drives || [];
  var html = '<div style="font-size:12px;font-weight:600;color:var(--muted);margin-bottom:6px;text-transform:uppercase;letter-spacing:.04em">Create RAID 1 Mirror</div>';

  if (free.length < 2) {
    html += '<p style="font-size:13px;color:var(--muted)">No unconfigured drives available (need at least 2).</p>';
    return html;
  }

  html += '<p style="font-size:13px;color:var(--muted);margin-bottom:8px">Select exactly 2 drives:</p>';
  html += '<div>';
  free.forEach(function(d) {
    var val = kind === 'lsi' ? d.slot : d.device;
    var label = kind === 'lsi'
      ? escHtml(d.slot) + (d.model ? ' &mdash; ' + escHtml(d.model) : '') + (d.size_gb > 0 ? ' (' + Math.round(d.size_gb) + ' GB)' : '')
      : escHtml(d.device) + (d.model ? ' &mdash; ' + escHtml(d.model) : '') + (d.serial ? ' [' + escHtml(d.serial) + ']' : '');
    html += '<label style="display:block;margin-bottom:4px;font-size:13px;cursor:pointer">'
      + '<input type="checkbox" class="raid-mirror-check-' + idx + '" value="' + escHtml(val) + '"> '
      + label + '</label>';
  });
  html += '</div>';

  if (kind === 'vroc') {
    html += '<div style="margin-top:10px;display:flex;align-items:center;gap:8px;flex-wrap:wrap">'
      + '<label style="font-size:13px">Array name:&nbsp;<input type="text" id="vroc-arrayname-' + idx + '" value="bee-mirror0" style="font-family:monospace;padding:2px 6px;width:140px"></label>';
  } else {
    html += '<div style="margin-top:10px;display:flex;gap:8px">';
  }

  html += '<button class="btn btn-sm btn-primary raid-mirror-btn-' + idx + '" onclick="raidCreateMirror(\'' + escHtml(c.id) + '\',' + idx + ',\'' + kind + '\',this)">Create Mirror</button>';
  html += '</div>';

  return html;
}

function raidForeignAction(ctrlID, action, btn) {
  if (action === 'clear' && !confirm('Clear foreign configuration on ' + ctrlID + '?\n\nThis will DELETE the foreign RAID metadata. Data on those drives may become inaccessible.')) {
    return;
  }
  var original = btn ? btn.textContent : '';
  if (btn) { btn.disabled = true; btn.textContent = action === 'import' ? 'Importing...' : 'Clearing...'; }
  raidShowOutput('RAID foreign ' + action, '', '');
  fetch('/api/tools/raid/foreign', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({controller_id: ctrlID, action: action})
  })
    .then(function(r) { return r.json(); })
    .then(function(d) {
      if (d.error) throw new Error(d.error);
      var actionLabel = action === 'import' ? 'Import foreign config' : 'Clear foreign config';
      raidStreamTask(d.task_id, actionLabel, function() {
        if (btn) { btn.disabled = false; btn.textContent = original; }
        raidLoad();
      });
    })
    .catch(function(e) {
      raidShowOutput('Error', 'failed', e.message);
      if (btn) { btn.disabled = false; btn.textContent = original; }
    });
}

function raidCreateMirror(ctrlID, idx, kind, btn) {
  var checks = document.querySelectorAll('.raid-mirror-check-' + idx + ':checked');
  if (checks.length !== 2) {
    alert('Select exactly 2 drives.');
    return;
  }
  var devices = Array.from(checks).map(function(c) { return c.value; });
  var arrayName = '';
  if (kind === 'vroc') {
    var nameEl = document.getElementById('vroc-arrayname-' + idx);
    arrayName = nameEl ? nameEl.value.trim() : 'bee-mirror0';
    if (!arrayName) arrayName = 'bee-mirror0';
  }
  var original = btn ? btn.textContent : '';
  if (btn) { btn.disabled = true; btn.textContent = 'Creating...'; }
  raidShowOutput('Create RAID 1', '', '');
  fetch('/api/tools/raid/create-mirror', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({controller_id: ctrlID, devices: devices, array_name: arrayName})
  })
    .then(function(r) { return r.json(); })
    .then(function(d) {
      if (d.error) throw new Error(d.error);
      raidStreamTask(d.task_id, 'Create RAID 1 mirror', function() {
        if (btn) { btn.disabled = false; btn.textContent = original; }
        raidLoad();
      });
    })
    .catch(function(e) {
      raidShowOutput('Error', 'failed', e.message);
      if (btn) { btn.disabled = false; btn.textContent = original; }
    });
}

function raidShowOutput(label, status, text) {
  var wrap = document.getElementById('raid-out-wrap');
  var labelEl = document.getElementById('raid-out-label');
  var statusEl = document.getElementById('raid-out-status');
  var term = document.getElementById('raid-terminal');
  wrap.style.display = 'block';
  labelEl.textContent = label;
  if (status === 'ok') {
    statusEl.textContent = '✓ done';
    statusEl.style.color = 'var(--ok-fg)';
  } else if (status === 'failed') {
    statusEl.textContent = '✗ failed';
    statusEl.style.color = 'var(--crit-fg)';
  } else {
    statusEl.textContent = status;
    statusEl.style.color = 'var(--muted)';
  }
  if (text !== undefined) {
    term.textContent = text;
    term.scrollTop = term.scrollHeight;
  }
}

function raidStreamTask(taskID, taskName, onDone) {
  var term = document.getElementById('raid-terminal');
  term.textContent = '';
  raidShowOutput(taskName || 'Running…', 'running…', undefined);
  var es = new EventSource('/api/tasks/' + taskID + '/stream');
  es.onmessage = function(e) {
    term.textContent += e.data + '\n';
    term.scrollTop = term.scrollHeight;
  };
  es.addEventListener('done', function(e) {
    es.close();
    if (!e.data) {
      raidShowOutput(taskName, 'ok', undefined);
    } else {
      raidShowOutput(taskName, 'failed', undefined);
      term.textContent += '\nFailed: ' + e.data;
      term.scrollTop = term.scrollHeight;
    }
    if (onDone) onDone();
  });
  es.onerror = function() {
    es.close();
    raidShowOutput(taskName, 'failed', undefined);
    if (onDone) onDone();
  };
}

window.raidLoad = raidLoad;
window.raidForeignAction = raidForeignAction;
window.raidCreateMirror = raidCreateMirror;
window.raidPrepareDrive = raidPrepareDrive;
raidLoad();
})();
</script>`
}