+Schimbările cu impact operațional care elimină nume sau schimbă semantica serviciilor locale se fac prin Work Order (WO), nu prin ștergere directă din UI. WO-ul rămâne în git și trebuie confirmat explicit înainte să modifice registrul.

+

+- `/api/work-orders`

+- `POST /api/work-orders/confirm`

+## Work Orders

+

+`config/work-orders.yaml` păstrează operațiuni care trebuie confirmate înainte să atingă registrul.

+

+În MVP, acțiunea suportată este:

+

+```text

+remove_name(host_id, name)

+```

+

+Confirmarea unui WO:

+

+- cere tastarea exactă a ID-ului WO în interfață

+- elimină numele declarate din `config/hosts.yaml`

+- marchează WO-ul ca `confirmed`

+- regenerează `config/local-hosts.tsv`

+- nu rulează automat sync-ul către resolvere

+

+După confirmare, operatorul verifică schimbarea în git și rulează explicit:

+

+```bash

+./scripts/sync_local_hosts.sh --apply --verify

+```

+

+Primul WO curent este pentru eliminarea numelor locale `pmx.*`/`pbs.*` create istoric pentru vhosturi nginx cu certificate Let's Encrypt. Odată cu CA-ul local, aceste nume nu mai trebuie să existe ca vhosturi separate pentru interfețele Proxmox/PBS.

+

+  config/work-orders.yaml  operațiuni confirmabile/versionate

+- `config/work-orders.yaml` - confirmable operational changes

+Name removals with operational impact go through a Work Order. Confirming a WO updates `hosts.yaml`, marks the WO as confirmed, and regenerates `local-hosts.tsv`; resolver sync remains an explicit operator step.

+

+version: 1

+work_orders:

+  - id: "WO-20260606-001"

+    status: "pending"

+    title: "Remove legacy public-cert local vhost names"

+    reason: "These names were introduced for Let's Encrypt-backed nginx vhosts for local Proxmox/PBS web interfaces. The local CA replaces public certificates for local-only resources."

+    created_at: "2026-06-06T00:00:00Z"

+    actions:

+      - type: "remove_name"

+        host_id: "baobab"

+        name: "pmx.baobab.madagascar.xdev.ro"

+      - type: "remove_name"

+        host_id: "ebony"

+        name: "pmx.ebony.madagascar.xdev.ro"

+      - type: "remove_name"

+        host_id: "tapia"

+        name: "pmx.tapia.madagascar.xdev.ro"

+      - type: "remove_name"

+        host_id: "anjothibe"

+        name: "pbs.anjothibe.madagascar.xdev.ro"

+      - type: "remove_name"

+        host_id: "andrafiabe"

+        name: "pbs.andrafiabe.madagascar.xdev.ro"

+    work_orders => $ENV{HOST_MANAGER_WORK_ORDERS} || "$project_dir/config/work-orders.yaml",

