You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/web/public/cloud/runtime.js

2423 lines
117 KiB
JavaScript

const assetVersion = new URL(import.meta.url).searchParams.get('v');
function versionedModuleUrl(path) {
const url = new URL(path, import.meta.url);
url.search = '';
if (assetVersion) url.searchParams.set('v', assetVersion);
return url.href;
}
const [toastModule, taskObserver, instanceService] = await Promise.all([
import(versionedModuleUrl('./toast.js')),
import(versionedModuleUrl('./task-observer.js')),
import(versionedModuleUrl('./instance-service.js')),
]);
const { toast } = toastModule;
const { formatServiceDate, servicePaused, serviceTimestamp } = instanceService;
const i18n = globalThis.VenixUserCopy;
const t = (key, parameters = {}) => i18n.text(key, parameters);
const {
announceTaskAccepted, observeTask,
resolvedTaskFailureNotice, taskSucceededWithoutRecovery, taskUrl,
} = taskObserver;
// PHP owns authentication, authorisation, ownership and purchasing. No Agent
// address, token, host credential or unrestricted create API exists in this UI.
const byId = (id) => document.getElementById(id);
const requestUserConfirmation = options => window.VenixDialog?.confirm?.(options) ?? Promise.resolve(false);
const state = { csrfToken: '', userId: '', username: '', admin: false, vms: [], offers: [], regions: [], lines: [], linesEnabled: false, sshKeys: [], templates: [], templateCatalogUnavailable: false, resources: null, selectedRegionId: '', selectedLineId: '', view: 'list', selectedVmId: null, detailTab: 'operations', metricsRange: '24h', metricsPayload: null, metricsRequest: null, metricsPollTimer: null, metricsResizeTimer: null, trafficDailyPayload: null, trafficDailyVmId: '', trafficDailyRequest: null, trafficDailyResizeTimer: null, trafficDailyLoadedAt: 0, credentialPassword: '', credentialVisible: false, credentialTimer: null, reinstallPassword: '', reinstallPasswordDismissed: false, rfb: null, consoleToken: 0, loadingVMs: false, selectedKeys: { create: '', reinstall: '' }, resourceController: null, mutationBusy: false, powerMutation: null, provisionIdempotency: '', provisionFingerprint: '', deployCloudSnapshotKey: '', deployCloudSnapshotName: '', rescueActive: false, rescueStaged: false };
function vmPageText(detailKey, reinstallKey, parameters = {}) {
return t(state.view === 'reinstall' ? reinstallKey : detailKey, parameters);
}
function safeRequestFailure(error) {
const status = Number(error?.status);
return t('common.error.request', { status: Number.isInteger(status) && status > 0 ? status : 0 });
}
let vmStatusRequest = null;
let vmStatusGeneration = 0;
const activeTaskObservers = new Set();
// Keep the historical storage key so an interrupted deployment can still
// reconcile to the same opening invoice.
const PROVISION_INVOICE_STORAGE_PREFIX = 'virt-cloud:pending-order:';
const CLOUD_PATHS = Object.freeze({
instances: '/user/cloud/instances',
deploy: '/user/cloud/deploy',
backups: '/user/cloud/backups',
keys: '/user/cloud/ssh-keys',
invoices: '/user/cloud/invoices',
});
const vmPagePath = (id, child = '') => `${CLOUD_PATHS.instances}/${encodeURIComponent(String(id))}${child ? `/${child}` : ''}`;
const navigate = (path) => location.assign(path);
const text = (id, value) => { byId(id).textContent = value ?? '—'; };
const items = (payload) => Array.isArray(payload) ? payload : Array.isArray(payload?.items) ? payload.items : Array.isArray(payload?.templates) ? payload.templates : Array.isArray(payload?.keys) ? payload.keys : Array.isArray(payload?.vms) ? payload.vms : [];
function readBootstrap(id) {
const source = byId(id);
if (!source) return null;
let payload;
try { payload = JSON.parse(source.textContent || '{}'); }
catch { throw new Error(t('common.error.bootstrap_invalid')); }
if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
throw new Error(t('common.error.bootstrap_missing'));
}
return payload;
}
function bootstrapItems(payload, ...names) {
for (const name of names) if (Array.isArray(payload?.[name])) return payload[name];
return [];
}
function showError(id, message) { text(id, message); byId(id).hidden = !message; }
async function copyText(value) { if (navigator.clipboard?.writeText) { try { await navigator.clipboard.writeText(value); return; } catch {} } const area = document.createElement('textarea'); area.value = value; area.style.position = 'fixed'; area.style.opacity = '0'; document.body.append(area); area.select(); try { if (!document.execCommand('copy')) throw new Error(t('common.error.copy')); } finally { area.value = ''; area.remove(); } }
function requireSecureTransport() { if (location.protocol !== 'https:' && !['localhost', '127.0.0.1', '[::1]'].includes(location.hostname)) throw new Error(t('common.error.secure_transport')); }
async function api(path, options = {}) {
const expectedStatuses = options.expectedStatus === undefined ? null
: (Array.isArray(options.expectedStatus) ? options.expectedStatus : [options.expectedStatus]);
const requireTaskReceipt = options.requireTaskReceipt === true;
const requestOptions = { ...options };
delete requestOptions.expectedStatus;
delete requestOptions.requireTaskReceipt;
const method = (options.method || 'GET').toUpperCase();
const headers = new Headers({ Accept: 'application/json', ...options.headers });
if (!['GET', 'HEAD'].includes(method)) { requireSecureTransport(); headers.set('X-CSRF-Token', state.csrfToken); if (options.body !== undefined) headers.set('Content-Type', 'application/json'); }
const response = await fetch(path, { ...requestOptions, method, headers, credentials: 'same-origin', cache: 'no-store', body: options.body === undefined ? undefined : JSON.stringify(options.body) });
let payload = null;
if (response.status !== 204) { try { payload = await response.json(); } catch { throw new Error(t('common.error.non_json')); } }
if (response.status === 401) { clearCredential(); closeConsole(); location.assign('/auth/login'); throw new Error(t('common.error.login_expired')); }
if (!response.ok || payload?.ret === 0) { const error = new Error(response.status === 422 ? t('common.error.invalid_input') : t('common.error.request', { status: response.status })); error.status = response.status; throw error; }
if (expectedStatuses && !expectedStatuses.includes(response.status)) {
const error = new Error(t('common.error.unexpected_status', { status: response.status }));
error.status = response.status;
error.mutationMayHaveApplied = true;
throw error;
}
if (requireTaskReceipt && !taskUrl(payload)) {
const error = new Error(t('common.error.task_receipt_invalid'));
error.status = response.status;
error.mutationMayHaveApplied = true;
throw error;
}
return payload;
}
function normalizeVm(vm) {
const legacyMutation = vm.can_mutate !== false;
const canOperate = vm.can_operate === undefined ? legacyMutation : vm.can_operate === true;
const canDelete = vm.can_delete === undefined ? legacyMutation : vm.can_delete === true;
const canViewCredential = vm.can_view_credential !== false;
return { ...vm, uuid: String(vm.uuid || vm.id || ''), api_id: String(vm.id || vm.uuid || ''), vcpu: vm.vcpu ?? vm.cpu_cores,
memory_mib: vm.memory_mib, public_network_valid: vm.public_network_valid === true,
public_ipv4: vm.public_network_valid === true ? String(vm.public_ipv4 || '') : '',
public_ipv6: vm.public_network_valid === true ? String(vm.public_ipv6 || '') : '',
can_operate: canOperate, can_delete: canDelete,
can_view_credential: canViewCredential, password_available: canViewCredential
&& (vm.password_available === true || vm.has_initial_root_password === true) };
}
function firstNumber(...values) {
for (const value of values) {
if (value === null || value === undefined || value === '') continue;
const number = Number(value);
if (Number.isFinite(number) && number >= 0) return number;
}
return null;
}
function firstText(...values) {
for (const value of values) {
if (value !== null && value !== undefined && String(value).trim() !== '') return String(value).trim();
}
return '';
}
function vmServiceData(vm) {
const period = vm?.current_period && typeof vm.current_period === 'object' ? vm.current_period
: vm?.service_period && typeof vm.service_period === 'object' ? vm.service_period : {};
const service = vm?.service && typeof vm.service === 'object' ? vm.service : period;
const billing = vm?.billing && typeof vm.billing === 'object' ? vm.billing : {};
const traffic = vm?.traffic && typeof vm.traffic === 'object' ? vm.traffic : (service.traffic && typeof service.traffic === 'object' ? service.traffic : {});
const accountingMode = ['legacy', 'pooled', 'unlimited'].includes(String(vm?.traffic_accounting_mode || ''))
? String(vm.traffic_accounting_mode) : 'legacy';
const pool = vm?.traffic_pool && typeof vm.traffic_pool === 'object' ? vm.traffic_pool : {};
const projectionReady = accountingMode !== 'pooled' || pool.projection_ready === true;
const trafficGib = firstNumber(vm?.traffic_gib, service.traffic_gib, period.traffic_gib, billing.traffic_gib);
const quota = firstNumber(vm?.traffic_quota_bytes, service.traffic_quota_bytes, period.traffic_quota_bytes, billing.traffic_quota_bytes, traffic.quota_bytes,
trafficGib === null ? null : trafficGib * 1024 ** 3);
const rx = firstNumber(vm?.traffic_download_bytes, vm?.traffic_rx_bytes, vm?.download_rx_bytes, vm?.network_rx_total_bytes,
service.traffic_download_bytes, service.traffic_rx_bytes, period.traffic_download_bytes, period.traffic_rx_bytes, traffic.rx_bytes, traffic.download_bytes);
const tx = firstNumber(vm?.traffic_upload_bytes, vm?.traffic_tx_bytes, vm?.upload_tx_bytes, vm?.network_tx_total_bytes,
service.traffic_upload_bytes, service.traffic_tx_bytes, period.traffic_upload_bytes, period.traffic_tx_bytes, traffic.tx_bytes, traffic.upload_bytes);
const used = firstNumber(vm?.traffic_used_bytes, vm?.traffic_total_bytes, service.traffic_used_bytes, period.traffic_used_bytes, traffic.used_bytes, traffic.total_bytes,
rx !== null && tx !== null ? rx + tx : null);
const remaining = firstNumber(vm?.traffic_remaining_bytes, service.traffic_remaining_bytes, period.traffic_remaining_bytes, traffic.remaining_bytes,
quota !== null && used !== null ? Math.max(0, quota - used) : null);
const serviceExpiresAt = vm?.service_expires_at ?? vm?.expires_at
?? service.service_expires_at ?? service.expires_at ?? billing.expires_at ?? null;
const status = firstText(vm?.service_status, service.status, period.status, billing.status, vm?.subscription_status);
const networkStatus = firstText(vm?.network_status, service.network_status, period.network_status, traffic.network_status);
const displayQuota = accountingMode === 'pooled'
? (projectionReady ? firstNumber(pool.active_entitlement_bytes) : null) : quota;
const displayConsumed = accountingMode === 'pooled'
? (projectionReady ? firstNumber(pool.active_consumed_bytes) : null) : used;
const displayRemaining = accountingMode === 'pooled'
? (projectionReady ? firstNumber(pool.available_bytes) : null) : remaining;
return { quota: displayQuota, rx, tx, used, remaining: displayRemaining,
progressUsed: displayConsumed, accountingMode, pool, projectionReady,
serviceExpiresAt, status, networkStatus };
}
function formatBytes(value) {
if (value === null || !Number.isFinite(value) || value < 0) {
return t('instance_detail.value.unavailable');
}
return i18n.bytes(value);
}
function formatTrafficQuota(value) {
return value === 0 ? t('instance_detail.value.unlimited_traffic') : formatBytes(value);
}
function serviceStatusInfo(data) {
let status = data.status.toLowerCase().replace(/[\s-]+/g, '_');
if (!status && serviceTimestamp(data.serviceExpiresAt) !== null) status = serviceTimestamp(data.serviceExpiresAt) <= Date.now() ? 'expired' : 'active';
const labels = {
active: ['active', 'active'], pending: ['pending', 'warning'], renewing: ['renewing', 'warning'],
grace: ['grace', 'warning'], expired_grace: ['grace', 'warning'], grace_expired: ['grace', 'warning'],
resume_pending: ['resume_pending', 'warning'], resuming: ['resuming', 'warning'], resume_failed: ['resume_failed', 'stopped'], suspending: ['suspending', 'warning'],
suspending_expired: ['suspending_expired', 'warning'], suspended_expired: ['suspended_expired', 'stopped'], expired: ['expired', 'stopped'],
suspend_failed: ['suspend_failed', 'stopped'],
deletion_pending: ['deletion_pending', 'warning'], delete_pending: ['deletion_pending', 'warning'], deleting: ['deleting', 'warning'], deleting_expired: ['deleting', 'warning'],
purge_pending: ['deletion_pending', 'warning'], purge_stopping: ['purge_stopping', 'warning'], purge_force_required: ['purge_force_required', 'stopped'], purge_deleting: ['deleting', 'warning'], purging: ['deleting', 'warning'],
delete_failed: ['delete_failed', 'stopped'], purge_stop_failed: ['purge_stop_failed', 'stopped'], purge_failed: ['delete_failed', 'stopped'],
suspended_traffic: ['suspended_traffic', 'stopped'], traffic_exhausted: ['traffic_exhausted', 'stopped'], exempt: ['exempt', 'active'],
};
const [labelKey, className] = labels[status] || ['unknown', 'unknown'];
return { label: t(`instance_detail.service.${labelKey}`), className };
}
function networkStatusInfo(value) {
const status = value.toLowerCase().replace(/[\s-]+/g, '_');
const labels = {
active: ['active', 'active'], blocking: ['blocking', 'warning'], blocking_expired: ['blocking_expired', 'warning'],
blocked_traffic: ['blocked_traffic', 'stopped'], blocked_expired: ['blocked_expired', 'stopped'],
block_failed: ['block_failed', 'stopped'], restore_pending: ['restore_pending', 'warning'], restoring: ['restoring', 'warning'],
expiry_block_failed: ['expiry_block_failed', 'stopped'], block_expired_failed: ['expiry_block_failed', 'stopped'],
restore_failed: ['restore_failed', 'stopped'],
configuration_invalid: ['configuration_invalid', 'stopped'],
exempt: ['exempt', 'active'],
};
const [labelKey, className] = labels[status] || ['unknown', 'unknown'];
return { label: t(`instance_detail.network.${labelKey}`), className };
}
function selectedVm() { return state.vms.find(vm => vm.uuid === state.selectedVmId); }
function vmPath(vm = selectedVm()) {
if (!vm) throw new Error(vmPageText('instance_detail.error.vm_unavailable', 'reinstall.error.vm_unavailable'));
return `/api/v1/vms/${encodeURIComponent(vm.api_id)}`;
}
function clearCredential() {
clearTimeout(state.credentialTimer);
state.credentialPassword = '';
state.credentialVisible = false;
if (byId('vm-detail-root-password')) text('vm-detail-root-password', '********');
byId('vm-detail-password-reveal')?.setAttribute('aria-pressed', 'false');
}
const VM_DETAIL_TABS = ['operations', 'performance', 'operations-log', 'settings'];
function setVmDetailTab(tab, focus = false) {
const requested = tab === 'traffic' ? 'performance' : tab;
const next = VM_DETAIL_TABS.includes(requested) ? requested : 'operations';
state.detailTab = next;
for (const name of VM_DETAIL_TABS) {
const button = byId(`vm-detail-tab-${name}`);
const active = name === next;
button.classList.toggle('active', active);
button.setAttribute('aria-selected', String(active));
button.tabIndex = active ? 0 : -1;
byId(`vm-detail-${name}-panel`).hidden = !active;
}
stopVmMetrics();
stopVmTrafficDaily();
if (state.view === 'detail') {
if (next === 'performance') {
startVmMetrics();
startVmTrafficDaily();
}
}
if (focus) byId(`vm-detail-tab-${next}`).focus();
}
async function loadVms() {
if (state.loadingVMs) return;
state.loadingVMs = true;
try {
state.vms = items(await api('/api/v1/vms')).map(normalizeVm);
showError('cloud-page-error', '');
if (byId('vm-table-body')) renderVMs();
const vm = selectedVm();
if (vm && state.view === 'detail') renderVmDetail(vm);
else if (state.selectedVmId && !vm && ['detail', 'reinstall'].includes(state.view)) {
throw new Error(vmPageText('instance_detail.error.vm_unavailable', 'reinstall.error.vm_unavailable'));
}
}
catch (error) {
showError('cloud-page-error', ['detail', 'reinstall'].includes(state.view)
? vmPageText('instance_detail.error.load', 'reinstall.error.load')
: safeRequestFailure(error));
if (!state.vms.length && byId('vm-table-body')) renderVMs(true);
}
finally { state.loadingVMs = false; }
}
async function loadVm(apiId = selectedVm()?.api_id || document.body.dataset.vmId, raise = false) {
const id = String(apiId || '');
if (!id) {
const message = vmPageText('instance_detail.error.vm_id_missing', 'reinstall.error.vm_id_missing');
showError('cloud-page-error', message);
if (raise) throw new Error(message);
return null;
}
if (state.loadingVMs) return selectedVm() || null;
state.loadingVMs = true;
try {
const vm = normalizeVm(await api(`/api/v1/vms/${encodeURIComponent(id)}`));
state.vms = [vm];
state.selectedVmId = vm.uuid;
showError('cloud-page-error', '');
if (state.view === 'detail') renderVmDetail(vm);
return vm;
} catch (error) {
showError('cloud-page-error', vmPageText('instance_detail.error.load', 'reinstall.error.load'));
if (raise) throw error;
return null;
} finally {
state.loadingVMs = false;
}
}
function applyCloudUser(user = {}) {
state.csrfToken = String(user.csrf_token || '');
if (!state.csrfToken) throw new Error(t('common.error.login_expired'));
state.userId = String(user.user_id || '');
if (!/^\d+$/.test(state.userId)) throw new Error(t('common.error.login_expired'));
state.username = user.username || user.user_name || user.email || t('common.shell.account.fallback');
state.admin = user.admin === true || user.is_admin === true || Number(user.is_admin) === 1;
if (byId('current-username')) text('current-username', state.username);
for (const id of ['cloud-admin-link', 'cloud-admin-menu-link']) {
const link = byId(id);
if (link) link.hidden = !state.admin;
}
}
function hydrateVmDetailBootstrap(payload) {
if (!payload || typeof payload !== 'object' || !payload.vm || typeof payload.vm !== 'object') {
throw new Error(t('instance_detail.error.vm_data_invalid'));
}
state.view = 'detail';
applyCloudUser(payload.user || {});
const vm = normalizeVm(payload.vm);
if (!vm.api_id || !vm.uuid) throw new Error(t('instance_detail.error.vm_id_missing'));
state.vms = [vm];
state.selectedVmId = vm.uuid;
return vm;
}
async function settleVmStatusRequest(promise, raise) {
try {
return await promise;
} catch (error) {
if (error?.name === 'AbortError') return null;
showError('cloud-page-error', vmPageText('instance_detail.error.status_load', 'reinstall.error.load'));
if (raise) throw error;
return null;
}
}
async function loadVmStatus(apiId = selectedVm()?.api_id || document.body.dataset.vmId, options = {}) {
const settings = typeof options === 'boolean' ? { raise: options } : (options || {});
const raise = settings.raise === true;
const live = settings.live === true;
const force = settings.force === true;
const id = String(apiId || '');
if (!id) {
const message = vmPageText('instance_detail.error.vm_id_missing', 'reinstall.error.vm_id_missing');
showError('cloud-page-error', message);
if (raise) throw new Error(message);
return null;
}
const active = vmStatusRequest;
if (active && active.apiId === id && !force && (!live || active.live)) {
return settleVmStatusRequest(active.promise, raise);
}
active?.controller.abort();
const controller = new AbortController();
const generation = ++vmStatusGeneration;
const request = { apiId: id, live, controller, promise: null };
request.promise = (async () => {
try {
const liveQuery = live ? '?live=1' : '';
const payload = await api(`/api/v1/vms/${encodeURIComponent(id)}/status${liveQuery}`, { signal: controller.signal });
if (controller.signal.aborted || generation !== vmStatusGeneration) return null;
const current = selectedVm();
if (!current) throw new Error(vmPageText('instance_detail.error.vm_data_invalid', 'reinstall.error.vm_data_invalid'));
if (String(current.api_id) !== id) return null;
const update = payload?.vm && typeof payload.vm === 'object' ? payload.vm : payload;
if (!update || typeof update !== 'object') throw new Error(vmPageText('instance_detail.error.vm_data_invalid', 'reinstall.error.vm_data_invalid'));
const vm = normalizeVm({ ...current, ...update, id: current.api_id, uuid: current.uuid });
state.vms = [vm];
state.selectedVmId = vm.uuid;
showError('cloud-page-error', '');
if (state.view === 'detail') renderVmDetail(vm);
return vm;
} catch (error) {
// Superseded requests must be silent even when fetch had already
// produced a non-abort error before the newer request took ownership.
if (controller.signal.aborted || generation !== vmStatusGeneration) return null;
throw error;
} finally {
if (vmStatusRequest === request) vmStatusRequest = null;
}
})();
vmStatusRequest = request;
return settleVmStatusRequest(request.promise, raise);
}
function localPowerMutation(vm) {
const mutation = state.powerMutation;
return mutation && vm && String(mutation.vmId) === String(vm.api_id) ? mutation : null;
}
function powerTransition(vm) {
const local = localPowerMutation(vm);
if (local) return local.action;
const operation = String(vm?.operation_transition || '').toLowerCase();
if (['start', 'shutdown', 'reinstall', 'upgrade', 'locked'].includes(operation)) return operation;
if (vm?.state_transitioning !== true) return '';
const transition = String(vm.state_transition || '').toLowerCase();
return ['start', 'shutdown', 'reinstall', 'upgrade', 'locked'].includes(transition)
? transition : '';
}
function renderVmDetail(vm) {
const display = detailStateDisplay(vm);
text('vm-detail-name-value', vm.name); text('vm-detail-state', display.label); byId('vm-detail-state').className = `state-pill ${display.category}`;
const syncElement = byId('vm-detail-state-sync');
if (syncElement) {
syncElement.textContent = display.note;
syncElement.className = `vm-state-sync ${display.noteClass}`.trim();
syncElement.hidden = !display.note;
}
for (const id of ['vm-detail-region', 'vm-detail-header-region']) text(id, vmRegion(vm));
text('vm-detail-ipv4', vmIp(vm, 4));
text('vm-detail-ipv6', vmIp(vm, 6));
text('vm-detail-header-ip', vmIp(vm, 4));
text('vm-detail-header-created-at', vmCreatedAgo(vm)); const system = vmSystemInfo(vm); text('vm-detail-os-label', system.label); text('vm-detail-os', system.value);
text('vm-detail-spec', `${vm.vcpu ?? '—'} vCPU · ${vm.memory_mib ?? '—'} MiB`); text('vm-detail-disk', diskLabel(vm)); text('vm-detail-ssh-user', vm.login_name || (vm.os_source === 'cloud_template' ? 'root' : t('instance_detail.value.not_recorded')));
const settingsHostname = byId('vm-detail-settings-current-hostname');
if (settingsHostname) settingsHostname.textContent = vm.guest_hostname || t('instance_detail.value.not_recorded');
byId('vm-detail-ipv4-copy').hidden = vmIp(vm, 4) === t('instance_detail.value.not_available');
byId('vm-detail-ipv6-copy').hidden = vmIp(vm, 6) === t('instance_detail.value.not_available');
text('vm-detail-root-password', !vm.can_view_credential ? t('instance_detail.value.no_permission') : vm.password_available ? (state.credentialVisible ? state.credentialPassword : '********') : t('instance_detail.value.not_recorded'));
for (const id of ['vm-detail-password-reveal', 'vm-detail-password-copy']) byId(id).hidden = !vm.password_available;
renderVmService(vm);
const category = stateCategory(vm.state); const running = category === 'running'; const stopped = category === 'stopped';
const transition = powerTransition(vm);
const powerBusy = localPowerMutation(vm) !== null || transition !== '';
const consoleAvailable = running || transition === 'shutdown';
const stateKnown = !['', 'unknown', 'nostate'].includes(String(vm.state || '').toLowerCase().replace(/[_\s-]+/g, ''));
const primary = byId('vm-detail-primary-actions'); const danger = byId('vm-detail-danger-actions'); primary.replaceChildren(); danger.replaceChildren();
danger.closest('section').hidden = !vm.can_operate && !vm.can_delete;
if (vm.can_operate) {
primary.append(actionButton(t('instance_detail.actions.console'), () => openConsole(vm), { disabled: !consoleAvailable }), actionButton(t('instance_detail.actions.start'), () => powerAction('start'), { disabled: powerBusy || !stopped }), actionButton(t('instance_detail.actions.shutdown'), () => powerAction('shutdown'), { disabled: powerBusy || !running }), actionButton(t('instance_detail.actions.restart'), () => powerAction('reboot'), { disabled: powerBusy || !running }));
danger.append(actionButton(t('instance_detail.danger.reinstall'), () => navigate(vmPagePath(vm.api_id, 'reinstall')), { variant: 'danger', disabled: powerBusy || !stateKnown || vm.os_source !== 'cloud_template' }), actionButton(t('instance_detail.danger.rescue'), () => navigate(`${vmPagePath(vm.api_id)}?tab=settings&setting=rescue`), { variant: 'danger', disabled: powerBusy || !stateKnown }), actionButton(t('instance_detail.danger.force_reset'), () => powerAction('reset', true), { variant: 'danger', disabled: powerBusy || !running }), actionButton(t('instance_detail.danger.force_off'), () => powerAction('poweroff', true), { variant: 'danger', disabled: powerBusy || !stateKnown || stopped }));
} else {
primary.append(makeElement('p', 'muted', vm.is_owner || vm.can_delete
? t('instance_detail.actions.unavailable')
: t('instance_detail.actions.read_only')));
}
if (vm.can_delete) danger.append(actionButton(t('instance_detail.danger.delete'), deleteVm, { variant: 'danger', disabled: powerBusy || !stopped }));
if (state.mutationBusy) document.querySelectorAll('#vm-detail-primary-actions button,#vm-detail-danger-actions button').forEach(button => { button.disabled = true; });
document.dispatchEvent(new CustomEvent('cloud:vm-rendered', { detail: { vm } }));
}
function renderVmService(vm) {
const data = vmServiceData(vm);
const status = serviceStatusInfo(data);
const statusElement = byId('vm-detail-service-status');
statusElement.textContent = status.label;
statusElement.className = `service-pill ${status.className}`;
const networkStatus = networkStatusInfo(data.networkStatus);
const networkStatusElement = byId('vm-detail-network-status');
networkStatusElement.textContent = networkStatus.label;
networkStatusElement.className = `service-pill ${networkStatus.className}`;
text('vm-detail-service-expiry', formatServiceDate(data.serviceExpiresAt));
text('vm-detail-traffic-rx', formatBytes(data.rx));
text('vm-detail-traffic-tx', formatBytes(data.tx));
text('vm-detail-traffic-used', formatBytes(data.used));
const pooled = data.accountingMode === 'pooled';
const unlimited = data.accountingMode === 'unlimited'
|| (data.accountingMode === 'legacy' && data.quota === 0);
text('vm-detail-traffic-description', pooled
? (data.projectionReady
? t('instance_detail.traffic.pooled_description')
: t('instance_detail.traffic.pool_initializing'))
: t('instance_detail.traffic.description'));
text('vm-detail-traffic-used-label', pooled ? t('instance_detail.traffic.instance_sample_total') : t('instance_detail.traffic.used'));
text('vm-detail-traffic-total-label', pooled ? t('instance_detail.traffic.pool_total_remaining') : t('instance_detail.traffic.total_remaining'));
text('vm-detail-traffic-total-remaining', pooled && !data.projectionReady
? t('instance_detail.traffic.preparing_pair')
: unlimited
? t('instance_detail.traffic.unlimited_pair')
: `${formatBytes(data.quota)} / ${formatBytes(data.remaining)}`);
const poolLink = byId('vm-detail-traffic-pool-link');
if (poolLink) {
poolLink.hidden = !pooled;
poolLink.textContent = pooled
? t('instance_detail.traffic.view_named_pool', { name: firstText(data.pool.name, t('instance_detail.traffic.shared_pool')) })
: t('instance_detail.traffic.view_pool');
}
const progress = byId('vm-detail-traffic-progress');
progress.setAttribute('aria-label', pooled ? t('instance_detail.traffic.pool_usage') : t('instance_detail.traffic.plan_usage'));
const ratio = data.quota !== null && data.quota > 0 && data.progressUsed !== null
? Math.max(0, Math.min(100, data.progressUsed / data.quota * 100)) : null;
progress.hidden = ratio === null;
if (ratio !== null) {
progress.setAttribute('aria-valuenow', String(Math.round(ratio * 10) / 10));
byId('vm-detail-traffic-progress-bar').style.width = `${ratio}%`;
progress.classList.toggle('is-exhausted', ratio >= 100);
} else {
progress.removeAttribute('aria-valuenow');
byId('vm-detail-traffic-progress-bar').style.width = '0';
progress.classList.remove('is-exhausted');
}
}
function taskFailureMessage(task, fallback = t('common.tasks.error.execution_failed')) {
const resolvedNotice = resolvedTaskFailureNotice(task);
if (resolvedNotice) return resolvedNotice;
if (task?.recovery?.pending === true || task?.effect_may_have_applied) {
return t('common.tasks.warning.effect_unknown');
}
return task?.safe_to_resubmit === false
? t('common.tasks.warning.no_resubmit') : fallback;
}
function observeAcceptedTask(result, detail = {}, handlers = {}) {
if (!taskUrl(result)) return null;
announceTaskAccepted(result, detail);
const handle = observeTask(result, handlers);
if (!handle.url) return null;
activeTaskObservers.add(handle);
void handle.done.finally(() => activeTaskObservers.delete(handle));
return handle;
}
async function powerAction(action, dangerous = false) {
const vm = selectedVm();
if (!vm?.can_operate) return toast(t('instance_detail.power.unavailable'), 'error');
if (state.mutationBusy || state.powerMutation) return;
if (dangerous) {
const resetting = action === 'reset';
const confirmed = await requestUserConfirmation({
title: resetting ? t('instance_detail.power.force_reset_title') : t('instance_detail.power.force_off_title'),
message: resetting
? t('instance_detail.power.force_reset_body', { name: vm.name })
: t('instance_detail.power.force_off_body', { name: vm.name }),
confirmText: resetting ? t('instance_detail.danger.force_reset') : t('instance_detail.danger.force_off'),
tone: 'danger',
});
if (!confirmed) return;
}
const mutation = { vmId: vm.api_id, action };
state.powerMutation = mutation;
renderVmDetail(vm);
try {
const result = await api(`${vmPath(vm)}/actions`, {
method: 'POST', body: { action }, expectedStatus: 202, requireTaskReceipt: true,
});
const observer = observeAcceptedTask(result, { title: t('instance_detail.power.task_title') }, {
onTerminal: task => {
if (!taskSucceededWithoutRecovery(task)) {
toast(taskFailureMessage(task), 'error', t('instance_detail.power.recovery_title'));
}
void loadVmStatus(vm.api_id, { live: true, force: true });
},
});
toast(observer
? t('instance_detail.power.accepted')
: t('instance_detail.power.invalid_receipt'),
observer ? 'success' : 'error', t('instance_detail.power.task_title'));
} catch (error) {
toast(error?.mutationMayHaveApplied
? t('common.tasks.warning.effect_unknown')
: t('instance_detail.power.submit_failed'), 'error');
void loadVmStatus(vm.api_id, { live: true, force: true });
} finally {
if (state.powerMutation === mutation) state.powerMutation = null;
if (selectedVm()) renderVmDetail(selectedVm());
}
}
async function deleteVm() {
const vm = selectedVm();
if (!vm?.can_delete) return toast(t('instance_detail.delete.forbidden'), 'error');
if (state.mutationBusy || state.powerMutation) return;
const confirmed = await requestUserConfirmation({
title: t('instance_detail.delete.title'),
message: t('instance_detail.delete.body', { name: vm.name }),
confirmText: t('instance_detail.delete.confirm'),
tone: 'danger',
requiredText: vm.name,
requiredLabel: t('instance_detail.delete.required_label'),
});
if (!confirmed) return;
state.mutationBusy = true;
setDetailBusy(true);
try {
const result = await api(vmPath(vm), {
method: 'DELETE', body: { confirmation_name: vm.name, delete_disks: true },
expectedStatus: 202, requireTaskReceipt: true,
});
announceTaskAccepted(result, { title: t('instance_detail.delete.task_title') });
toast(t('instance_detail.delete.accepted'), 'success', t('instance_detail.delete.task_title'));
navigate(CLOUD_PATHS.instances);
} catch (error) {
toast(error?.mutationMayHaveApplied
? t('common.tasks.warning.effect_unknown')
: t('instance_detail.delete.submit_failed'), 'error');
} finally {
state.mutationBusy = false;
setDetailBusy(false);
}
}
function setDetailBusy(busy) { if (!busy && selectedVm()) renderVmDetail(selectedVm()); else if (busy) document.querySelectorAll('#vm-detail-primary-actions button,#vm-detail-danger-actions button').forEach(button => { button.disabled = true; }); }
async function credential(copy = false) {
const vm = selectedVm(); if (!vm?.can_view_credential || !vm.password_available) return;
if (!copy && state.credentialVisible) return clearCredential();
const id = vm.api_id;
try { const result = await api(`${vmPath(vm)}/credential`, { method: 'POST' }); if (selectedVm()?.api_id !== id || state.view !== 'detail') return; if (!result?.password) throw new Error(t('instance_detail.error.credential_unavailable')); if (copy) { await copyText(result.password); } else { state.credentialPassword = result.password; state.credentialVisible = true; text('vm-detail-root-password', result.password); byId('vm-detail-password-reveal').setAttribute('aria-pressed', 'true'); clearTimeout(state.credentialTimer); state.credentialTimer = setTimeout(clearCredential, 30000); } } catch { toast(t('instance_detail.error.credential_unavailable'), 'error'); }
}
async function loadKeys() {
state.sshKeys = items(await api('/api/v1/ssh-keys'));
if (byId('ssh-keys-list')) renderKeys();
if (byId('vm-guest-ssh-key-cards')) renderKeyCards('create');
if (byId('reinstall-ssh-key-cards')) renderKeyCards('reinstall');
}
function renderKeys() {
const container = byId('ssh-keys-list'); container.replaceChildren();
if (!state.sshKeys.length) {
return container.append(makeElement('p', 'muted', t('ssh_keys.empty.title')));
}
for (const key of state.sshKeys) {
const row = makeElement('div', 'ssh-key-row');
const details = makeElement('div', 'ssh-key-details');
details.append(makeElement('strong', '', key.name), makeElement('small', '', key.fingerprint || ''));
const actions = makeElement('div', 'ssh-key-actions');
const button = actionButton(t('ssh_keys.action.delete'), async () => {
const confirmed = await requestUserConfirmation({
title: t('ssh_keys.confirm.delete.title'),
message: t('ssh_keys.confirm.delete.body', { name: key.name }),
confirmText: t('ssh_keys.confirm.delete.button'),
tone: 'danger',
});
if (!confirmed) return;
try {
await api(`/api/v1/ssh-keys/${encodeURIComponent(key.id)}`, { method: 'DELETE' });
await loadKeys();
} catch {
toast(t('ssh_keys.error.delete'), 'error');
}
});
button.classList.add('ssh-key-delete');
actions.append(button);
row.append(details, actions);
container.append(row);
}
}
function renderKeyCards(kind) {
const id = kind === 'create' ? 'vm-guest-ssh-key-cards' : 'reinstall-ssh-key-cards'; const container = byId(id); if (!container) return; container.replaceChildren();
const deployment = kind === 'create';
if (!state.sshKeys.some(key => String(key.id) === state.selectedKeys[kind])) state.selectedKeys[kind] = '';
for (const key of state.sshKeys) {
const keyId = String(key.id);
const selected = state.selectedKeys[kind] === keyId;
const fingerprint = String(key.fingerprint || '').trim();
const button = makeElement('button', 'ssh-key-option');
button.type = 'button';
button.dataset.keyId = keyId;
button.dataset.keyFingerprint = fingerprint;
button.setAttribute('aria-pressed', String(selected));
button.setAttribute('aria-label', deployment
? t(selected ? 'deploy.config.ssh_deselect' : 'deploy.config.ssh_select', {
name: key.name, fingerprint: fingerprint || t('deploy.config.fingerprint_missing'),
})
: t(selected ? 'reinstall.ssh_key.deselect' : 'reinstall.ssh_key.select', {
name: key.name, fingerprint: fingerprint || t('reinstall.ssh_key.fingerprint_missing'),
}));
const icon = makeElement('i', 'mdi mdi-key-variant ssh-key-choice-icon');
icon.setAttribute('aria-hidden', 'true');
const copy = makeElement('span', 'ssh-key-choice-copy');
const fingerprintLabel = makeElement('small', 'ssh-key-choice-fingerprint', fingerprint
|| (deployment ? t('deploy.config.fingerprint_label_missing') : t('reinstall.ssh_key.fingerprint_missing')));
if (fingerprint) fingerprintLabel.title = fingerprint;
copy.append(makeElement('strong', 'ssh-key-choice-label', key.name), fingerprintLabel);
const check = makeElement('span', 'ssh-key-choice-check', '✓');
check.setAttribute('aria-hidden', 'true');
button.append(icon, copy, check);
button.addEventListener('click', () => {
state.selectedKeys[kind] = state.selectedKeys[kind] === keyId ? '' : keyId;
container.querySelectorAll('.ssh-key-option').forEach((option) => {
const optionSelected = option.dataset.keyId === state.selectedKeys[kind];
const optionName = option.querySelector('.ssh-key-choice-label')?.textContent || '';
const optionFingerprint = option.dataset.keyFingerprint
|| (deployment ? t('deploy.config.fingerprint_missing') : t('reinstall.ssh_key.fingerprint_missing'));
option.setAttribute('aria-pressed', String(optionSelected));
option.setAttribute('aria-label', deployment
? t(optionSelected ? 'deploy.config.ssh_deselect' : 'deploy.config.ssh_select', {
name: optionName, fingerprint: optionFingerprint,
})
: t(optionSelected ? 'reinstall.ssh_key.deselect' : 'reinstall.ssh_key.select', {
name: optionName, fingerprint: optionFingerprint,
}));
});
});
container.append(button);
}
if (!state.sshKeys.length) container.append(makeElement('p', 'muted', deployment
? t('deploy.config.ssh_empty') : t('reinstall.ssh_key.empty')));
}
function flagForCountry(code) {
const normalized = String(code || '').trim().toUpperCase();
if (!/^[A-Z]{2}$/.test(normalized)) return '🌐';
return String.fromCodePoint(...Array.from(normalized, character => 127397 + character.charCodeAt(0)));
}
function saleRegions() {
const regions = [];
const seen = new Set();
for (const region of state.regions) {
const id = String(region?.id ?? '');
if (!/^[1-9]\d*$/.test(id) || seen.has(id)) continue;
seen.add(id);
regions.push({
id,
countryCode: String(region.country_code || '').trim().toUpperCase(),
name: String(region.name || t('deploy.region.unset')).trim()
|| t('deploy.region.unset'),
});
}
return regions;
}
function saleLines(regionId = state.selectedRegionId) {
const lines = [];
const seen = new Set();
for (const line of state.lines) {
const id = String(line?.id ?? '');
if (!/^[1-9]\d*$/.test(id) || seen.has(id)
|| String(line?.region_id ?? '') !== String(regionId)
|| (!state.linesEnabled && line?.is_default !== true)) continue;
seen.add(id);
lines.push({
id,
regionId: String(line.region_id),
name: String(line.name || t('deploy.line.unset')).trim()
|| t('deploy.line.unset'),
isDefault: line.is_default === true,
});
}
return lines;
}
function saleOffers(regionId = state.selectedRegionId, lineId = state.selectedLineId) {
return state.offers.filter(offer => /^[1-9]\d*$/.test(String(offer?.id ?? ''))
&& String(offer?.region_id ?? '') === String(regionId)
&& String(offer?.line_id ?? '') === String(lineId)
&& String(offer?.currency || '').toUpperCase() === 'USD');
}
function isOfferSellable(offer) { return offer?.sellable === true; }
function defaultSaleLine(lines) { return lines.find(line => line.isDefault) || lines[0] || null; }
function applySaleCatalog(catalog) {
state.regions = bootstrapItems(catalog, 'regions');
state.lines = bootstrapItems(catalog, 'lines');
state.offers = bootstrapItems(catalog, 'offers');
state.linesEnabled = catalog?.lines_enabled === true;
const regions = saleRegions();
const requestedRegionId = String(catalog?.default_region_id ?? '');
state.selectedRegionId = regions.some(region => region.id === requestedRegionId)
? requestedRegionId : (regions[0]?.id || '');
const lines = saleLines(state.selectedRegionId);
const requestedLineId = String(catalog?.default_line_id ?? '');
state.selectedLineId = lines.some(line => line.id === requestedLineId)
? requestedLineId : (defaultSaleLine(lines)?.id || '');
byId('vm-region').value = state.selectedRegionId;
byId('vm-line').value = state.selectedLineId;
}
function setDeploymentStepEnabled(id, enabled) {
const step = byId(id);
if (!step) return;
step.classList.toggle('is-disabled', !enabled);
step.setAttribute('aria-disabled', String(!enabled));
}
function selectedSaleOffer() {
return saleOffers().find(item => String(item.id) === byId('vm-offer')?.value) || null;
}
function deploymentTemplates() {
const offerId = String(selectedSaleOffer()?.id ?? '');
if (!offerId) return [];
return state.templates.filter(item => Array.isArray(item?.offer_ids)
&& item.offer_ids.some(id => String(id) === offerId));
}
function syncDeploymentPricing() {
const offer = selectedSaleOffer();
const option = byId('vm-automatic-backup-option');
const checkbox = byId('vm-automatic-backup');
const help = byId('vm-automatic-backup-help');
const backupAvailable = Boolean(offer);
if (checkbox) {
checkbox.disabled = !backupAvailable || state.mutationBusy;
if (!backupAvailable) checkbox.checked = false;
}
option?.classList.toggle('is-disabled', !backupAvailable || state.mutationBusy);
if (help) {
help.textContent = offer
? t('deploy.backup.help_available')
: t('deploy.backup.help_unavailable');
}
const summary = byId('vm-order-summary');
const empty = byId('vm-order-summary-empty');
if (!offer) {
if (summary) summary.hidden = true;
if (empty) empty.hidden = false;
if (byId('create-submit')) byId('create-submit').textContent = t('deploy.submit.invoice');
return;
}
const instancePrice = Number(offer.price);
const backupPrice = Number(offer.backup_price);
const backupSelected = backupAvailable && checkbox?.checked === true;
const total = Math.max(0, Number.isFinite(instancePrice) ? instancePrice : 0)
+ (backupSelected && Number.isFinite(backupPrice) ? Math.max(0, backupPrice) : 0);
if (byId('vm-order-instance-price')) byId('vm-order-instance-price').textContent = formatUsd(instancePrice);
if (byId('vm-order-backup-price')) byId('vm-order-backup-price').textContent = formatUsd(backupPrice);
if (byId('vm-order-backup-row')) byId('vm-order-backup-row').hidden = !backupSelected;
if (byId('vm-order-total-price')) byId('vm-order-total-price').textContent = formatUsd(total);
if (byId('vm-order-renewal-price')) byId('vm-order-renewal-price').textContent = t('deploy.summary.period_price', { price: formatUsd(total) });
if (summary) summary.hidden = false;
if (empty) empty.hidden = true;
if (byId('create-submit')) byId('create-submit').textContent = t('deploy.submit.invoice_amount', { price: formatUsd(total) });
}
function applyDeploymentSource() {
const snapshotKey = state.deployCloudSnapshotKey;
const source = byId('vm-cloud-snapshot-source');
const templateField = byId('vm-template-field');
const authFields = byId('vm-cloud-fields');
const template = byId('vm-template');
const password = byId('vm-root-password');
if (byId('vm-cloud-snapshot-key')) byId('vm-cloud-snapshot-key').value = snapshotKey;
if (source) source.hidden = !snapshotKey;
if (templateField) templateField.hidden = Boolean(snapshotKey);
if (authFields) authFields.hidden = Boolean(snapshotKey);
if (template) {
template.disabled = Boolean(snapshotKey)
|| !deploymentTemplates().some(item => item?.id);
}
if (password) password.disabled = Boolean(snapshotKey);
const sourceTitle = byId('deploy-source-title');
if (sourceTitle?.firstChild) {
sourceTitle.firstChild.nodeValue = snapshotKey
? t('deploy.source.snapshot') : t('deploy.source.template');
}
if (byId('vm-cloud-snapshot-source-name') && snapshotKey) {
const name = state.deployCloudSnapshotName
|| `${t('deploy.source.snapshot_default')} ${snapshotKey.slice(0, 8)}`;
byId('vm-cloud-snapshot-source-name').textContent = t('deploy.source.snapshot_description', { name });
}
}
function initializeDeploymentOptions(bootstrap = null) {
const snapshot = bootstrap?.cloud_snapshot;
const key = String(snapshot?.snapshot_key ?? snapshot?.key ?? '');
state.deployCloudSnapshotKey = /^[a-f0-9]{32}$/.test(key) ? key : '';
state.deployCloudSnapshotName = state.deployCloudSnapshotKey
? String(snapshot?.name || '').trim().slice(0, 64) : '';
const checkbox = byId('vm-automatic-backup');
if (checkbox && checkbox.dataset.bound !== 'true') {
checkbox.dataset.bound = 'true';
checkbox.addEventListener('change', () => {
showError('create-error', '');
syncDeploymentPricing();
updateCreateAvailability();
});
}
applyDeploymentSource();
syncDeploymentPricing();
}
function updateCreateAvailability() {
const offer = selectedSaleOffer();
const selectedTemplate = String(byId('vm-template')?.value || '');
const validTemplate = deploymentTemplates().some(item => String(item?.id) === selectedTemplate);
const validMedia = Boolean(state.deployCloudSnapshotKey || validTemplate);
if (byId('create-submit')) byId('create-submit').disabled = state.mutationBusy || !isOfferSellable(offer) || !validMedia;
syncDeploymentPricing();
}
function strongPassword(value) { return !value || (value.length >= 12 && value.length <= 128 && /^[\x21-\x7e]+$/.test(value) && /[A-Z]/.test(value) && /[a-z]/.test(value) && /[0-9]/.test(value) && /[^A-Za-z0-9]/.test(value)); }
function formatUsd(value) {
const amount = Number(value);
if (!Number.isFinite(amount) || amount < 0) return '$— USD';
return `$${amount.toFixed(2)} USD`;
}
function formatMemoryGiB(memoryMib) {
const amount = Number(memoryMib);
if (!Number.isFinite(amount) || amount < 0) return '— GB';
return `${i18n.number(amount / 1024, { maximumFractionDigits: 1 })} GB`;
}
function formatTrafficTiB(trafficTiB) {
const amount = Number(trafficTiB);
if (!Number.isFinite(amount) || amount < 0) return '—';
if (amount === 0) return t('deploy.offer.unlimited');
return `${amount.toFixed(10).replace(/\.?0+$/, '')} TB`;
}
function resetInstallChoices() {
state.resourceController?.abort();
state.resourceController = null;
state.resources = null;
state.templates = [];
const templateInput = byId('vm-template');
const templateCatalog = byId('vm-template-catalog');
templateInput.value = '';
templateInput.disabled = true;
templateCatalog.removeAttribute('aria-busy');
templateCatalog.replaceChildren();
byId('vm-name').disabled = true;
byId('vm-root-password').disabled = true;
setDeploymentStepEnabled('vm-source-step', false);
setDeploymentStepEnabled('vm-config-step', false);
updateCreateAvailability();
}
function renderRegionPicker() {
const container = byId('vm-region-picker');
const cards = saleRegions().map(region => {
const button = makeElement('button', 'region-option');
button.type = 'button';
button.dataset.regionId = region.id;
button.setAttribute('aria-pressed', String(state.selectedRegionId === region.id));
button.setAttribute('aria-label', t('deploy.region.select', { name: region.name }));
button.append(makeElement('span', 'region-flag', flagForCountry(region.countryCode)), makeElement('strong', '', region.name));
button.addEventListener('click', () => void selectRegion(region.id));
return button;
});
if (!cards.length) cards.push(makeElement('p', 'template-catalog-empty', t('deploy.region.empty')));
container.replaceChildren(...cards);
byId('vm-region').value = state.selectedRegionId;
}
function renderLinePicker() {
const container = byId('vm-line-picker');
if (!container) return;
const cards = saleLines().map(line => {
const button = makeElement('button', 'line-option');
button.type = 'button';
button.dataset.lineId = line.id;
button.setAttribute('aria-pressed', String(state.selectedLineId === line.id));
button.setAttribute('aria-label', t('deploy.line.select', { name: line.name }));
button.append(makeElement('strong', '', line.name));
button.addEventListener('click', () => void selectLine(line.id));
return button;
});
if (!cards.length) cards.push(makeElement('p', 'template-catalog-empty', t('deploy.line.empty')));
container.replaceChildren(...cards);
}
function renderOfferPicker() {
const container = byId('vm-offer-picker');
const offerInput = byId('vm-offer');
let selectedOfferId = offerInput.value;
const offers = saleOffers();
if (!offers.length) {
container.replaceChildren(makeElement('p', 'template-catalog-empty', t('deploy.offer.empty')));
return;
}
if (!offers.some(offer => String(offer.id) === selectedOfferId && isOfferSellable(offer))) {
const defaultOffer = offers.find(isOfferSellable);
offerInput.value = defaultOffer ? String(defaultOffer.id) : '';
selectedOfferId = offerInput.value;
}
const header = makeElement('div', 'offer-table-head');
['deploy.offer.name', 'deploy.offer.cpu', 'deploy.offer.memory', 'deploy.offer.disk', 'deploy.offer.traffic']
.forEach(key => header.append(makeElement('span', '', t(key))));
const rows = offers.map(offer => {
const button = makeElement('button', 'offer-option');
const memory = formatMemoryGiB(offer.memory_mib);
const traffic = formatTrafficTiB(offer.traffic_tib);
const sellable = isOfferSellable(offer);
const name = makeElement('strong', 'offer-option-name', offer.name);
if (!sellable) name.append(makeElement('span', 'offer-option-status', t('deploy.offer.sold_out')));
button.type = 'button';
button.dataset.offerId = String(offer.id);
button.classList.toggle('is-sold-out', !sellable);
button.disabled = !sellable;
button.setAttribute('aria-disabled', String(!sellable));
button.setAttribute('aria-pressed', String(sellable && selectedOfferId === String(offer.id)));
button.setAttribute('aria-label', t(
sellable ? 'deploy.offer.select' : 'deploy.offer.unavailable',
{ name: offer.name, cpu: offer.cpu_cores, memory, disk: offer.disk_gib, traffic }
));
button.append(
name,
makeElement('span', 'offer-option-value', `${offer.cpu_cores} vCPU`),
makeElement('span', 'offer-option-value', memory),
makeElement('span', 'offer-option-value', `${offer.disk_gib} GB`),
makeElement('span', 'offer-option-value', traffic),
);
if (sellable) button.addEventListener('click', () => void selectOffer(String(offer.id)));
return button;
});
container.replaceChildren(header, ...rows);
}
async function selectRegion(regionId) {
if (state.mutationBusy) return;
const normalized = String(regionId || '');
if (!saleRegions().some(region => region.id === normalized)) return;
if (state.selectedRegionId === normalized) return;
state.selectedRegionId = normalized;
state.selectedLineId = defaultSaleLine(saleLines(normalized))?.id || '';
byId('vm-region').value = state.selectedRegionId;
byId('vm-line').value = state.selectedLineId;
byId('vm-offer').value = '';
if (byId('vm-automatic-backup')) byId('vm-automatic-backup').checked = false;
renderRegionPicker();
renderLinePicker();
renderOfferPicker();
renderTemplateCatalog('vm-template');
setDeploymentStepEnabled('vm-line-step', state.linesEnabled);
setDeploymentStepEnabled('vm-offer-step', Boolean(state.selectedLineId));
showError('create-error', '');
updateCreateAvailability();
}
async function selectLine(lineId) {
if (state.mutationBusy) return;
const line = saleLines().find(item => item.id === String(lineId));
if (!line || state.selectedLineId === line.id) return;
state.selectedLineId = line.id;
byId('vm-line').value = line.id;
byId('vm-offer').value = '';
if (byId('vm-automatic-backup')) byId('vm-automatic-backup').checked = false;
byId('vm-line-picker')?.querySelectorAll('.line-option').forEach(button => {
button.setAttribute('aria-pressed', String(button.dataset.lineId === line.id));
});
renderOfferPicker();
renderTemplateCatalog('vm-template');
setDeploymentStepEnabled('vm-offer-step', true);
showError('create-error', '');
updateCreateAvailability();
}
async function selectOffer(offerId) {
if (state.mutationBusy) return;
const offer = saleOffers().find(item => String(item.id) === String(offerId));
if (!isOfferSellable(offer)) return;
byId('vm-offer').value = String(offer.id);
byId('vm-offer-picker').querySelectorAll('.offer-option').forEach(button => {
button.setAttribute('aria-pressed', String(button.dataset.offerId === String(offer.id)));
});
renderTemplateCatalog('vm-template');
showError('create-error', '');
updateCreateAvailability();
}
async function openCreate(bootstrap = null) {
state.view = 'create'; state.selectedVmId = null; showError('create-error', '');
byId('vm-offer').value = String(bootstrap?.default_offer_id || '');
if (bootstrap && Array.isArray(bootstrap.offers) && Array.isArray(bootstrap.regions)
&& Array.isArray(bootstrap.lines) && Array.isArray(bootstrap.templates)) {
applySaleCatalog(bootstrap);
initializeDeploymentOptions(bootstrap);
state.templates = bootstrapItems(bootstrap, 'templates', 'cloud_templates');
state.templateCatalogUnavailable = bootstrap.catalog_unavailable === true;
state.sshKeys = bootstrapItems(bootstrap, 'ssh_keys', 'keys');
state.resources = { templates: state.templates };
state.selectedKeys.create = '';
renderRegionPicker();
renderLinePicker();
renderOfferPicker();
renderTemplateCatalog('vm-template');
renderKeyCards('create');
byId('vm-template').disabled = !deploymentTemplates().some(item => item?.id);
byId('vm-name').disabled = false;
byId('vm-root-password').disabled = false;
applyDeploymentSource();
setDeploymentStepEnabled('vm-line-step', state.linesEnabled && Boolean(state.selectedRegionId));
setDeploymentStepEnabled('vm-offer-step', Boolean(state.selectedLineId));
setDeploymentStepEnabled('vm-source-step', true);
setDeploymentStepEnabled('vm-config-step', true);
updateCreateAvailability();
return;
}
initializeDeploymentOptions(bootstrap);
state.regions = []; state.lines = []; state.offers = []; state.linesEnabled = false;
state.selectedRegionId = ''; state.selectedLineId = '';
byId('vm-region').value = ''; byId('vm-line').value = '';
setDeploymentStepEnabled('vm-line-step', false);
setDeploymentStepEnabled('vm-offer-step', false);
resetInstallChoices();
const results = await Promise.allSettled([
api('/api/v1/catalog').then(catalog => {
applySaleCatalog(catalog);
renderRegionPicker();
renderLinePicker();
renderOfferPicker();
renderTemplateCatalog('vm-template');
setDeploymentStepEnabled('vm-line-step', state.linesEnabled && Boolean(state.selectedRegionId));
setDeploymentStepEnabled('vm-offer-step', Boolean(state.selectedLineId));
updateCreateAvailability();
}),
loadKeys(),
loadGlobalTemplates(),
]);
const failure = results.find(result => result.status === 'rejected');
if (failure) showError('create-error', t('deploy.error.load'));
}
async function loadGlobalTemplates() {
state.resourceController?.abort();
const controller = new AbortController();
state.resourceController = controller;
renderTemplateCatalogStatus('vm-template', t('deploy.template.loading'), true);
setDeploymentStepEnabled('vm-source-step', true);
try {
const resources = await api('/api/v1/resources', { signal: controller.signal });
if (controller !== state.resourceController) return;
state.resources = resources;
state.templateCatalogUnavailable = false;
state.templates = items(resources.templates || resources.cloud_templates);
renderTemplateCatalog('vm-template');
byId('vm-template').disabled = !deploymentTemplates().some(item => item?.id);
byId('vm-name').disabled = false;
byId('vm-root-password').disabled = false;
applyDeploymentSource();
setDeploymentStepEnabled('vm-source-step', true);
setDeploymentStepEnabled('vm-config-step', true);
updateCreateAvailability();
} catch (error) {
if (controller === state.resourceController && error.name !== 'AbortError') {
renderTemplateCatalogStatus('vm-template', t('deploy.template.load_failed'));
showError('create-error', t('deploy.template.load_failed'));
}
throw error;
} finally {
if (controller === state.resourceController) {
state.resourceController = null;
}
}
}
function provisionInvoiceStorageKey() { return `${PROVISION_INVOICE_STORAGE_PREFIX}${state.userId || 'unknown'}`; }
async function provisionInvoiceFingerprint(body) {
if (!globalThis.crypto?.subtle) throw new Error(t('deploy.error.crypto'));
const canonical = {}; for (const key of Object.keys(body).sort()) canonical[key] = body[key];
const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(JSON.stringify(canonical)));
return Array.from(new Uint8Array(digest), value => value.toString(16).padStart(2, '0')).join('');
}
async function pendingProvisionInvoiceKey(fingerprint) {
if (state.provisionIdempotency && state.provisionFingerprint === fingerprint) return state.provisionIdempotency;
let saved = null;
try { saved = JSON.parse(sessionStorage.getItem(provisionInvoiceStorageKey()) || 'null'); } catch {}
let key = saved && saved.fingerprint === fingerprint ? String(saved.key || '') : '';
if (!/^[A-Za-z0-9_.-]{16,128}$/.test(key)) key = crypto.randomUUID();
state.provisionIdempotency = key;
state.provisionFingerprint = fingerprint;
try { sessionStorage.setItem(provisionInvoiceStorageKey(), JSON.stringify({ key, fingerprint })); } catch {}
return key;
}
function clearPendingProvisionInvoiceKey() {
state.provisionIdempotency = '';
state.provisionFingerprint = '';
try { sessionStorage.removeItem(provisionInvoiceStorageKey()); } catch {}
}
async function existingProvisionInvoice(key) {
try { return await api(`/api/v1/invoices/by-request/${encodeURIComponent(key)}`); }
catch (error) { if (error.status === 404) return null; throw error; }
}
async function buy(event) {
event.preventDefault(); if (state.mutationBusy) return;
const password = byId('vm-root-password').value;
if (!state.deployCloudSnapshotKey && !strongPassword(password)) return showError('create-error', t('deploy.error.password'));
if (!state.deployCloudSnapshotKey && !byId('vm-template').value) return showError('create-error', t('deploy.error.template_required'));
if (!byId('vm-offer').value) return showError('create-error', t('deploy.error.offer_required'));
const selectedOffer = saleOffers().find(offer => String(offer.id) === byId('vm-offer').value);
if (!selectedOffer) return showError('create-error', t('deploy.error.offer_mismatch'));
if (!isOfferSellable(selectedOffer)) return showError('create-error', t('deploy.error.offer_sold_out'));
state.mutationBusy = true;
const formBody = byId('create-form')?.querySelector('.workspace-form-body');
if (formBody) { formBody.inert = true; formBody.setAttribute('aria-busy', 'true'); }
byId('create-submit').disabled = true; showError('create-error', '');
const body = { offer_id: Number(byId('vm-offer').value), name: byId('vm-name').value.trim(),
source: state.deployCloudSnapshotKey ? 'deployment_snapshot' : 'cloud',
automatic_backup: byId('vm-automatic-backup')?.checked === true };
if (state.deployCloudSnapshotKey) body.cloud_snapshot_key = state.deployCloudSnapshotKey;
else body.template_id = byId('vm-template').value;
if (!state.deployCloudSnapshotKey && state.selectedKeys.create) body.guest_ssh_key_id = state.selectedKeys.create;
if (!state.deployCloudSnapshotKey && password) body.root_password = password;
try {
const fingerprint = await provisionInvoiceFingerprint(body);
const invoiceIdempotency = await pendingProvisionInvoiceKey(fingerprint);
body.idempotency_key = invoiceIdempotency;
const recovered = await existingProvisionInvoice(invoiceIdempotency);
const result = recovered || await api('/api/v1/invoices', { method: 'POST', body });
const invoiceId = result?.invoice?.id;
if (!invoiceId) throw new Error(t('deploy.error.invoice_missing'));
clearPendingProvisionInvoiceKey(); byId('vm-root-password').value = '';
navigate(`${CLOUD_PATHS.invoices}/${encodeURIComponent(String(invoiceId))}`);
}
catch (error) {
// A timeout or 409 can mean the first request committed but its response
// was lost. Reconcile by the same durable key before reporting failure.
try {
const invoiceIdempotency = state.provisionIdempotency;
const recovered = invoiceIdempotency ? await existingProvisionInvoice(invoiceIdempotency) : null;
if (recovered) {
clearPendingProvisionInvoiceKey(); byId('vm-root-password').value = '';
const invoiceId = recovered?.invoice?.id;
if (!invoiceId) throw new Error(t('deploy.error.recovered_invoice_missing'));
navigate(`${CLOUD_PATHS.invoices}/${encodeURIComponent(String(invoiceId))}`);
return;
}
} catch {}
showError('create-error', t('deploy.error.reconcile'));
}
finally {
delete body.root_password; state.mutationBusy = false;
if (formBody) { formBody.inert = false; formBody.removeAttribute('aria-busy'); }
updateCreateAvailability();
}
}
function clearReinstallPasswordCard(dismissed = false) {
state.reinstallPassword = '';
if (dismissed) state.reinstallPasswordDismissed = true;
const card = byId('reinstall-password-card');
if (!card) return;
card.hidden = true;
const value = byId('reinstall-password-card-value');
if (value) value.textContent = '';
}
function showReinstallPasswordCard(password, generated = true) {
if (state.reinstallPasswordDismissed || typeof password !== 'string' || password === '') return false;
const card = byId('reinstall-password-card');
const value = byId('reinstall-password-card-value');
if (!card || !value) return false;
state.reinstallPassword = password;
state.reinstallPasswordDismissed = false;
value.textContent = password;
text('reinstall-password-card-title', generated
? t('reinstall.card.accepted_title') : t('reinstall.card.password_received_title'));
text('reinstall-password-card-message', generated
? t('reinstall.card.generated_message')
: t('reinstall.card.provided_message'));
text('reinstall-password-card-note', t('reinstall.card.pending_note'));
card.hidden = false;
card.focus({ preventScroll: true });
return true;
}
async function loadReinstallCredential(vm) {
if (state.reinstallPassword || state.reinstallPasswordDismissed || !vm) return;
try {
const result = await api(`${vmPath(vm)}/credential`, { method: 'POST' });
showReinstallPasswordCard(result?.password, false);
} catch {
toast(t('reinstall.credential_unavailable'), 'warning', t('reinstall.credential_notice_title'));
}
}
function syncReinstallControls(vm = selectedVm()) {
const allowed = vm?.can_operate === true;
const fields = byId('reinstall-fields');
const submit = byId('reinstall-submit');
if (fields) {
fields.inert = !allowed;
if (allowed) fields.removeAttribute('aria-disabled');
else fields.setAttribute('aria-disabled', 'true');
}
if (submit) submit.disabled = !allowed;
return allowed;
}
function trackReinstallJob(vm, result) {
observeAcceptedTask(result, { title: t('reinstall.task_title') }, {
onUpdate: () => text('reinstall-phase', t('reinstall.progress.running')),
onTerminal: task => {
void (async () => {
byId('reinstall-progress').hidden = true;
const refreshed = await loadVm(vm.api_id);
syncReinstallControls(refreshed || selectedVm());
if (taskSucceededWithoutRecovery(task)) {
await loadReinstallCredential(refreshed || vm);
if (state.reinstallPassword) text('reinstall-password-card-note', t('reinstall.card.success_note'));
return;
}
const message = taskFailureMessage(task, t('reinstall.task_failed'));
showError('reinstall-error', message);
if (state.reinstallPassword) {
if (task.effect_resolution === 'applied') {
text('reinstall-password-card-note', t('reinstall.card.applied_note'));
} else if (task.effect_resolution === 'not_applied') {
text('reinstall-password-card-note', t('reinstall.card.not_applied_note'));
} else {
text('reinstall-password-card-note', task.effect_may_have_applied || task.safe_to_resubmit === false
? t('reinstall.card.locked_note')
: t('reinstall.card.retry_note'));
}
}
toast(message, 'error', t('reinstall.task_failure_title'));
})();
},
onStop: reason => {
if (reason === 'pagehide') return;
void (async () => {
byId('reinstall-progress').hidden = true;
const refreshed = await loadVm(vm.api_id);
syncReinstallControls(refreshed || selectedVm());
showError('reinstall-error', t('reinstall.progress.observer_stopped'));
})();
},
});
}
async function openReinstall(vm, bootstrap = null) {
state.view = 'reinstall'; state.reinstallPasswordDismissed = false; clearReinstallPasswordCard(); byId('reinstall-confirm-name').value = ''; byId('reinstall-root-password').value = ''; byId('reinstall-template').value = ''; showError('reinstall-error', ''); byId('reinstall-progress').hidden = true; byId('reinstall-result').hidden = true; byId('reinstall-fields').hidden = false;
const currentName = String(vm.name ?? '');
const nameValue = byId('reinstall-confirm-name-value');
const nameInput = byId('reinstall-confirm-name');
const copyName = byId('reinstall-copy-name');
if (nameValue) nameValue.textContent = currentName || t('reinstall.value.not_recorded');
const syncNameConfirmation = () => {
const matches = currentName !== '' && nameInput?.value === currentName;
const hasInput = Boolean(nameInput?.value);
nameInput?.classList.toggle('is-match', matches);
nameInput?.classList.toggle('is-mismatch', hasInput && !matches);
};
if (nameInput) nameInput.oninput = syncNameConfirmation;
if (copyName) {
copyName.disabled = !currentName;
copyName.onclick = async () => {
if (!currentName) return;
try { await copyText(currentName); }
catch { toast(t('reinstall.copy_failed'), 'error'); }
};
}
const passwordCardClose = byId('reinstall-password-card-close');
const passwordCardSaved = byId('reinstall-password-card-saved');
const passwordCardCopy = byId('reinstall-password-card-copy');
if (passwordCardClose) passwordCardClose.onclick = () => clearReinstallPasswordCard(true);
if (passwordCardSaved) passwordCardSaved.onclick = () => clearReinstallPasswordCard(true);
if (passwordCardCopy) {
passwordCardCopy.onclick = async () => {
if (!state.reinstallPassword) return;
try { await copyText(state.reinstallPassword); }
catch { toast(t('reinstall.copy_failed'), 'error'); }
};
}
syncNameConfirmation();
if (!vm?.can_operate) {
byId('reinstall-fields').inert = true;
byId('reinstall-fields').setAttribute('aria-disabled', 'true');
byId('reinstall-submit').disabled = true;
showError('reinstall-error', t('reinstall.unavailable.error'));
return;
}
byId('reinstall-fields').inert = false;
byId('reinstall-fields').removeAttribute('aria-disabled');
byId('reinstall-submit').disabled = false;
if (bootstrap && Array.isArray(bootstrap.templates)) {
state.templates = bootstrapItems(bootstrap, 'templates', 'cloud_templates');
state.templateCatalogUnavailable = bootstrap.catalog_unavailable === true;
state.sshKeys = bootstrapItems(bootstrap, 'ssh_keys', 'keys');
state.selectedKeys.reinstall = '';
renderTemplateCatalog('reinstall-template');
renderKeyCards('reinstall');
return;
}
try { const resources = await api(`/api/v1/resources?vm_id=${encodeURIComponent(vm.api_id)}`); state.templates = items(resources.templates || resources.cloud_templates); renderTemplateCatalog('reinstall-template'); await loadKeys(); } catch { showError('reinstall-error', t('reinstall.error.catalog_load')); }
}
async function reinstall(event) {
event.preventDefault(); const vm = selectedVm(); if (!vm || state.mutationBusy) return;
if (byId('reinstall-confirm-name').value !== vm.name) return showError('reinstall-error', t('reinstall.error.confirm_name'));
const password = byId('reinstall-root-password').value; if (!strongPassword(password)) return showError('reinstall-error', t('reinstall.error.password_invalid'));
const template = byId('reinstall-template').value; if (!template) return showError('reinstall-error', t('reinstall.error.template_required'));
state.mutationBusy = true; byId('reinstall-submit').disabled = true;
const body = { template_id: template, confirmation_name: vm.name }; if (state.selectedKeys.reinstall) body.ssh_key_id = state.selectedKeys.reinstall; if (password) body.root_password = password;
let submitted = false;
try {
const result = await api(`${vmPath(vm)}/reinstall`, {
method: 'POST', body, expectedStatus: 202, requireTaskReceipt: true,
});
submitted = true;
showReinstallPasswordCard(password, false);
toast(t('reinstall.accepted'), 'success', t('reinstall.task_title'));
byId('reinstall-root-password').value = '';
byId('reinstall-progress').hidden = false;
text('reinstall-phase', t('reinstall.progress.accepted'));
byId('reinstall-fields').inert = false;
byId('reinstall-fields').removeAttribute('aria-disabled');
trackReinstallJob(vm, result);
}
catch (error) {
showError('reinstall-error', error?.mutationMayHaveApplied
? t('reinstall.error.submit_unknown') : t('reinstall.error.submit_failed'));
const refreshed = await loadVm(vm.api_id);
syncReinstallControls(refreshed || selectedVm());
}
finally {
delete body.root_password;
state.mutationBusy = false;
if (!submitted) byId('reinstall-progress').hidden = true;
}
}
function closeConsole() {
state.consoleToken++;
state.rfb?.disconnect();
state.rfb = null;
if (byId('console-modal')) byId('console-modal').hidden = true;
if (byId('console-password-form')) byId('console-password-form').hidden = true;
if (byId('console-password')) byId('console-password').value = '';
if (byId('console-cad')) byId('console-cad').disabled = true;
}
async function openConsole(vm) {
if (!vm?.can_operate) return toast(t('instance_detail.power.unavailable'), 'error');
closeConsole();
const token = ++state.consoleToken;
byId('console-modal').hidden = false;
text('console-title', t('instance_detail.console.window_title', { name: vm.name }));
text('console-status', t('instance_detail.console.requesting'));
const placeholder = byId('console-placeholder');
placeholder.hidden = false;
try {
const [ticket, module] = await Promise.all([
api(`${vmPath(vm)}/console-ticket`, { method: 'POST' }),
import('/cloud/vendor/novnc/core/rfb.js'),
]);
if (token !== state.consoleToken) return;
const url = new URL(ticket.websocket_path, location.href);
if (url.origin !== location.origin || url.pathname !== '/engine-console' || url.search || url.hash
|| typeof ticket.ticket !== 'string' || !/^[A-Za-z0-9_-]+$/.test(ticket.ticket)) {
throw new Error(t('instance_detail.console.invalid_ticket'));
}
url.protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
const rfb = new module.default(byId('console-stage'), url.href, {
shared: true, wsProtocols: ['cloud-ticket.' + ticket.ticket],
});
state.rfb = rfb;
rfb.scaleViewport = true;
rfb.resizeSession = false;
placeholder.hidden = true;
rfb.addEventListener('connect', () => {
if (state.rfb !== rfb) return;
text('console-status', t('instance_detail.console.connected'));
byId('console-cad').disabled = false;
});
rfb.addEventListener('disconnect', event => {
if (state.rfb !== rfb) return;
text('console-status', event.detail?.clean
? t('instance_detail.console.closed') : t('instance_detail.console.interrupted'));
byId('console-cad').disabled = true;
});
rfb.addEventListener('credentialsrequired', () => {
if (state.rfb !== rfb) return;
byId('console-password-form').hidden = false;
byId('console-password').focus();
text('console-status', t('instance_detail.console.password_prompt'));
});
} catch {
if (token === state.consoleToken) {
text('console-status', t('instance_detail.console.failed'));
placeholder.hidden = false;
}
}
}
function stateCategory(value) {
const normalized = String(value || "unknown").toLowerCase().replace(/[_\s-]+/g, "");
if (normalized === "running" || normalized === "blocked") return "running";
if (["shutoff", "stopped", "crashed"].includes(normalized)) return "stopped";
return "other";
}
function stateLabel(value) {
const normalized = String(value || "unknown").toLowerCase().replace(/[_\s-]+/g, "");
const labels = {
running: 'running', blocked: 'running', shutoff: 'stopped', stopped: 'stopped',
shutdown: 'shutting_down', crashed: 'crashed', paused: 'paused', pmsuspended: 'suspended',
nostate: 'awaiting_sync', unknown: 'awaiting_sync',
};
const key = labels[normalized] || 'awaiting_sync';
return t(`${state.view === 'detail' ? 'instance_detail' : 'instances'}.state.${key}`);
}
function detailStateDisplay(vm) {
const transition = powerTransition(vm);
if (transition) {
const labels = {
start: 'instance_detail.state.starting', shutdown: 'instance_detail.state.shutting_down',
reinstall: 'instance_detail.state.reinstalling', upgrade: 'instance_detail.state.upgrading',
locked: 'instance_detail.state.reconciling',
};
return {
label: t(labels[transition] || 'instance_detail.state.operating'), category: 'other', note: '', noteClass: '',
};
}
if (servicePaused(vm)) {
return { label: t('instance_detail.state.paused'), category: 'other', note: '', noteClass: '' };
}
const sync = String(vm?.state_sync_status || '').toLowerCase();
if (['unavailable', 'offline', 'host_offline', 'host_unreachable'].includes(sync)) {
return { label: t('instance_detail.state.sync_unavailable'), category: 'other', note: '', noteClass: 'offline' };
}
const normalized = String(vm?.state || '').toLowerCase().replace(/[_\s-]+/g, '');
if (['', 'unknown', 'nostate'].includes(normalized) || ['pending', 'never'].includes(sync)) {
const key = ['creating', 'provisioning', 'deploying'].includes(String(vm?.instance_status || ''))
? 'instance_detail.state.deploying' : 'instance_detail.state.awaiting_sync';
return { label: t(key), category: 'other', note: '', noteClass: '' };
}
const fresh = vm?.state_fresh === true || sync === 'fresh';
return {
label: stateLabel(vm.state),
category: stateCategory(vm.state),
note: fresh ? '' : t('instance_detail.state.sync_pending'),
noteClass: fresh ? '' : 'stale',
};
}
function diskLabel(vm) {
if (Array.isArray(vm.disks) && vm.disks.length) {
const size = vm.disks.reduce((sum, disk) => {
const capacity = Number(disk.capacity_gib ?? disk.size_gib ?? 0);
return sum + (Number.isFinite(capacity) && capacity > 0 ? capacity : 0);
}, 0);
if (size > 0) return `${Math.round(size * 100) / 100} GiB`;
}
if (Number.isFinite(Number(vm.disk_gib)) && Number(vm.disk_gib) > 0) return `${vm.disk_gib} GiB`;
return "—";
}
function vmSystemInfo(vm) {
const detail = state.view === 'detail';
const unavailable = t(detail ? 'instance_detail.value.unrecognized' : 'instances.value.unrecognized');
if (vm.os_source === "iso") return {
label: t(detail ? 'instance_detail.system.install_image' : 'instances.system.iso'),
value: String(vm.install_iso || unavailable),
};
if (vm.os_source === "cloud_template") return {
label: t(detail ? 'instance_detail.system.cloud_image' : 'instances.system.template'),
value: String(vm.os_name || unavailable),
};
return {
label: t(detail ? 'instance_detail.info.system' : 'instances.system.other'),
value: String(vm.os_name || unavailable),
};
}
function vmRegion(vm) {
return String(vm.region || "").trim()
|| t(state.view === 'detail' ? 'instance_detail.value.not_set' : 'instances.value.not_set');
}
function vmIp(vm, family = 4) {
const unavailable = t(state.view === 'detail'
? 'instance_detail.value.not_available' : 'instances.value.not_available');
if (vm?.public_network_valid !== true) return unavailable;
return String(family === 6 ? vm.public_ipv6 : vm.public_ipv4).trim() || unavailable;
}
function vmCreatedAt(vm) {
const value = typeof vm.created_at === "string" ? vm.created_at.trim() : "";
if (!value) return t('instance_detail.value.not_recorded');
const date = new Date(value);
if (!Number.isFinite(date.getTime())) return t('instance_detail.value.not_recorded');
return i18n.date(date.getTime());
}
function vmCreatedAgo(vm, now = Date.now()) {
const value = typeof vm.created_at === "string" ? vm.created_at.trim() : "";
if (!value) return t('instance_detail.value.not_recorded');
const created = Date.parse(value);
if (!Number.isFinite(created)) return t('instance_detail.value.not_recorded');
const elapsed = Math.max(0, now - created);
const minute = 60 * 1000;
const hour = 60 * minute;
const day = 24 * hour;
const month = 30 * day;
if (elapsed < minute) return t('instance_detail.created.just_now');
if (elapsed < hour) return t('instance_detail.created.minutes_ago', { count: Math.floor(elapsed / minute) });
if (elapsed < day) return t('instance_detail.created.hours_ago', { count: Math.floor(elapsed / hour) });
if (elapsed < month) return t('instance_detail.created.days_ago', { count: Math.floor(elapsed / day) });
return t('instance_detail.created.months_ago', { count: Math.floor(elapsed / month) });
}
function makeCell(row, className = "") {
const cell = document.createElement("td");
if (className) cell.className = className;
row.append(cell);
return cell;
}
function makeElement(tag, className, content) {
const element = document.createElement(tag);
if (className) element.className = className;
if (content !== undefined) element.textContent = String(content);
return element;
}
function makeCopyIconButton(value, label) {
const button = makeElement("button", "vm-copy-icon");
button.type = "button";
const copyLabel = t('instances.copy.value', { label });
button.title = copyLabel;
button.setAttribute("aria-label", copyLabel);
const icon = document.createElementNS("http://www.w3.org/2000/svg", "svg");
icon.setAttribute("viewBox", "0 0 24 24");
icon.setAttribute("aria-hidden", "true");
const back = document.createElementNS("http://www.w3.org/2000/svg", "rect");
for (const [name, attribute] of Object.entries({ x: "8", y: "8", width: "12", height: "12", rx: "2" })) {
back.setAttribute(name, attribute);
}
const front = document.createElementNS("http://www.w3.org/2000/svg", "path");
front.setAttribute("d", "M16 8V6a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v8a2 2 0 0 0 2 2h2");
icon.append(back, front);
button.append(icon);
button.addEventListener("click", async () => {
try {
await copyText(value);
} catch {
toast(t('instances.error.copy_short'), "error");
}
});
return button;
}
function actionButton(label, handler, options = {}) {
const button = makeElement("button", `row-button ${options.variant || ""}`, label);
button.type = "button";
button.disabled = Boolean(options.disabled);
if (options.key) button.dataset.vmAction = options.key;
if (options.title) button.title = options.title;
button.addEventListener("click", handler);
return button;
}
function renderVMs(connectionError = false) {
const all = state.vms;
const runningCount = all.filter((vm) => stateCategory(vm.state) === "running").length;
const stoppedCount = all.filter((vm) => stateCategory(vm.state) === "stopped").length;
text("stat-total", String(all.length));
text("stat-running", String(runningCount));
text("stat-stopped", String(stoppedCount));
const query = byId("search-input").value.trim().toLocaleLowerCase();
const filter = byId("state-filter").value;
const filtered = all.filter((vm) => {
const matchesText = !query || [vm.name, vm.uuid, vm.public_ipv4, vm.public_ipv6,
vm.region, vm.os_name, vm.install_iso]
.some((value) => String(value || "").toLocaleLowerCase().includes(query));
return matchesText && (filter === "all" || stateCategory(vm.state) === filter);
});
text("inventory-count", filtered.length !== all.length
? t('instances.list.count_filtered', {
filtered: filtered.length, page_count: filtered.length, total: all.length,
})
: t('instances.list.count', { page_count: filtered.length, total: all.length }));
const tbody = byId("vm-table-body");
const focusedVmId = document.activeElement?.classList.contains("vm-name-link")
? document.activeElement.dataset.vmUuid : null;
tbody.replaceChildren();
const empty = byId("empty-state");
empty.hidden = filtered.length !== 0;
if (!filtered.length) {
if (connectionError) {
text("empty-title", t('instances.empty.failed.title'));
text("empty-description", t('instances.empty.failed.body'));
} else if (all.length) {
text("empty-title", t('instances.empty.filtered.title'));
text("empty-description", t('instances.empty.filtered.body'));
} else {
text("empty-title", t('instances.empty.none.title'));
text("empty-description", t('instances.empty.none.body'));
}
return;
}
for (const vm of filtered) {
const uuid = String(vm.uuid || "");
const invalidNetwork = vm?.network_status === 'configuration_invalid';
const category = invalidNetwork ? 'other' : stateCategory(vm.state);
const row = document.createElement("tr");
const identity = makeElement("div", "vm-identity");
identity.append(makeElement("div", "vm-icon", "▣"));
const identityText = makeElement("div");
const nameLink = makeElement("a", "vm-name-link", vm.name || t('instances.value.unnamed'));
nameLink.href = vmPagePath(vm.api_id);
nameLink.dataset.vmUuid = uuid;
nameLink.setAttribute("aria-label", t('instances.manage.aria', {
name: vm.name || uuid || t('instances.value.unnamed'),
}));
identityText.append(nameLink);
const uuidRow = makeElement("span", "vm-uuid-row");
const uuidText = makeElement("span", "vm-id", uuid || t('instances.value.uuid_unknown'));
if (uuid) uuidText.title = uuid;
uuidRow.append(uuidText);
if (uuid) uuidRow.append(makeCopyIconButton(uuid, "UUID"));
identityText.append(uuidRow);
identity.append(identityText);
const identityCell = makeCell(row);
identityCell.dataset.label = t('instances.column.instance');
identityCell.append(identity);
const stateCell = makeCell(row);
stateCell.dataset.label = t('instances.column.status');
stateCell.append(makeElement("span", `state-pill ${category}`,
invalidNetwork ? t('instances.state.network_invalid') : stateLabel(vm.state)));
const regionCell = makeCell(row);
regionCell.dataset.label = t('instances.column.region');
regionCell.append(makeElement("span", "vm-metadata", vmRegion(vm)));
const system = vmSystemInfo(vm);
const systemCell = makeCell(row);
systemCell.dataset.label = system.label;
systemCell.append(makeElement("span", "vm-metadata", system.value));
const ipCell = makeCell(row);
ipCell.dataset.label = t('instances.column.address');
const addresses = makeElement("div", "vm-public-addresses");
for (const [family, label] of [[4, t('instances.address.ipv4')]]) {
const ip = vmIp(vm, family);
const ipRow = makeElement("span", "vm-ip-copy-row");
ipRow.append(makeElement("span", "vm-metadata vm-ip", ip));
if (ip !== t('instances.value.not_available')) ipRow.append(makeCopyIconButton(ip, label));
addresses.append(ipRow);
}
ipCell.append(addresses);
const spec = makeElement("div", "vm-spec");
spec.append(makeElement("strong", "", `${vm.vcpu ?? "—"} vCPU · ${vm.memory_mib ?? "—"} MiB`));
spec.append(makeElement("small", "", t('instances.spec.compute')));
const specCell = makeCell(row);
specCell.dataset.label = t('instances.column.spec');
specCell.append(spec);
const diskCell = makeCell(row);
diskCell.dataset.label = t('instances.column.disk');
diskCell.append(makeElement("span", "vm-spec", diskLabel(vm)));
tbody.append(row);
}
if (focusedVmId) {
const replacement = Array.from(tbody.querySelectorAll(".vm-name-link"))
.find((button) => button.dataset.vmUuid === focusedVmId);
replacement?.focus({ preventScroll: true });
}
}
const VM_METRICS_RANGE_SECONDS = { "1h": 3600, "24h": 86400, "7d": 604800, "30d": 2592000 };
const VM_METRIC_CHARTS = [
{ id: "cpu", titleKey: "instance_detail.metrics.cpu", unit: "percent", series: [{ key: "cpu_percent", color: "#0f9eaa" }] },
{ id: "memory", titleKey: "instance_detail.metrics.memory", unit: "memory", series: [{ key: "memory_used_mib", color: "#4781cf" }, { key: "memory_total_mib", color: "#a4b7d7", dash: "6 5" }] },
{ id: "disk", titleKey: "instance_detail.metrics.disk", unit: "rate", series: [{ key: "disk_read_bps", color: "#477dc9" }, { key: "disk_write_bps", color: "#e59c46" }] },
{ id: "network", titleKey: "instance_detail.metrics.network", unit: "rate", series: [{ key: "network_rx_bps", color: "#17a685" }, { key: "network_tx_bps", color: "#926ed0" }] },
];
let metricsLoopActive = false;
function metricViewVisible() {
return state.view === "detail" && state.detailTab === "performance" && Boolean(state.selectedVmId) && !document.hidden && !byId("dashboard-view").hidden
&& !byId("vm-workspace").hidden && !byId("vm-detail-view").hidden;
}
function stopVmMetrics() {
metricsLoopActive = false;
if (state.metricsPollTimer) window.clearTimeout(state.metricsPollTimer);
state.metricsPollTimer = null;
if (state.metricsResizeTimer) window.clearTimeout(state.metricsResizeTimer);
state.metricsResizeTimer = null;
state.metricsRequest?.controller.abort();
state.metricsRequest = null;
}
async function runVmMetricsLoop() {
if (!metricsLoopActive || !metricViewVisible()) return;
await loadVmMetrics();
if (!metricsLoopActive || !metricViewVisible() || state.metricsPollTimer) return;
state.metricsPollTimer = window.setTimeout(() => {
state.metricsPollTimer = null;
void runVmMetricsLoop();
}, 60000);
}
function startVmMetrics() {
if (!metricViewVisible() || metricsLoopActive) return;
metricsLoopActive = true;
void runVmMetricsLoop();
}
function setVmMetricsStatus(message, warning = false) {
const status = byId("vm-metrics-status");
status.textContent = message;
status.classList.toggle("warning", warning);
}
function clearVmMetrics(message) {
state.metricsPayload = null;
setVmMetricsStatus(message);
for (const chart of VM_METRIC_CHARTS) {
text(`vm-metric-${chart.id}-summary`, "—");
byId(`vm-metric-${chart.id}-plot`).replaceChildren(makeElement("p", "vm-metric-empty", message));
}
}
async function loadVmMetrics() {
if (!metricViewVisible()) return;
const vmId = state.selectedVmId;
const range = state.metricsRange;
const previous = state.metricsRequest;
if (previous?.vmId === vmId && previous.range === range) return;
previous?.controller.abort();
const request = { vmId, range, controller: new AbortController() };
state.metricsRequest = request;
setVmMetricsStatus(t('instance_detail.metrics.updating'));
try {
const payload = await api(`${vmPath()}/metrics?range=${encodeURIComponent(range)}`, {
signal: request.controller.signal,
});
if (request !== state.metricsRequest || !metricViewVisible()) return;
if (!Array.isArray(payload?.points)) {
throw new Error(t('instance_detail.metrics.load_failed'));
}
renderVmMetrics(payload);
} catch {
if (request !== state.metricsRequest || request.controller.signal.aborted || !metricViewVisible()) return;
setVmMetricsStatus(t('instance_detail.metrics.load_failed'), true);
} finally {
if (request === state.metricsRequest) state.metricsRequest = null;
}
}
function metricNumber(value) {
return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
}
function formatMetricRate(value) {
if (value === null) return t('instance_detail.metrics.no_stat');
const units = ["B/s", "KB/s", "MB/s", "GB/s", "TB/s"];
let amount = value;
let index = 0;
while (amount >= 1000 && index < units.length - 1) { amount /= 1000; index += 1; }
return `${amount.toFixed(index === 0 ? (amount < 1 && amount > 0 ? 2 : 0) : amount < 10 ? 2 : 1)} ${units[index]}`;
}
function formatMetricMemory(value) {
if (value === null) return t('instance_detail.metrics.no_stat');
return value >= 1024 ? `${(value / 1024).toFixed(value < 10240 ? 2 : 1)} GiB` : `${Math.round(value)} MiB`;
}
function formatMetricValue(value, unit) {
if (value === null) return t('instance_detail.metrics.no_stat');
if (unit === "percent") return `${value.toFixed(1)}%`;
if (unit === "memory") return formatMetricMemory(value);
return formatMetricRate(value);
}
function formatMetricTime(timestamp) {
return i18n.date(timestamp * 1000);
}
function metricSummary(chart, points) {
const latest = [...points].reverse().find((point) => chart.series.some((series) => metricNumber(point[series.key]) !== null));
if (!latest) return t('instance_detail.metrics.no_stat');
const value = (key) => metricNumber(latest[key]);
if (chart.id === "cpu") return formatMetricValue(value("cpu_percent"), "percent");
if (chart.id === "memory") return t('instance_detail.metrics.summary_memory', {
used: formatMetricMemory(value("memory_used_mib")), total: formatMetricMemory(value("memory_total_mib")),
});
if (chart.id === "disk") return t('instance_detail.metrics.summary_disk', {
read: formatMetricRate(value("disk_read_bps")), write: formatMetricRate(value("disk_write_bps")),
});
return t('instance_detail.metrics.summary_network', {
receive: formatMetricRate(value("network_rx_bps")), send: formatMetricRate(value("network_tx_bps")),
});
}
function metricChartEmptyText(chart) {
if (chart.id === "memory") return t('instance_detail.metrics.no_memory');
if (chart.id === "disk" || chart.id === "network") return t('instance_detail.metrics.no_rate');
return t('instance_detail.metrics.no_cpu');
}
function metricNiceMax(value) {
if (value <= 0) return 1;
const base = 10 ** Math.floor(Math.log10(value));
for (const step of [1, 1.5, 2, 2.5, 5, 10]) {
if (value <= step * base) return step * base;
}
return 10 * base;
}
function metricSvgElement(tag, attributes = {}) {
const element = document.createElementNS("http://www.w3.org/2000/svg", tag);
for (const [name, value] of Object.entries(attributes)) element.setAttribute(name, String(value));
return element;
}
function drawMetricChart(chart, points, start, end, intervalSeconds) {
const plot = byId(`vm-metric-${chart.id}-plot`);
const summary = metricSummary(chart, points);
text(`vm-metric-${chart.id}-summary`, summary);
const hasData = points.some((point) => chart.series.some((series) => metricNumber(point[series.key]) !== null));
if (!hasData) {
plot.replaceChildren(makeElement("p", "vm-metric-empty", metricChartEmptyText(chart)));
return;
}
const values = points.flatMap((point) => chart.series.map((series) => metricNumber(point[series.key]))).filter((value) => value !== null);
const maximum = chart.unit === "percent" ? Math.max(100, metricNiceMax(Math.max(...values))) : metricNiceMax(Math.max(...values));
// A fixed 640px viewBox shrinks axis text to ~4px inside a phone card.
const width = Math.max(240, Math.floor(plot.clientWidth || 640));
const height = Math.max(180, Math.floor(plot.clientHeight || 216));
const left = 64;
const right = 18;
const top = 14;
const bottom = 37;
const plotWidth = width - left - right;
const plotHeight = height - top - bottom;
const x = (timestamp) => left + Math.max(0, Math.min(1, (timestamp - start) / (end - start))) * plotWidth;
const y = (value) => top + (1 - Math.min(value, maximum) / maximum) * plotHeight;
const svg = metricSvgElement("svg", {
viewBox: `0 0 ${width} ${height}`,
role: "img",
"aria-label": t('instance_detail.metrics.chart_aria', {
title: t(chart.titleKey),
range: byId("vm-metrics-range").selectedOptions[0]?.textContent || t('instance_detail.metrics.current_range'),
summary,
}),
});
for (const fraction of [1, 0.5, 0]) {
const lineY = top + (1 - fraction) * plotHeight;
svg.append(metricSvgElement("line", { x1: left, x2: width - right, y1: lineY, y2: lineY, class: "vm-metric-gridline" }));
const label = metricSvgElement("text", { x: left - 8, y: lineY + 4, "text-anchor": "end", class: "vm-metric-axis-label" });
label.textContent = formatMetricValue(fraction * maximum, chart.unit);
svg.append(label);
}
for (const [fraction, anchor] of [[0, "start"], [0.5, "middle"], [1, "end"]]) {
const label = metricSvgElement("text", { x: left + fraction * plotWidth, y: height - 8, "text-anchor": anchor, class: "vm-metric-axis-label" });
label.textContent = formatMetricTime(start + fraction * (end - start));
svg.append(label);
}
const maxGap = intervalSeconds * 2.5;
for (const series of chart.series) {
const segments = [];
let segment = [];
for (const point of points) {
const value = metricNumber(point[series.key]);
if (value === null) {
if (segment.length) segments.push(segment);
segment = [];
continue;
}
if (segment.length && point.timestamp - segment[segment.length - 1].timestamp > maxGap) {
segments.push(segment);
segment = [];
}
segment.push({ timestamp: point.timestamp, value });
}
if (segment.length) segments.push(segment);
for (const group of segments) {
if (group.length > 1) {
const path = metricSvgElement("path", {
d: group.map((point, index) => `${index ? "L" : "M"}${x(point.timestamp).toFixed(2)} ${y(point.value).toFixed(2)}`).join(" "),
fill: "none", stroke: series.color, "stroke-width": 2.6,
"stroke-linecap": "round", "stroke-linejoin": "round",
...(series.dash ? { "stroke-dasharray": series.dash } : {}),
});
svg.append(path);
}
const last = group[group.length - 1];
svg.append(metricSvgElement("circle", { cx: x(last.timestamp), cy: y(last.value), r: group.length === 1 ? 3.8 : 2.8, fill: series.color }));
}
}
plot.replaceChildren(svg);
}
function renderVmMetrics(payload) {
state.metricsPayload = payload;
const intervalSeconds = Math.max(1, Number(payload.interval_seconds) || 60);
const rangeSeconds = VM_METRICS_RANGE_SECONDS[state.metricsRange];
const now = Math.floor(Date.now() / 1000);
const points = payload.points
.filter((point) => Number.isFinite(Number(point?.timestamp)) && Number(point.timestamp) >= now - rangeSeconds - intervalSeconds && Number(point.timestamp) <= now + intervalSeconds)
.map((point) => ({ ...point, timestamp: Number(point.timestamp) }))
.sort((a, b) => a.timestamp - b.timestamp);
const end = Math.max(now, points.length ? points[points.length - 1].timestamp : now);
const start = end - rangeSeconds;
const visiblePoints = points.filter((point) => point.timestamp >= start && point.timestamp <= end);
for (const chart of VM_METRIC_CHARTS) drawMetricChart(chart, visiblePoints, start, end, intervalSeconds);
if (!visiblePoints.length) {
setVmMetricsStatus(t('instance_detail.metrics.no_samples'), true);
return;
}
const latest = visiblePoints[visiblePoints.length - 1].timestamp;
// Bucket width grows for long ranges; freshness still follows the 60s
// collector cadence, not the downsampling bucket width.
const stale = end - latest > 60 * 2.5;
setVmMetricsStatus(t('instance_detail.metrics.status', {
count: visiblePoints.length,
freshness: t(stale ? 'instance_detail.metrics.history' : 'instance_detail.metrics.latest'),
time: formatMetricTime(latest),
suffix: stale ? t('instance_detail.metrics.stale_suffix') : '',
}), stale);
}
function trafficDailyViewVisible() {
return state.view === "detail" && state.detailTab === "performance" && Boolean(state.selectedVmId) && !document.hidden
&& !byId("dashboard-view").hidden && !byId("vm-workspace").hidden && !byId("vm-detail-view").hidden;
}
function stopVmTrafficDaily() {
state.trafficDailyRequest?.controller.abort();
state.trafficDailyRequest = null;
if (state.trafficDailyResizeTimer) window.clearTimeout(state.trafficDailyResizeTimer);
state.trafficDailyResizeTimer = null;
}
function setVmTrafficDailyStatus(message, warning = false) {
const status = byId("vm-traffic-daily-status");
status.textContent = message;
status.classList.toggle("warning", warning);
}
function clearVmTrafficDaily(message) {
stopVmTrafficDaily();
state.trafficDailyPayload = null;
state.trafficDailyVmId = "";
state.trafficDailyLoadedAt = 0;
setVmTrafficDailyStatus(message);
byId("vm-traffic-daily-plot").replaceChildren(makeElement("p", "vm-metric-empty", message));
}
function trafficDailyItems(payload) {
if (Array.isArray(payload)) return payload;
for (const value of [payload?.points, payload?.days, payload?.items, payload?.daily, payload?.data?.points, payload?.data?.days, payload?.data]) {
if (Array.isArray(value)) return value;
}
return null;
}
function trafficDailyDate(point) {
const value = point?.date ?? point?.day ?? point?.bucket_date ?? point?.observed_date ?? point?.day_start ?? point?.timestamp ?? point?.time;
const dateText = typeof value === "string" ? value.trim() : "";
if (/^\d{4}-\d{2}-\d{2}$/.test(dateText)) {
return { timestamp: Date.parse(`${dateText}T00:00:00Z`), label: dateText };
}
const timestamp = serviceTimestamp(value);
if (timestamp === null) return null;
const date = new Date(timestamp);
return { timestamp, label: `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}` };
}
function normalizeTrafficDailyPoints(payload) {
const values = trafficDailyItems(payload);
if (values === null) throw new Error(t('instance_detail.traffic.daily_invalid'));
const points = [];
for (const point of values) {
const date = trafficDailyDate(point);
if (!date) continue;
const download = firstNumber(point?.download_bytes, point?.rx_bytes, point?.traffic_download_bytes, point?.download, point?.rx);
const upload = firstNumber(point?.upload_bytes, point?.tx_bytes, point?.traffic_upload_bytes, point?.upload, point?.tx);
points.push({ ...date, download, upload });
}
return points.sort((a, b) => a.timestamp - b.timestamp).slice(-30);
}
function trafficDailyShortDate(point) {
return point.label.slice(5).replace("-", "/");
}
function drawVmTrafficDaily(payload) {
const plot = byId("vm-traffic-daily-plot");
const points = normalizeTrafficDailyPoints(payload);
if (!points.length) {
const message = t('instance_detail.traffic.daily_empty');
plot.replaceChildren(makeElement("p", "vm-metric-empty", message));
setVmTrafficDailyStatus(message, true);
return;
}
const values = points.flatMap(point => [point.download, point.upload]).filter(value => value !== null);
if (!values.length) {
const message = t('instance_detail.traffic.daily_no_samples');
plot.replaceChildren(makeElement("p", "vm-metric-empty", message));
setVmTrafficDailyStatus(message, true);
return;
}
const maximum = metricNiceMax(Math.max(...values));
const width = Math.max(300, Math.floor(plot.clientWidth || 800));
const height = Math.max(220, Math.floor(plot.clientHeight || 290));
const left = 68;
const right = 18;
const top = 18;
const bottom = 38;
const plotWidth = width - left - right;
const plotHeight = height - top - bottom;
const groupWidth = plotWidth / points.length;
const barWidth = Math.max(2, Math.min(12, groupWidth * .32));
const y = (value) => top + (1 - Math.min(value, maximum) / maximum) * plotHeight;
const totalDownload = points.reduce((sum, point) => sum + (point.download ?? 0), 0);
const totalUpload = points.reduce((sum, point) => sum + (point.upload ?? 0), 0);
const sampledDays = points.filter(point => point.download !== null || point.upload !== null).length;
const svg = metricSvgElement("svg", {
viewBox: `0 0 ${width} ${height}`,
role: "img",
"aria-label": t('instance_detail.traffic.daily_aria', {
days: points.length, download: formatBytes(totalDownload), upload: formatBytes(totalUpload),
}),
});
for (const fraction of [1, .5, 0]) {
const lineY = top + (1 - fraction) * plotHeight;
svg.append(metricSvgElement("line", { x1: left, x2: width - right, y1: lineY, y2: lineY, class: "vm-metric-gridline" }));
const label = metricSvgElement("text", { x: left - 8, y: lineY + 4, "text-anchor": "end", class: "vm-metric-axis-label" });
label.textContent = formatBytes(fraction * maximum);
svg.append(label);
}
points.forEach((point, index) => {
const center = left + (index + .5) * groupWidth;
for (const [value, className, offset] of [[point.download, "download", -barWidth], [point.upload, "upload", 0]]) {
if (value === null) continue;
const topY = y(value);
const bar = metricSvgElement("rect", {
x: center + offset,
y: topY,
width: barWidth,
height: Math.max(1, top + plotHeight - topY),
rx: Math.min(2, barWidth / 3),
class: `vm-traffic-daily-bar ${className}`,
});
const title = metricSvgElement("title");
title.textContent = t('instance_detail.traffic.daily_bar', {
date: point.label,
direction: t(className === "download"
? 'instance_detail.traffic.download' : 'instance_detail.traffic.upload'),
value: formatBytes(value),
});
bar.append(title);
svg.append(bar);
}
});
const labelIndexes = [...new Set([0, Math.floor((points.length - 1) / 2), points.length - 1])];
for (const index of labelIndexes) {
const anchor = index === 0 ? "start" : index === points.length - 1 ? "end" : "middle";
const label = metricSvgElement("text", { x: left + (index + .5) * groupWidth, y: height - 8, "text-anchor": anchor, class: "vm-metric-axis-label" });
label.textContent = trafficDailyShortDate(points[index]);
svg.append(label);
}
plot.replaceChildren(svg);
setVmTrafficDailyStatus(t('instance_detail.traffic.daily_summary', {
days: points.length,
sampled: sampledDays,
download: formatBytes(totalDownload),
upload: formatBytes(totalUpload),
}));
}
async function loadVmTrafficDaily(force = false) {
if (!trafficDailyViewVisible()) return;
const vmId = state.selectedVmId;
if (!force && state.trafficDailyPayload && state.trafficDailyVmId === vmId
&& Date.now() - state.trafficDailyLoadedAt < 60000) return;
if (state.trafficDailyRequest?.vmId === vmId) return;
state.trafficDailyRequest?.controller.abort();
const request = { vmId, controller: new AbortController() };
state.trafficDailyRequest = request;
setVmTrafficDailyStatus(t('instance_detail.traffic.daily_loading'));
try {
const payload = await api(`${vmPath()}/traffic/daily?days=30`, { signal: request.controller.signal });
if (request !== state.trafficDailyRequest || !trafficDailyViewVisible()) return;
state.trafficDailyPayload = payload;
state.trafficDailyVmId = vmId;
state.trafficDailyLoadedAt = Date.now();
drawVmTrafficDaily(payload);
} catch {
if (request !== state.trafficDailyRequest || request.controller.signal.aborted || !trafficDailyViewVisible()) return;
setVmTrafficDailyStatus(t('instance_detail.traffic.daily_failed'), true);
if (!state.trafficDailyPayload || state.trafficDailyVmId !== vmId) {
byId("vm-traffic-daily-plot").replaceChildren(makeElement("p", "vm-metric-empty",
t('instance_detail.traffic.daily_failed')));
}
} finally {
if (request === state.trafficDailyRequest) state.trafficDailyRequest = null;
}
}
function startVmTrafficDaily() {
if (!trafficDailyViewVisible()) return;
if (state.trafficDailyPayload && state.trafficDailyVmId === state.selectedVmId) drawVmTrafficDaily(state.trafficDailyPayload);
void loadVmTrafficDaily();
}
const TEMPLATE_FAMILY_NAMES = {
almalinux: "AlmaLinux",
debian: "Debian",
centos: "CentOS Stream",
centosstream: "CentOS Stream",
ubuntu: "Ubuntu",
};
const TEMPLATE_ICON_PATHS = {
AlmaLinux: "/cloud/almalinux-icon.svg",
Debian: "/cloud/debian-icon.svg",
"CentOS Stream": "/cloud/centos-icon.svg",
Ubuntu: "/cloud/ubuntu-icon.svg",
};
const TEMPLATE_FAMILY_ORDER = new Map([
["AlmaLinux", 0], ["Debian", 1], ["CentOS Stream", 2], ["Ubuntu", 3],
]);
function compareTemplateVersions(left, right) {
const leftParts = String(left || "0").split(".").map((part) => Number(part) || 0);
const rightParts = String(right || "0").split(".").map((part) => Number(part) || 0);
const length = Math.max(leftParts.length, rightParts.length);
for (let index = 0; index < length; index += 1) {
const difference = (leftParts[index] || 0) - (rightParts[index] || 0);
if (difference) return difference;
}
return 0;
}
function templateSystem(item) {
const id = String(item?.id || "");
const familyKey = String(item?.os_family || "").trim().toLowerCase().replace(/[\s_-]+/g, "");
const namedFamily = Object.prototype.hasOwnProperty.call(TEMPLATE_FAMILY_NAMES, familyKey)
? TEMPLATE_FAMILY_NAMES[familyKey] : "";
const idMatch = /^(alma|debian|ubuntu|centosstream)([0-9]{1,4})-/.exec(id);
const idFamily = ({ alma: "AlmaLinux", debian: "Debian", ubuntu: "Ubuntu", centosstream: "CentOS Stream" })[idMatch?.[1]] || "";
const rawIdVersion = idMatch?.[2] || "";
const idVersion = idMatch?.[1] === "ubuntu" && rawIdVersion.length === 4
? `${rawIdVersion.slice(0, 2)}.${rawIdVersion.slice(2)}` : rawIdVersion;
const family = namedFamily || idFamily || t('common.template.other_system');
const providedVersion = String(item?.os_version || "");
const version = /^[0-9]+(?:\.[0-9]+){0,2}$/.test(providedVersion) ? providedVersion : idVersion;
return { family, version };
}
function templateIcon(family, className) {
const logoPath = TEMPLATE_ICON_PATHS[family];
const icon = makeElement("span", `${className}${logoPath ? " system" : ""}`);
icon.setAttribute("aria-hidden", "true");
if (logoPath) {
const logo = makeElement("img", "template-system-logo");
logo.src = logoPath;
logo.alt = "";
icon.append(logo);
} else {
icon.textContent = "◈";
}
return icon;
}
function renderTemplateCatalogStatus(inputId, message, busy = false) {
const input = byId(inputId);
const container = byId(inputId === "vm-template" ? "vm-template-catalog" : "reinstall-template-catalog");
if (!input || !container) return;
input.value = "";
input.disabled = true;
container.setAttribute("aria-busy", String(busy));
const status = makeElement("p", "template-catalog-status", message);
status.setAttribute("role", "status");
container.replaceChildren(status);
}
function closeTemplateVersionMenus(except = null) {
document.querySelectorAll(".template-family-card[open]").forEach((card) => {
if (card !== except) card.open = false;
});
}
function bindTemplateVersionMenu(card, container) {
card.addEventListener("toggle", () => {
const deployment = container.id === 'vm-template-catalog';
const family = String(card.dataset.family || t('common.template.system_image'));
const summary = card.querySelector("summary");
const selection = card.querySelector(".template-family-selection");
if (!card.open) {
const selectedName = String(selection?.title || "");
summary?.setAttribute("aria-label", deployment
? t(selectedName ? 'deploy.template.family_change' : 'deploy.template.family_expand',
selectedName ? { family, name: selectedName } : { family })
: (selectedName
? t('reinstall.template.family_change', { family, name: selectedName })
: t('reinstall.template.family_expand', { family })));
return;
}
summary?.setAttribute("aria-label", deployment
? t('deploy.template.family_collapse', { family })
: t('reinstall.template.family_collapse', { family }));
container.querySelectorAll(".template-family-card[open]").forEach((other) => {
if (other !== card) other.open = false;
});
requestAnimationFrame(() => {
if (!card.open) return;
const option = card.querySelector('.template-version-option[aria-pressed="true"]')
|| card.querySelector(".template-version-option");
option?.focus({ preventScroll: true });
});
});
}
function updateTemplateFamilySelection(card, selectedName = "", selectedVersion = "") {
const deployment = card.closest('#vm-template-catalog') !== null;
const family = String(card.dataset.family || t('common.template.system_image'));
const summary = card.querySelector("summary");
const label = card.querySelector(".template-family-selection");
const selected = Boolean(selectedName);
const fallbackVersion = String(selectedName).startsWith(family)
? String(selectedName).slice(family.length).replace(/^[-_\s]+/, "")
: String(selectedName);
const versionLabel = String(selectedVersion || fallbackVersion).trim();
card.classList.toggle("has-selection", selected);
if (label) {
label.textContent = selected ? versionLabel : "";
label.title = selected ? selectedName : "";
}
summary?.setAttribute("aria-label", deployment
? t(selected ? 'deploy.template.family_change' : 'deploy.template.family_expand',
selected ? { family, name: selectedName } : { family })
: (selected
? t('reinstall.template.family_change', { family, name: selectedName })
: t('reinstall.template.family_expand', { family })));
}
function renderTemplateCatalog(inputId) {
const input = byId(inputId);
const container = byId(inputId === "vm-template" ? "vm-template-catalog" : "reinstall-template-catalog");
container.removeAttribute("aria-busy");
const opened = new Set(Array.from(container.querySelectorAll("details[open]"), (detail) => detail.dataset.family));
const groups = new Map();
const catalogTemplates = inputId === "vm-template"
? deploymentTemplates() : state.templates;
for (const item of catalogTemplates) {
if (!item?.id) continue;
const { family, version } = templateSystem(item);
if (!groups.has(family)) groups.set(family, []);
groups.get(family).push({ item, version });
}
if (!groups.size) {
input.value = "";
const noOffer = inputId === "vm-template" && !selectedSaleOffer();
container.replaceChildren(makeElement("p", "template-catalog-empty",
inputId === "vm-template"
? (state.templateCatalogUnavailable
? t('deploy.template.catalog_unavailable')
: noOffer
? t('deploy.template.offer_first')
: t('deploy.template.no_match'))
: state.templateCatalogUnavailable
? t('reinstall.template.catalog_unavailable')
: state.admin
? t('reinstall.template.admin_empty')
: t('reinstall.template.empty')));
input.disabled = true;
return;
}
if (!catalogTemplates.some((item) => String(item.id) === input.value)) input.value = "";
input.disabled = false;
const cards = [];
const orderedGroups = Array.from(groups.entries()).sort(([left], [right]) =>
(TEMPLATE_FAMILY_ORDER.get(left) ?? 100) - (TEMPLATE_FAMILY_ORDER.get(right) ?? 100)
|| left.localeCompare(right, i18n.locale));
for (const [family, entries] of orderedGroups) {
entries.sort((a, b) => compareTemplateVersions(b.version, a.version)
|| String(a.item.name || "").localeCompare(String(b.item.name || ""), i18n.locale));
const card = makeElement("details", "template-family-card");
card.dataset.family = family;
card.setAttribute("name", `${inputId}-family`);
card.open = opened.has(family);
bindTemplateVersionMenu(card, container);
const summary = makeElement("summary", "template-family-summary");
const selectedMark = makeElement("span", "template-family-selected-mark", "✓");
selectedMark.setAttribute("aria-hidden", "true");
const icon = templateIcon(family, "template-family-icon");
const selection = makeElement("span", "template-family-selection");
selection.setAttribute("aria-hidden", "true");
const arrow = makeElement("span", "template-family-arrow");
arrow.setAttribute("aria-hidden", "true");
const footer = makeElement("span", "template-family-footer");
footer.append(selection, arrow);
summary.append(selectedMark, icon, makeElement("strong", "", family), footer);
const versions = makeElement("div", "template-versions");
versions.setAttribute("role", "group");
versions.setAttribute("aria-label", inputId === 'vm-template'
? t('deploy.template.versions', { family }) : t('reinstall.template.versions', { family }));
for (const { item, version } of entries) {
const id = String(item.id);
const name = String(item.name || id);
const option = makeElement("button", "template-version-option");
option.type = "button";
option.dataset.templateId = id;
option.setAttribute("aria-pressed", String(input.value === id));
option.setAttribute("aria-label", inputId === 'vm-template'
? t('deploy.template.select', { name }) : t('reinstall.template.select', { name }));
option.append(makeElement("strong", "", name));
option.addEventListener("click", () => {
input.value = id;
container.querySelectorAll(".template-version-option").forEach((button) => {
button.setAttribute("aria-pressed", String(button.dataset.templateId === id));
});
container.querySelectorAll(".template-family-card").forEach((familyCard) => {
updateTemplateFamilySelection(familyCard,
familyCard === card ? name : "", familyCard === card ? version : "");
});
card.open = false;
summary.focus({ preventScroll: true });
if (inputId === "vm-template") { showError("create-error", ""); updateCreateAvailability(); }
else showError("reinstall-error", "");
});
versions.append(option);
}
card.append(summary, versions);
const selectedEntry = entries.find(({ item }) => String(item.id) === input.value);
updateTemplateFamilySelection(card,
selectedEntry ? String(selectedEntry.item.name || selectedEntry.item.id) : "",
selectedEntry?.version || "");
cards.push(card);
}
container.replaceChildren(...cards);
}
document.addEventListener("click", (event) => {
if (!(event.target instanceof Element) || !event.target.closest(".template-family-card")) {
closeTemplateVersionMenus();
}
});
document.addEventListener("focusin", (event) => {
const openCard = document.querySelector(".template-family-card[open]");
if (!openCard || (event.target instanceof Element && openCard.contains(event.target))) return;
closeTemplateVersionMenus();
});
document.addEventListener("keydown", (event) => {
if (event.key !== "Escape") return;
const openCard = document.querySelector(".template-family-card[open]");
if (!openCard) return;
closeTemplateVersionMenus();
openCard.querySelector("summary")?.focus({ preventScroll: true });
});
async function initializeSession(view, bootstrapUser = null) {
state.view = view;
if (bootstrapUser && typeof bootstrapUser === 'object') {
if (bootstrapUser.authenticated === false) { location.assign('/auth/login'); return false; }
applyCloudUser(bootstrapUser);
byId('logout-button')?.addEventListener('click', () => location.assign('/user/logout'));
return true;
}
const session = await api('/api/v1/session');
if (session.authenticated === false) { location.assign('/auth/login'); return false; }
applyCloudUser(session);
byId('logout-button')?.addEventListener('click', () => location.assign('/user/logout'));
return true;
}
async function selectVmByApiId(apiId, bootstrapVm = null) {
if (bootstrapVm && typeof bootstrapVm === 'object') {
const vm = normalizeVm(bootstrapVm);
if (!vm.api_id || String(vm.api_id) !== String(apiId || '')) {
throw new Error(vmPageText('instance_detail.error.vm_data_invalid', 'reinstall.error.vm_data_invalid'));
}
state.vms = [vm];
state.selectedVmId = vm.uuid;
return vm;
}
const vm = await loadVm(apiId, true);
if (!vm) throw new Error(vmPageText('instance_detail.error.vm_unavailable', 'reinstall.error.vm_unavailable'));
return vm;
}
function bindPageCleanup() {
window.addEventListener('pagehide', () => {
clearCredential();
clearReinstallPasswordCard();
stopVmMetrics();
stopVmTrafficDaily();
closeConsole();
state.resourceController?.abort();
vmStatusGeneration += 1;
vmStatusRequest?.controller.abort();
vmStatusRequest = null;
for (const observer of activeTaskObservers) observer.stop('pagehide');
activeTaskObservers.clear();
});
}
export {
CLOUD_PATHS, VM_DETAIL_TABS, api, bindPageCleanup, buy, byId, clearCredential,
clearVmMetrics, clearVmTrafficDaily, closeConsole, copyText, credential,
drawVmTrafficDaily, hydrateVmDetailBootstrap, initializeSession,
loadGlobalTemplates, loadKeys, loadVmMetrics, loadVmTrafficDaily,
loadVm, loadVmStatus, loadVms, navigate, openCreate, openReinstall, reinstall,
readBootstrap, renderVMs, renderVmDetail, renderVmMetrics, selectVmByApiId, selectedVm,
setVmDetailTab, showError, state, stopVmMetrics,
stopVmTrafficDaily, toast, trafficDailyViewVisible, vmIp,
vmPagePath,
};