+    } elsif ($arg eq '--work-orders') {

+        $opt{work_orders} = shift @ARGV;

+  HOST_MANAGER_WORK_ORDERS      Defaults to config/work-orders.yaml.

+The nginx vhost keeps registry, CA, work order and download endpoints behind OTP.

+    if ($method eq 'GET' && $path eq '/api/work-orders') {

+        return send_json($client, 200, work_orders_payload(load_work_orders()));

+    }

+        if ($path eq '/api/work-orders/confirm') {

+            my $payload = request_payload(\%headers, $body);

+            return confirm_work_order($client, $payload);

+        }

+sub load_work_orders {

+    return { version => 1, work_orders => [] } unless -f $opt{work_orders};

+    return parse_work_orders_yaml(read_file($opt{work_orders}));

+}

+

+sub save_work_orders {

+    my ($orders) = @_;

+    backup_file($opt{work_orders});

+    write_file($opt{work_orders}, render_work_orders_yaml($orders));

+}

+

+sub work_orders_payload {

+    my ($orders) = @_;

+    my $pending = 0;

+    for my $wo (@{ $orders->{work_orders} || [] }) {

+        $pending++ if ($wo->{status} || 'pending') eq 'pending';

+    }

+    return {

+        version => $orders->{version},

+        work_orders => $orders->{work_orders} || [],

+        counts => {

+            work_orders => scalar @{ $orders->{work_orders} || [] },

+            pending => $pending,

+        },

+    };

+}

+

+sub confirm_work_order {

+    my ($client, $payload) = @_;

+    my $id = clean_scalar($payload->{id} || '');

+    return send_json($client, 400, { error => 'invalid_work_order_id' }) unless $id =~ /\AWO-[A-Za-z0-9_.-]+\z/;

+    return send_json($client, 400, { error => 'confirmation_required' }) unless clean_scalar($payload->{confirm} || '') eq $id;

+

+    my $orders = load_work_orders();

+    my $work_order;

+    for my $wo (@{ $orders->{work_orders} || [] }) {

+        if (($wo->{id} || '') eq $id) {

+            $work_order = $wo;

+            last;

+        }

+    }

+    return send_json($client, 404, { error => 'work_order_not_found' }) unless $work_order;

+    return send_json($client, 409, { error => 'work_order_not_pending' }) unless ($work_order->{status} || 'pending') eq 'pending';

+

+    my $registry = load_registry();

+    my $results = apply_work_order($registry, $work_order);

+    $work_order->{status} = 'confirmed';

+    $work_order->{confirmed_at} = iso_now();

+    $work_order->{result} = scalar(@$results) . ' action(s) applied';

+

+    save_registry($registry);

+    save_work_orders($orders);

+    backup_file($opt{local_hosts_tsv});

+    write_file($opt{local_hosts_tsv}, render_local_hosts_tsv($registry));

+

+    return send_json($client, 200, {

+        ok => json_bool(1),

+        work_order => $work_order,

+        results => $results,

+        local_hosts_tsv => $opt{local_hosts_tsv},

+    });

+}

+

+sub apply_work_order {

+    my ($registry, $work_order) = @_;

+    my @results;

+    for my $action (@{ $work_order->{actions} || [] }) {

+        my $type = $action->{type} || '';

+        if ($type eq 'remove_name') {

+            my $host_id = $action->{host_id} || '';

+            my $name = $action->{name} || '';

+            my $removed = 0;

+            for my $host (@{ $registry->{hosts} || [] }) {

+                next unless ($host->{id} || '') eq $host_id;

+                my @kept = grep { $_ ne $name } @{ $host->{names} || [] };

+                $removed = @kept != @{ $host->{names} || [] };

+                $host->{names} = \@kept;

+                last;

+            }

+            push @results, {

+                type => $type,

+                host_id => $host_id,

+                name => $name,

+                removed => json_bool($removed),

+            };

+        } else {

+            die "Unsupported work order action: $type\n";

+        }

+    }

+    return \@results;

+}

+

+sub parse_work_orders_yaml {

+    my ($text) = @_;

+    my %orders = (

+        version => 1,

+        work_orders => [],

+    );

+    my ($section, $current, $in_actions, $current_action);

+    for my $line (split /\n/, $text) {

+        next if $line =~ /^\s*$/ || $line =~ /^\s*#/;

+        if ($line =~ /^version:\s*(\d+)/) {

+            $orders{version} = int($1);

+        } elsif ($line =~ /^work_orders:\s*$/) {

+            $section = 'work_orders';

+        } elsif (($section || '') eq 'work_orders' && $line =~ /^  - id:\s*(.+)$/) {

+            $current = {

+                id => yaml_unquote($1),

+                status => 'pending',

+                actions => [],

+            };

+            push @{ $orders{work_orders} }, $current;

+            $in_actions = 0;

+            $current_action = undef;

+        } elsif ($current && $line =~ /^    actions:\s*$/) {

+            $in_actions = 1;

+            $current->{actions} ||= [];

+        } elsif ($current && $in_actions && $line =~ /^      - type:\s*(.+)$/) {

+            $current_action = { type => yaml_unquote($1) };

+            push @{ $current->{actions} }, $current_action;

+        } elsif ($current_action && $line =~ /^        ([A-Za-z0-9_]+):\s*(.*)$/) {

+            $current_action->{$1} = yaml_unquote($2);

+        } elsif ($current && $line =~ /^    ([A-Za-z0-9_]+):\s*(.*)$/) {

+            $current->{$1} = yaml_unquote($2);

+            $in_actions = 0;

+            $current_action = undef;

+        }

+    }

+    return \%orders;

+}

+

+sub render_work_orders_yaml {

+    my ($orders) = @_;

+    my $out = "version: " . int($orders->{version} || 1) . "\n";

+    $out .= "work_orders:\n";

+    for my $wo (@{ $orders->{work_orders} || [] }) {

+        $out .= "  - id: " . yq($wo->{id}) . "\n";

+        for my $key (qw(status title reason created_at confirmed_at result)) {

+            next unless exists $wo->{$key} && length($wo->{$key} || '');

+            $out .= "    $key: " . yq($wo->{$key}) . "\n";

+        }

+        $out .= "    actions:\n";

+        for my $action (@{ $wo->{actions} || [] }) {

+            $out .= "      - type: " . yq($action->{type}) . "\n";

+            for my $key (qw(host_id name)) {

+                next unless exists $action->{$key} && length($action->{$key} || '');

+                $out .= "        $key: " . yq($action->{$key}) . "\n";

+            }

+        }

+    }

+    return $out;

+}

+

+    my %reason = (200 => 'OK', 400 => 'Bad Request', 401 => 'Unauthorized', 404 => 'Not Found', 409 => 'Conflict', 500 => 'Internal Server Error', 503 => 'Service Unavailable');

+      <section class="panel">

+        <div class="panel-head">

+          <h2>Work Orders</h2>

+          <div class="stats" id="wo-stats"></div>

+        </div>

+        <div class="problems" id="work-orders"></div>

+      </section>

+

+    let state = { hosts: [], problems: [], workOrders: [], authenticated: false };

+      await renderWorkOrders();

+    async function renderWorkOrders() {

+      try {

+        const data = await api('/api/work-orders');

+        state.workOrders = data.work_orders || [];

+        $('wo-stats').innerHTML = [

+          ['pending', data.counts.pending],

+          ['total', data.counts.work_orders],

+        ].map(([k, v]) => `<span class="stat">${k}: ${escapeHtml(String(v))}</span>`).join('');

+

+        if (!state.workOrders.length) {

+          $('work-orders').innerHTML = '<div class="muted" style="padding: 8px 0">No work orders.</div>';

+          return;

+        }

+

+        $('work-orders').innerHTML = state.workOrders.map(wo => {

+          const actions = (wo.actions || []).map(a => {

+            const target = [a.host_id, a.name].filter(Boolean).join(' ');

+            return `<div><span class="pill">${escapeHtml(a.type || '')}</span> ${escapeHtml(target)}</div>`;

+          }).join('');

+          const statusClass = (wo.status || 'pending') === 'pending' ? 'warn' : 'ok';

+          const button = (wo.status || 'pending') === 'pending'

+            ? `<button type="button" class="primary" data-confirm-wo="${escapeHtml(wo.id)}">Confirm</button>`

+            : '';

+          return `<div class="problem" style="display:grid;gap:8px">

+            <div style="display:flex;align-items:center;justify-content:space-between;gap:12px;flex-wrap:wrap">

+              <div><strong>${escapeHtml(wo.id || '')}</strong> <span class="pill ${statusClass}">${escapeHtml(wo.status || 'pending')}</span></div>

+              ${button}

+            </div>

+            <div>${escapeHtml(wo.title || '')}</div>

+            <div class="muted">${escapeHtml(wo.reason || '')}</div>

+            <div style="display:grid;gap:4px">${actions}</div>

+            ${wo.confirmed_at ? `<div class="muted">confirmed ${escapeHtml(wo.confirmed_at)}</div>` : ''}

+          </div>`;

+        }).join('');

+        document.querySelectorAll('[data-confirm-wo]').forEach(button => button.addEventListener('click', () => confirmWorkOrder(button.dataset.confirmWo)));

+      } catch (e) {

+        $('work-orders').innerHTML = `<div class="problem"><strong>Work orders unavailable</strong> ${escapeHtml(e.message)}</div>`;

+      }

+    }

+

+    async function confirmWorkOrder(id) {

+      const typed = prompt(`Type ${id} to confirm this work order`);

+      if (typed !== id) return;

+      try {

+        await api('/api/work-orders/confirm', {

+          method: 'POST',

+          headers: { 'Content-Type': 'application/json' },

+          body: JSON.stringify({ id, confirm: typed })

+        });

+        msg('work order confirmed; local-hosts.tsv written');

+        await refresh();

+      } catch (e) { msg(e.message); }

+    }

+