{"format":"rivetin-package-v1","manifest":{"manifestVersion":1,"id":"rivetin-disk-smart-info","version":"0.1.6","name":{"zh-CN":"磁盘健康展示","en-US":"Disk SMART information"},"description":{"zh-CN":"CloudTower 4.9.0 受控验收候选：物理盘 SMART 与每日历史、本地化和劣化风险；真实主机采集尚未验收。","en-US":"CloudTower 4.9.0 controlled acceptance candidate: localized disk SMART, daily history and deterioration. Live host collection remains unverified."},"author":"Rivetin contributors","license":"MIT","repository":"https://github.com/sephirothchang/rivetin","homepage":"https://github.com/sephirothchang/rivetin/tree/main/plugins/rivetin-disk-smart-info","compatibility":{"schemaVersion":2,"frameworkApi":1,"frameworkMinVersion":"0.2.0","frameworkMaxVersionExclusive":"0.3.0","tower":"CloudTower 4.9.0 controlled candidate; real SMART collection remains unverified.","towerBuilds":["4.9.0"],"smtx":"none"},"frontend":{"format":"rivetin-global-v1","entry":"web/plugin.js"},"permissions":["inventory.read","ssh.channel.use","disk.smart.read"],"locales":["zh-CN","en-US"],"configuration":{"version":1,"schema":{"type":"object","additionalProperties":false,"properties":{"version":{"type":"integer","enum":[1]},"enabled":{"type":"boolean"}},"required":["version","enabled"]},"defaults":{"version":1,"enabled":true}},"lifecycle":{"reset":"defaults","uninstall":"retain-config"},"releaseNotes":{"zh-CN":"0.1.6：明确显示磁盘采集命令范式、目标类别、新鲜主机库存参数来源及 all/custom 逐盘展开边界。用途声明不绑定固定设备路径，不增加执行命令或权限；物理盘样本及每日采集仍待真实环境测试。","en-US":"0.1.6: show the disk collection template, category, fresh host inventory argument source and all/custom per-disk expansion. The declaration selects no fixed path and adds no executable operation or permission. Physical samples and daily collection await real-environment testing."},"ssh":{"version":1,"commands":[{"id":"daily-smart","operation":"disk.smart.read","purpose":{"zh-CN":"读取各目标主机授权物理盘 SMART，按策略逐盘展开并保留人工审批。参数要求来自本机新鲜库存；旧v1仅原可信映射待核验，不自动扩权。命令范式：sudo -n -- /usr/sbin/smartctl --json=c --all <disk>","en-US":"Read each target host's authorized physical disks under all/custom policy and administrator approval. Require fresh host inventory; legacy v1 uses configured mappings pending verification without automatic widening. Template: sudo -n -- /usr/sbin/smartctl --json=c --all <disk>"},"hostScope":"configured","deviceScope":"configured","intervalSeconds":86400}]}},"files":[{"path":"web/plugin.js","sha256":"6c80bf2501df73cf5443a24684a1007f139cf792e474e457c727da7bacb1e3eb","data":"(()=>{"use strict";const e={d:(t,n)=>{for(var r in n)e.o(n,r)&&!e.o(t,r)&&Object.defineProperty(t,r,{enumerable:!0,get:n[r]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r:e=>{Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}};let t={};e.r(t),e.d(t,{default:()=>_e});const n="rivetin-disk-smart-info",r="/api/rivetin/v1/config";function o(e){if(!e||"enabled,version"!==Object.keys(e).sort().join()||1!==e.version||"boolean"!=typeof e.enabled)throw new Error("INVALID_SETTINGS");return{version:1,enabled:e.enabled}}const a={id:n,defaults:function(e){return void 0===e?{version:1,enabled:!0}:o(e)},validate:o,equal:(e,t)=>e.version===t.version&&e.enabled===t.enabled,seed:e=>e},i="rivetin.personal.v1",s=/^rivetin-[a-z0-9]+(?:-[a-z0-9]+)*$/,l=e=>"string"==typeof e&&e.length<=100&&s.test(e),d="/api/rivetin/v1";function c(e){try{const t=JSON.parse(e.localStorage?.getItem("token")||"null")?.value;if("string"==typeof t&&t.length<8192&&!/[\r\n]/.test(t))return{Authorization:t}}catch{}return{}}function u(e,t){if(!e||!Number.isSafeInteger(e.revision)||e.revision<0||null!==e.updatedAt&&"string"!=typeof e.updatedAt)throw new Error("INVALID_CONFIG_RESPONSE");return{...e,settings:t(e.settings)}}function p(e,t,n="/api/rivetin/v1/config"){const{defaults:r,validate:o}=t,a=function(e){if(!l(e))throw new Error("INVALID_PLUGIN_ID");return e}(t.id),i=new URL(n,e.location.origin);if(i.origin!==e.location.origin)throw new Error("CONFIGURATION_ORIGIN_MISMATCH");if("/api/rivetin/v1/config"!==i.pathname||i.search)throw new Error("INVALID_CONFIGURATION_ENDPOINT");const s=function(e){const t=async(t,n="GET",r,{signal:o}={})=>{if("string"!=typeof t||!t.startsWith("/")||t.startsWith("//"))throw new Error("INVALID_API_ROUTE");const a=new URL(t,"http://rivetin.invalid").searchParams.get("pluginId");if(null!==a&&!l(a)||r&&"object"==typeof r&&Object.hasOwn(r,"pluginId")&&!l(r.pluginId))throw new Error("INVALID_PLUGIN_ID");return function(e){if(!e.response.ok){const t=new Error(/^[A-Z][A-Z0-9_]{0,99}$/.test(e.value?.error||"")?e.value.error:404===e.response.status?"NOT_FOUND":"REQUEST_FAILED");throw t.code=t.message,t.status=e.response.status,t}return e.value}(await async function(t,n="GET",r,o){const a=new AbortController,i=setTimeout(()=>a.abort(),8e3),s=()=>a.abort();o?.aborted&&a.abort(),o?.addEventListener("abort",s,{once:!0});try{const o=await e.fetch(t,{method:n,credentials:"same-origin",cache:"no-store",redirect:"error",signal:a.signal,headers:{...c(e),...void 0!==r?{"Content-Type":"application/json"}:{}},...void 0!==r?{body:"string"==typeof r?r:JSON.stringify(r)}:{}});let i;try{i=await o.json()}catch{if(404===o.status)return{response:o,value:null};throw new Error("INVALID_API_RESPONSE")}return{response:o,value:i}}finally{clearTimeout(i),o?.removeEventListener("abort",s)}}(d+t,n,r,o))};return t.assetUrl=async(e,t)=>{if(!l(e.id))throw new Error("INVALID_PLUGIN_ID");return`${d}/assets/${e.id}/${e.packageId}/${t}`},t}(e);async function p(e,t){const n=await s("/config",e,t?{pluginId:a,settings:t}:void 0);if(1!==n?.version||!n.plugins||Array.isArray(n.plugins))throw new Error("INVALID_CONFIG_RESPONSE");if(n.errors?.[a])throw new Error("CONFIGURATION_UNAVAILABLE");return u(Object.hasOwn(n.plugins,a)?n.plugins[a]:{revision:0,updatedAt:null,settings:r()},o)}return{load:()=>p("GET"),save:e=>p("PUT",e)}}new WeakMap;const _=e=>e&&"object"==typeof e&&!Array.isArray(e),A=e=>"string"==typeof e?e.slice(0,160):"";function m(e){return"number"==typeof e?Number.isSafeInteger(e)&&e>=0?String(e):null:"string"==typeof e&&/^\d{1,40}$/.test(e)?BigInt(e).toString():null}const h=(e,t)=>m(e?.[`${t}_s`])??m(e?.[t]),T=e=>"number"==typeof e&&Number.isFinite(e)?e:null,f={unknown:-1,normal:0,yellow:1,red:2,darkred:3},g=e=>e.reduce((e,t)=>f[t]>f[e]?t:e,"unknown"),E=new Map([["Reallocated_Sector_Ct",5],["Reallocated_Event_Count",196],["Current_Pending_Sector",197],["Offline_Uncorrectable",198],["Reported_Uncorrect",187],["UDMA_CRC_Error_Count",199]]);function S(e){if(!_(e))throw new Error("INVALID_SMART_DOCUMENT");const t=e.smartctl?.exit_status;if(void 0!==t&&(!Number.isInteger(t)||t<0||t>255||7&t))throw new Error("SMART_COLLECTION_FAILED");if(!1===e.smart_support?.available||!1===e.smart_support?.enabled)throw new Error("SMART_UNAVAILABLE");const n=[];function r(e,t,r,o="",a={}){n.push({id:e,name:t,value:r,unit:o,direction:null,risk:null===r?"unknown":"normal",reason:"informational",...a})}if("boolean"==typeof e.smart_status?.passed||8&t){const n=!0===e.smart_status?.passed&&!(8&t);r("health","health",n?"1":"0","",{risk:n?"normal":"darkred",reason:n?"informational":"failed"})}16&t?r("ata_threshold_status","ata_threshold_status","1","",{risk:"darkred",reason:"threshold"}):32&t&&r("ata_threshold_status","ata_threshold_status","1","",{risk:"red",reason:"historical"}),128&t&&r("self_test_errors","self_test_errors","1","",{risk:"yellow",reason:"historical"}),null!==T(e.temperature?.current)&&r("temperature","temperature",String(e.temperature.current),"°C"),void 0===e.power_on_time?.hours&&void 0===e.power_on_time?.hours_s||r("power_on_hours","power_on_hours",h(e.power_on_time,"hours"),"h"),void 0===e.power_cycle_count&&void 0===e.power_cycle_count_s||r("power_cycles","power_cycles",h(e,"power_cycle_count"));const o=e.nvme_smart_health_information_log;if(_(o)){for(const e of["critical_warning","available_spare","percentage_used","media_errors","num_err_log_entries","unsafe_shutdowns","data_units_read","data_units_written","power_on_hours","power_cycles"]){if(void 0===o[e]&&void 0===o[`${e}_s`])continue;if(n.some(t=>t.id===e))continue;const t=h(o,e),a=null===t?null:BigInt(t),i={};if("critical_warning"===e&&null!==a&&Object.assign(i,{risk:0n===a?"normal":"darkred",reason:0n===a?"informational":"critical"}),"percentage_used"===e&&null!==a&&Object.assign(i,{direction:"up",risk:a>=100n?"darkred":a>=90n?"red":a>=80n?"yellow":"normal",reason:a>=80n?"endurance":"informational"}),"available_spare"===e&&null!==a){const e=h(o,"available_spare_threshold");Object.assign(i,{direction:"down",threshold:e,risk:null!==e&&a<BigInt(e)?"darkred":"normal",reason:null!==e&&a<BigInt(e)?"threshold":"informational"})}"media_errors"===e&&null!==a&&Object.assign(i,{direction:"up",risk:a>0n?"red":"normal",reason:a>0n?"counter":"informational",counter:!0}),r(e,e,t,["percentage_used","available_spare"].includes(e)?"%":"power_on_hours"===e?"h":"",i)}n.some(e=>"temperature"===e.id)||null===T(o.temperature)||r("temperature","temperature",String(o.temperature),"°C")}const a=e.ata_smart_attributes?.table;if(void 0!==a&&(!Array.isArray(a)||a.length>256))throw new Error("INVALID_ATA_TABLE");const i=new Set;for(const e of a||[]){if(!_(e)||!Number.isInteger(e.id)||e.id<1||e.id>255||i.has(e.id))throw new Error("INVALID_ATA_ATTRIBUTE");i.add(e.id);const t=A(e.name)||`Attribute_${e.id}`,n=T(e.value),o=T(e.thresh),a=h(e.raw,"value"),s=E.get(t)===e.id,l=null!==n&&null!==o&&o>0&&n<=o,d="string"==typeof e.when_failed&&!["","-"].includes(e.when_failed.trim());let c=null===a&&null===n?"unknown":"normal",u="vendor";l||"now"===e.when_failed?(c="darkred",u="threshold"):d?(c="red",u="historical"):s&&null!==a&&BigInt(a)>0n&&(c="UDMA_CRC_Error_Count"===t?"yellow":"red",u="counter"),r(`ata:${e.id}`,t,a,"",{normalized:n,worst:T(e.worst),threshold:o,rawText:A(e.raw?.string),direction:s?"up":null,counter:s,risk:c,reason:u})}if(void 0!==e.scsi_grown_defect_list||void 0!==e.scsi_grown_defect_list_s){const t=h(e,"scsi_grown_defect_list");r("scsi_grown_defect_list","scsi_grown_defect_list",t,"",{direction:"up",counter:!0,risk:null===t?"unknown":BigInt(t)>0n?"red":"normal",reason:null!==t&&BigInt(t)>0n?"counter":"informational"})}for(const t of["read","write","verify"]){const n=e.scsi_error_counter_log?.[t];if(!n||void 0===n.total_uncorrected_errors&&void 0===n.total_uncorrected_errors_s)continue;const o=h(n,"total_uncorrected_errors");r(`scsi_${t}_errors`,`scsi_${t}_errors`,o,"",{direction:"up",counter:!0,risk:null===o?"unknown":BigInt(o)>0n?"red":"normal",reason:null!==o&&BigInt(o)>0n?"counter":"informational"})}if(!n.length)throw new Error("SMART_UNAVAILABLE");return{protocol:o?"NVMe":a?"ATA":["ATA","NVMe","SCSI"].includes(e.device?.protocol)?e.device.protocol:"Unknown",metrics:n,exitStatus:t??null}}function I(e,t){const n=new Map((t||[]).map(e=>[e.id,e]));return e.map(e=>{const t=n.get(e.id);let r=null,o=null,a=null,i="no-baseline",s=e.risk,l=e.reason;if(t&&e.name===t.name&&null!==e.value&&null!==t.value&&/^\d+$/.test(e.value)&&/^\d+$/.test(t.value)){const n=BigInt(e.value)-BigInt(t.value);r=n.toString(),i=0n===n?"unchanged":"changed","up"===e.direction&&n<0n?i="counter-reset":e.direction&&("up"===e.direction?n>0n:n<0n)&&(o=(n<0n?-n:n).toString(),i="deteriorated",s=g([s,e.counter&&"red"===e.risk?"darkred":"yellow"]),"darkred"!==e.risk&&(l="increased"))}return t?.name===e.name&&null!==e.normalized&&void 0!==e.normalized&&null!==t.normalized&&void 0!==t.normalized&&e.normalized<t.normalized&&(i="deteriorated",o=String(t.normalized-e.normalized),a="normalized",s=g([s,"yellow"]),"darkred"!==e.risk&&(l="normalized")),{...e,delta:r,deterioration:o,deteriorationKind:a,trend:i,risk:s,reason:l}})}const w=e=>"string"==typeof e&&/^(?:VMware|Virtual[_ ]disk)/i.test(e.trimStart());function v(e,t=Date.now()){if(!e||"string"!=typeof e.diskId||!/^[A-Za-z0-9_-]{1,128}$/.test(e.diskId)||!w(e.model))throw new Error("VIRTUAL_DEMO_MODEL_UNVERIFIED");const n=S({smartctl:{exit_status:0},smart_status:{passed:!0},temperature:{current:35},power_on_time:{hours:2400},.../nvme/i.test(e.model)?{nvme_smart_health_information_log:{critical_warning:0,available_spare:100,available_spare_threshold:10,percentage_used:12,media_errors:0}}:{device:{protocol:"ATA"},ata_smart_attributes:{table:[{id:5,name:"Reallocated_Sector_Ct",value:100,worst:100,thresh:10,raw:{value:0}},{id:197,name:"Current_Pending_Sector",value:100,worst:100,thresh:0,raw:{value:0}},{id:199,name:"UDMA_CRC_Error_Count",value:200,worst:200,thresh:0,raw:{value:0}}]}}}),r=I(n.metrics,null);return{virtualDemo:!0,inventory:{diskId:e.diskId,model:e.model.slice(0,160)},example:{...n,metrics:r,risk:g(r.map(e=>e.risk)),status:"ok",source:"local-virtual-demo",generatedAt:new Date(t).toISOString()},hasMore:!1}}const b=e=>"string"==typeof e&&/^[A-Za-z0-9_-]{1,128}$/.test(e),k=(e,t)=>Boolean(e&&t&&["diskId","hostId","deviceId","generation"].every(n=>e[n]===t[n])),C=e=>"string"==typeof e&&/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d{1,3})?Z$/.test(e)&&Number.isFinite(Date.parse(e))&&new Date(e).toISOString().slice(0,19)===e.slice(0,19),R=new Set(["mock","host-smartctl"]),N=new Set(["SMART_COLLECTION_FAILED","SMART_UNAVAILABLE","SMART_UNSUPPORTED","SMART_INVALID_DATA","SMART_DEVICE_CHANGED","SMART_IDENTITY_MISMATCH","SMART_EXECUTION_TIMEOUT","SMART_EXECUTION_CANCELLED","SMART_OUTPUT_INVALID"]),y=new Set(["SMART_NO_SAMPLE","SMART_DISK_UNBOUND","SMART_COLLECTION_FAILED","SMART_UNAVAILABLE","SMART_UNSUPPORTED","SMART_INVALID_DATA","SMART_DEVICE_CHANGED","SMART_IDENTITY_MISMATCH","SMART_EXECUTION_TIMEOUT","SMART_EXECUTION_CANCELLED","SMART_OUTPUT_INVALID"]),L=new Set(["SMART_GENERATION_CHANGED","SMART_HISTORY_CURSOR_STALE","SMART_BINDING_CHANGED","SMART_DISK_FORBIDDEN","AUTHENTICATION_REQUIRED","SMART_PLUGIN_DISABLED",...y]),M=e=>[e?.code,e?.message].find(e=>L.has(e))||"SMART_READ_FAILED",O=e=>{if(e.aborted)throw new Error("REQUEST_CANCELLED")},D=e=>["ok","stale"].includes(e.status);function U(e,t,n=Date.now()){if(!(e&&1===e.schemaVersion&&R.has(e.source)&&k(e.identity,t)&&["ok","stale","unavailable","unsupported"].includes(e.status)))throw new Error("INVALID_SMART_RESPONSE");if(!(void 0===e.gapCode||D(e)&&N.has(e.gapCode)))throw new Error("INVALID_SMART_RESPONSE");const r=C(e.collectedAt)&&Date.parse(e.collectedAt)<=n+3e5;if(!D(e)){if(null!==e.collectedAt&&!r)throw new Error("INVALID_SMART_RESPONSE");return{schemaVersion:1,source:e.source,status:e.status,identity:t,collectedAt:e.collectedAt,code:y.has(e.code)?e.code:"SMART_COLLECTION_FAILED",metrics:[],risk:"unknown"}}if(!r||!e.smart||JSON.stringify(e.smart).length>524288)throw new Error("INVALID_SMART_RESPONSE");const o=S(e.smart),a="stale"===e.status||n-Date.parse(e.collectedAt)>1296e5?"stale":"ok";return{schemaVersion:1,source:e.source,status:a,identity:t,collectedAt:e.collectedAt,...void 0===e.gapCode?{}:{gapCode:e.gapCode},...o,risk:g(o.metrics.map(e=>e.risk))}}function H(e,t){const n=D(e)&&t.find(t=>D(t)&&k(t.identity,e.identity)&&Date.parse(t.collectedAt)<Date.parse(e.collectedAt))||null,r=I(e.metrics,n?.metrics);return{sample:{...e,metrics:r,risk:g(r.map(e=>e.risk))},previous:n}}async function x(e,t,n,r,o=Date.now()){if(t.virtualDemo)throw new Error("VIRTUAL_DEMO_HAS_NO_HISTORY");O(r);const a=await e.readHistory({identity:t.identity,limit:30,cursor:n,signal:r});if(O(r),!a||1!==a.schemaVersion||a.source!==t.latest.source||!k(a.identity,t.identity)||!Array.isArray(a.items)||a.items.length>30||!(null===a.nextCursor||"string"==typeof a.nextCursor&&a.nextCursor.length>0&&a.nextCursor.length<=4096)||null!==a.nextCursor&&(a.nextCursor===n||0===a.items.length))throw new Error("INVALID_HISTORY_RESPONSE");const i=n?t.history:[],s=new Set(i.map(e=>e.collectedAt.slice(0,10))),l=a.items.map(e=>{const n=U(e,t.identity,o);if(n.source!==a.source)throw new Error("HISTORY_SOURCE_MISMATCH");if(!n.collectedAt)throw new Error("INVALID_HISTORY_RESPONSE");const r=n.collectedAt.slice(0,10);if(s.has(r))throw new Error("DUPLICATE_HISTORY_TIMESTAMP");return s.add(r),n});if(n&&l.some(e=>Date.parse(e.collectedAt)>=Date.parse(i.at(-1)?.collectedAt)))throw new Error("INVALID_HISTORY_ORDER");const d=[...i,...l].sort((e,t)=>Date.parse(t.collectedAt)-Date.parse(e.collectedAt));if(d.length>365||365===d.length&&null!==a.nextCursor)throw new Error("INVALID_HISTORY_RESPONSE");const{sample:c,previous:u}=H(t.latest,d);return{...t,latest:c,previous:u,history:d,historyUnavailable:!1,nextCursor:a.nextCursor,hasMore:null!==a.nextCursor}}function B(e){const t=function(e){try{const[t,n=""]=e.location.hash.slice(1).split("?");if(!/^\/(clusters|hosts)\/[A-Za-z0-9_-]{1,128}\/?$/.test(t))return null;const r=new URLSearchParams(n),o=JSON.parse(r.get("sidebar"));return"disks"===JSON.parse(r.get("view"))&&"disk"===o?.type&&b(o.id)?o.id:null}catch{return null}}(e);if(!t)return null;const n=[...e.document.querySelectorAll(".drawer-content-inner")].filter(e=>!e.closest('[hidden],[aria-hidden="true"]'));if(1!==n.length)return null;const r=n[0],o=r.querySelector(".detail-tabs");if(!o||1!==r.querySelectorAll(".detail-tabs").length)return null;const a=o.closest(".detail-sidebar-header");let i;if(a){const e=a.parentElement,t=a.nextElementSibling;if(i=t?.nextElementSibling,!(e&&r.contains(e)&&o.parentElement===a&&1===r.querySelectorAll(".detail-sidebar-header").length&&t?.matches(".tab-border-bottom")&&i?.matches(".tab-content")&&1===r.querySelectorAll(".tab-content").length))return null;const n=[...e.children].filter(e=>!e.matches("#pk-smart-info-panel[data-pk-smart-panel]"));if(3!==n.length||n[0]!==a||n[1]!==t||n[2]!==i)return null}else if(i=o.nextElementSibling,r.querySelector(".detail-sidebar-header")||!i?.matches(".detail-tab-content,.detail-content"))return null;const s=[...e.document.querySelectorAll("tr[data-row-key]")].filter(e=>e.getAttribute("data-row-key")===t),l=1===s.length?s[0].querySelector('td[unique="path"],td.cell_path'):null,d=r.querySelector(".title-wrapper .header-title"),c=l?.textContent.trim();return c&&d?.textContent.trim()===c&&/^\/dev\/[A-Za-z0-9/_-]{1,100}$/.test(c)?{diskId:t,path:c,root:r,tabs:o,content:i}:null}const V=e=>"string"==typeof e&&/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(e),P=new Set(["running","succeeded","failed","unknown"]),G=new Set(["SMART_DISK_UNBOUND","SMART_GENERATION_CHANGED","SMART_BINDING_CHANGED","SMART_DISK_FORBIDDEN","SMART_PLUGIN_DISABLED","SMART_COLLECTION_FAILED","SMART_COLLECTION_BUSY","SMART_COLLECTION_UNAVAILABLE","SMART_COLLECTION_WAIT_TIMEOUT","SMART_COLLECTION_UNKNOWN","SMART_COLLECTION_INTERRUPTED","SMART_UNSUPPORTED","SMART_OUTPUT_INVALID","SMART_IDENTITY_MISMATCH","SMART_PROFILE_UNAVAILABLE","SMART_DEVICE_UNAVAILABLE","SSH_CHANNEL_DISABLED","SSH_TARGET_UNAVAILABLE","SSH_DEVICE_UNAVAILABLE","SSH_TRANSPORT_UNAVAILABLE","SSH_EXECUTION_TIMEOUT","SSH_EXECUTION_CANCELLED","SMART_EXECUTION_TIMEOUT","SMART_EXECUTION_CANCELLED","SSH_REGISTRATION_CHANGED","SSH_CONCURRENCY_LIMIT","AUTHENTICATION_REQUIRED","ADMIN_REQUIRED","SMART_BATCH_NO_TARGETS","SMART_BATCH_NO_APPROVED_TARGETS","SMART_BATCH_TARGET_LIMIT","SMART_BATCH_NOT_APPROVED","SMART_BATCH_AMBIGUOUS_COMMAND","SMART_BATCH_SNAPSHOT_CHANGED","SMART_BATCH_FORBIDDEN","SMART_BATCH_TARGET_UNAVAILABLE","SMART_BATCH_CONFLICT","SMART_BATCH_DEADLINE","SMART_BATCH_INTERRUPTED","SMART_BATCH_CHILD_UNKNOWN","SMART_BATCH_BUSY","SMART_BATCH_CAPACITY_EXCEEDED","SMART_BATCH_NOT_FOUND","SMART_BATCH_ACCESS_CHANGED","SMART_BATCH_ACCESS_UNAVAILABLE","SMART_BATCH_ACCESS_TIMEOUT","SMART_COLLECTION_SNAPSHOT_CHANGED"]);function $(e){if("function"==typeof e?.randomUUID)return e.randomUUID();if("function"!=typeof e?.getRandomValues)throw new Error("SMART_COLLECTION_UNAVAILABLE");const t=e.getRandomValues(new Uint8Array(16));t[6]=15&t[6]|64,t[8]=63&t[8]|128;const n=[...t].map(e=>e.toString(16).padStart(2,"0")).join("");return`${n.slice(0,8)}-${n.slice(8,12)}-${n.slice(12,16)}-${n.slice(16,20)}-${n.slice(20)}`}function F(e){for(const t of[e?.code,e?.message]){if("SSH_TARGET_NOT_APPROVED"===t)return"SSH_APPROVAL_REQUIRED";if("SSH_ADMIN_REQUIRED"===t)return"ADMIN_REQUIRED";if("SMART_COLLECTION_CONCURRENCY_LIMIT"===t)return"SMART_COLLECTION_BUSY";if("string"==typeof t&&/^SSH_APPROVAL_[A-Z_]+$/.test(t))return"SSH_APPROVAL_REQUIRED";if(G.has(t))return t}return"SMART_COLLECTION_UNKNOWN"}const z=e=>["SMART_GENERATION_CHANGED","SMART_BINDING_CHANGED","SMART_DISK_FORBIDDEN","SMART_PLUGIN_DISABLED","AUTHENTICATION_REQUIRED","ADMIN_REQUIRED","SMART_BATCH_FORBIDDEN","SMART_BATCH_ACCESS_CHANGED"].includes(e);function j(e,t){if(!e||1!==e.schemaVersion||!V(e.operationId)||t&&e.operationId!==t||!P.has(e.status))throw new Error("INVALID_COLLECTION_RESPONSE");return{schemaVersion:1,operationId:e.operationId,status:e.status,...void 0===e.code?{}:{code:F({code:e.code})}}}const q=()=>Object.assign(new Error("REQUEST_CANCELLED"),{name:"AbortError",code:"REQUEST_CANCELLED"});async function Y(e,{identity:t,requestId:n,signal:r,onProgress:o=()=>{},timeoutMs:a=45e3,intervalMs:i=1500,validate:s=j}){if(!e||"function"!=typeof e.collect||"function"!=typeof e.collection||!V(n))throw new Error("SMART_COLLECTION_UNAVAILABLE");if(r.aborted)throw q();const l=new AbortController;let d,c,u;const p=e=>({schemaVersion:1,operationId:d?.operationId??null,status:"unknown",code:e}),_=()=>{if(l.signal.aborted)throw q()},A=()=>new Promise((e,t)=>{const n=setTimeout(()=>{l.signal.removeEventListener("abort",r),e()},i),r=()=>{clearTimeout(n),l.signal.removeEventListener("abort",r),t(q())};l.signal.addEventListener("abort",r,{once:!0}),l.signal.aborted&&r()}),m=async()=>{d=s(await e.collect({identity:t,requestId:n,signal:l.signal})),_(),o(d);for(let n=0;"running"===d.status&&n<30;n++)await A(),_(),d=s(await e.collection({identity:t,operationId:d.operationId,signal:l.signal}),d.operationId),_(),o(d);return"running"===d.status?p("SMART_COLLECTION_WAIT_TIMEOUT"):d};try{return await Promise.race([m(),new Promise(e=>{c=setTimeout(()=>{e(p("SMART_COLLECTION_WAIT_TIMEOUT")),l.abort()},a)}),new Promise((e,t)=>{u=()=>{t(q()),l.abort()},r.addEventListener("abort",u,{once:!0}),r.aborted&&u()})])}catch(e){if(r.aborted)throw q();const t=F(e);if(z(t))throw Object.assign(new Error(t),{code:t});return{...p(t),status:!d&&Number.isInteger(e.status)&&e.status>=400&&e.status<500?"failed":"unknown"}}finally{clearTimeout(c),r.removeEventListener("abort",u),l.abort()}}const W=(e,t,n)=>"en-US"===e?n:t;function K(e,t){if("running"===e.status)return W(t,"正在采集当前磁盘…离开此页只停止页面等待，不保证远端任务取消。","Collecting this disk… Leaving this page only stops waiting; the remote task may continue.");if("succeeded"===e.status)return W(t,"采集任务已完成。","Collection completed.");if("SMART_COLLECTION_WAIT_CANCELLED"===e.code)return W(t,"已停止页面等待，后台采集可能继续；请重新读取或联系管理员核实。","Stopped waiting. Collection may continue in the background; reload or ask an administrator to verify.");const n={SMART_BATCH_NO_TARGETS:["没有已绑定的磁盘，未发起全局采集。请配置可信设备绑定。","No disks are bound. Global collection was not started. Configure trusted device bindings."],SMART_BATCH_NO_APPROVED_TARGETS:["没有获批的采集目标，未发起全局采集。请联系管理员审核。","No collection targets are approved. Global collection was not started. Ask an administrator to review approvals."],SMART_BATCH_TARGET_LIMIT:["采集目标超过 100 个，未发起批次；不会静默忽略超出部分。请联系管理员调整范围。","There are more than 100 targets. No batch was started or silently truncated. Ask an administrator to adjust the scope."],SMART_BATCH_NOT_APPROVED:["该目标未获得有效采集授权，未执行。","This target lacks a valid collection approval and was skipped."],SMART_BATCH_AMBIGUOUS_COMMAND:["该目标没有唯一的已批准采集声明，未执行。","This target has no unique approved collection declaration and was skipped."],SMART_BATCH_SNAPSHOT_CHANGED:["目标绑定或审批已变化，未跟随新目标执行。","The binding or approval changed. Execution did not follow a new target."],SMART_COLLECTION_SNAPSHOT_CHANGED:["目标绑定或审批已变化，本次采集未继续。","The binding or approval changed. This collection did not continue."],SMART_BATCH_FORBIDDEN:["没有读取该磁盘或批次的权限，请联系管理员。","Access to this disk or batch is denied. Contact an administrator."],SMART_BATCH_ACCESS_CHANGED:["磁盘绑定或读取权限已变化，已清空批次展示。请核实。","The disk binding or read access changed. Batch details were cleared. Verify access."],SMART_BATCH_TARGET_UNAVAILABLE:["采集目标暂不可用，未执行。","The collection target is unavailable and was skipped."],SMART_BATCH_CONFLICT:["与已有采集任务冲突，未自动重试。请先核实运行状态。","Another collection conflicts with this target. It was not retried. Check the active task."],SMART_BATCH_BUSY:["已有全局批次运行中，未发起新批次。请先核实运行状态。","A global batch is already running. No new batch was started. Check its status."],SMART_BATCH_DEADLINE:["批次达到后台等待时限，尚未开始的目标未执行。","The batch reached its background deadline. Targets that had not started were skipped."],SMART_BATCH_INTERRUPTED:["批次被中断，结果待确认。未自动重发命令。","The batch was interrupted and its outcome is unknown. Commands were not resent."],SMART_BATCH_CHILD_UNKNOWN:["该磁盘的采集结果待确认，未自动重发命令。","This disk’s collection outcome is unknown. The command was not resent."],SMART_BATCH_CAPACITY_EXCEEDED:["批次记录容量已满，未发起新批次。请联系管理员处理。","Batch record capacity is full. No new batch was started. Contact an administrator."],SMART_BATCH_NOT_FOUND:["批次记录不可用，未重新发起采集。请联系管理员核实。","The batch record is unavailable. Collection was not resubmitted. Contact an administrator."],SSH_APPROVAL_REQUIRED:["采集命令尚未审核或授权已失效，请联系管理员审核。","The collection command is not approved, or approval expired. Ask an administrator to review it."],SSH_REGISTRATION_CHANGED:["采集声明已变化，需要管理员重新审核授权。","The collection declaration changed and requires administrator approval again."],SSH_CHANNEL_DISABLED:["统一 SSH 通道未启用或未配置，请联系管理员。","The shared SSH channel is disabled or unconfigured. Contact an administrator."],SSH_TARGET_UNAVAILABLE:["尚未配置可用采集目标，请联系管理员。","No collection target is configured. Contact an administrator."],SSH_DEVICE_UNAVAILABLE:["采集设备尚未配置或已不可用，请联系管理员。","The collection device is unconfigured or unavailable. Contact an administrator."],SMART_PROFILE_UNAVAILABLE:["可信采集主机配置不可用，请联系管理员。","The trusted collection host profile is unavailable. Contact an administrator."],SMART_DEVICE_UNAVAILABLE:["可信采集设备不可用，请联系管理员。","The trusted collection device is unavailable. Contact an administrator."],SMART_COLLECTION_UNAVAILABLE:["当前框架尚未提供立即采集，请联系管理员。","Collect now is unavailable in this framework. Contact an administrator."],SSH_CONCURRENCY_LIMIT:["已有采集任务运行中，请稍后核实状态。","A collection is already running. Check its status before trying again."],SMART_COLLECTION_BUSY:["已有采集任务运行中，请稍后核实状态。","A collection is already running. Check its status before trying again."],ADMIN_REQUIRED:["立即采集需要管理员权限。","Collect now requires administrator access."],SMART_UNSUPPORTED:["该设备不支持 SMART 采集或未透传，健康状态未知。","SMART collection is unsupported or not passed through; health is unknown."]};if("unknown"===e.status){const r=W(t,"采集结果待确认，任务可能仍在执行。未自动重发请求；请重新读取或联系管理员核实。","Collection outcome is unknown; the task may still be running. The request was not resent. Reload or ask an administrator to verify.");return n[e.code]?`${r} ${W(t,...n[e.code])}`:r}return n[e.code]?W(t,...n[e.code]):e.code&&"SMART_COLLECTION_UNKNOWN"!==e.code?Q(e.code,t):W(t,"采集任务失败，未提供详细原因。请重新读取并联系管理员核实。","Collection failed without a detailed reason. Reload and ask an administrator to verify.")}function Q(e,t){return W(t,...{SMART_GENERATION_CHANGED:["磁盘已更换或身份已变化，请重新读取。","The disk was replaced or its identity changed. Reload to verify it."],SMART_BINDING_CHANGED:["可信采集绑定已变化，已清空旧数据。请联系管理员重新核验设备绑定与采集授权后再读取。","The trusted collection binding changed. Previous data was cleared. Ask an administrator to verify the binding and collection approval before reloading."],SMART_DISK_FORBIDDEN:["没有读取该磁盘的权限，已清空旧数据。请联系管理员核实对象权限。","You no longer have read access to this disk. Previous data was cleared. Ask an administrator to verify object access."],AUTHENTICATION_REQUIRED:["CloudTower 登录状态已失效，已清空旧数据。请重新登录后读取；主机 SSH 认证结果请查看通道独立检查。","Your CloudTower session is no longer valid. Previous data was cleared. Sign in again before reloading; check the SSH channel separately for host authentication results."],SMART_PLUGIN_DISABLED:["磁盘健康插件已停用或当前不可用，已清空旧数据。请联系管理员核实插件启用状态与权限。","The Disk SMART plugin is disabled or unavailable. Previous data was cleared. Ask an administrator to verify plugin activation and permissions."],SMART_HISTORY_CURSOR_STALE:["历史记录已更新，请重新读取首页后继续翻页。","History changed. Reload the first page before continuing."],SMART_DISK_UNBOUND:["该磁盘尚未绑定可信采集设备，请联系管理员。","This disk has no trusted collection binding. Contact an administrator."],SMART_NO_SAMPLE:["尚无采样，等待已授权的后台采集。","No sample yet. Await authorized background collection."],SMART_COLLECTION_FAILED:["本次采集失败：SMART 数据不可用，健康状态未知。","Collection failed: SMART data is unavailable; health is unknown."],SMART_EXECUTION_TIMEOUT:["采集超时，健康状态未知。","Collection timed out; health is unknown."],SMART_EXECUTION_CANCELLED:["采集已取消，健康状态未知。","Collection was cancelled; health is unknown."],SMART_IDENTITY_MISMATCH:["采集设备身份不符，未使用该结果，健康状态未知。","Collected device identity did not match. The result was discarded; health is unknown."],SMART_OUTPUT_INVALID:["采集数据无效，健康状态未知。","Collected data is invalid; health is unknown."],SMART_INVALID_DATA:["采集数据无效，健康状态未知。","Collected data is invalid; health is unknown."],SMART_DEVICE_CHANGED:["采集设备已变化，健康状态未知。","The collected device changed; health is unknown."],SMART_UNAVAILABLE:["没有可用采样，健康状态未知。","No sample is available; health is unknown."]}[e]||["SMART 信息暂不可用。请联系管理员检查采集服务和对象权限后重试。","SMART information is unavailable. Ask an administrator to check collection and object access, then retry."])}function X(e){return W(e,"SMART 读取失败不等于 SSH 认证失败，也不能据此判定坏盘。认证结果请查看 SSH 通道的独立检查。可能原因包括工具或命令问题、设备不提供 SMART，或虚拟化层未透传（例如某些 VMware 虚拟盘）；本页未确认具体原因。","A SMART read failure does not establish an SSH authentication failure or a damaged disk. See the SSH channel’s separate authentication check. Possible causes include tool or command issues, a device without SMART, or missing virtualization passthrough (for example, some VMware virtual disks). This page has not confirmed the cause.")}const J={health:["SMART 健康自检","SMART health assessment"],ata_threshold_status:["SMART 退出状态：属性阈值告警","SMART exit status: attribute threshold alert"],self_test_errors:["自检日志包含错误","Self-test log contains errors"],temperature:["温度","Temperature"],power_on_hours:["通电时间","Power-on hours"],power_cycles:["通电次数","Power cycles"],critical_warning:["严重警告位","Critical warning bits"],available_spare:["可用备用空间","Available spare"],percentage_used:["已消耗寿命","Endurance used"],media_errors:["介质与数据完整性错误","Media and data integrity errors"],num_err_log_entries:["错误日志条目","Error log entries"],unsafe_shutdowns:["非正常关机次数","Unsafe shutdowns"],data_units_read:["读取数据单元","Data units read"],data_units_written:["写入数据单元","Data units written"],Reallocated_Sector_Ct:["重映射扇区数","Reallocated sectors"],Reallocated_Event_Count:["重映射事件数","Reallocation events"],Current_Pending_Sector:["待处理扇区数","Current pending sectors"],Offline_Uncorrectable:["离线不可纠正扇区","Offline uncorrectable sectors"],Reported_Uncorrect:["已报告不可纠正错误","Reported uncorrectable errors"],UDMA_CRC_Error_Count:["接口 CRC 错误数","Interface CRC errors"],Raw_Read_Error_Rate:["原始读取错误率（厂商定义）","Raw read error rate (vendor defined)"],Seek_Error_Rate:["寻道错误率（厂商定义）","Seek error rate (vendor defined)"],Power_On_Hours:["通电时间","Power-on hours"],Power_Cycle_Count:["通电次数","Power cycles"],Temperature_Celsius:["温度（厂商原始格式）","Temperature (vendor raw format)"],Wear_Leveling_Count:["磨损均衡计数（厂商定义）","Wear leveling count (vendor defined)"],Media_Wearout_Indicator:["介质磨损指标（厂商定义）","Media wearout indicator (vendor defined)"],Percent_Lifetime_Remain:["剩余寿命（厂商定义）","Remaining life (vendor defined)"],scsi_grown_defect_list:["增长缺陷列表","Grown defect list"],scsi_read_errors:["不可纠正读取错误","Uncorrected read errors"],scsi_write_errors:["不可纠正写入错误","Uncorrected write errors"],scsi_verify_errors:["不可纠正校验错误","Uncorrected verify errors"]};function Z(e,t){return J[e]?W(t,...J[e]):W(t,"厂商属性","Vendor attribute")}const ee=(e,t)=>W(t,...{unknown:["未知","Unknown"],normal:["未触发规则","No rule triggered"],yellow:["关注","Attention"],red:["高风险","High risk"],darkred:["严重风险","Critical risk"]}[e]||["未知","Unknown"]),te={failed:["设备报告健康检查失败","Device reports failed health assessment"],critical:["设备严重警告位非零","Device critical warning bits are nonzero"],threshold:["已达到设备报告的阈值","Device-reported threshold reached"],historical:["设备报告曾越过阈值","Device reports a previous threshold failure"],endurance:["已消耗寿命达到展示策略阈值","Endurance used reached a display policy threshold"],counter:["该错误或缺陷计数非零","This error or defect counter is nonzero"],increased:["相较上一有效采样劣化","Deteriorated since the previous valid sample"],normalized:["归一化值下降；原始值含义由厂商定义","Normalized value fell; raw semantics are vendor defined"],vendor:["厂商属性原始值不做通用风险推断","No generic risk inference from vendor raw values"],informational:["仅供参考，不据此推断寿命或故障","Informational; no lifespan or failure inference"]},ne=(e,t)=>te[e]?W(t,...te[e]):"—";const re='\n.pk-smart-actions{display:flex;flex-wrap:wrap;gap:8px;justify-content:flex-end}\n.pk-smart-history{max-height:240px;overflow:auto;padding:4px 4px 4px 22px}.pk-smart-history li{margin:4px 0}.pk-smart-history button[aria-pressed=true]{outline:2px solid #087ef5}\n.pk-smart-tab{border:0;background:transparent;padding:10px 14px;color:#536880;cursor:pointer;font:inherit;white-space:nowrap}.pk-smart-tab[aria-selected=true]{color:#087ef5;border-bottom:2px solid #087ef5}.pk-smart-tab:focus-visible,.pk-smart-panel button:focus-visible{outline:2px solid #087ef5;outline-offset:2px}\n.pk-smart-panel{font:13px/1.6 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;color:#243a55;padding:20px;background:#f5f7fb;overflow:auto;max-height:calc(100vh - 240px)}.pk-smart-panel *{box-sizing:border-box}.pk-smart-panel h3{font-size:16px;margin:0 0 12px}.pk-smart-panel h4{margin:18px 0 8px}.pk-smart-panel p{margin:8px 0}.pk-smart-card{background:#fff;border:1px solid #e2e9f2;border-radius:8px;padding:16px;margin-bottom:12px}.pk-smart-meta{color:#63768d;font-size:12px;overflow-wrap:anywhere}.pk-smart-banner{padding:10px 12px;background:#eaf3ff;border-radius:6px;margin:8px 0}.pk-smart-notice{padding:10px 12px;background:#fff5d8;color:#694c00;border-radius:6px;margin:8px 0}.pk-smart-summary{display:flex;justify-content:space-between;align-items:center;gap:10px}.pk-smart-panel button{border:1px solid #d5dfeb;background:white;border-radius:5px;padding:5px 10px;color:inherit;cursor:pointer}.pk-smart-panel button:disabled{opacity:.5;cursor:default}.pk-smart-scroll{overflow-x:auto}.pk-smart-table{border-collapse:collapse;width:100%;font-size:12px}.pk-smart-table th,.pk-smart-table td{padding:10px 8px;text-align:left;vertical-align:top;border-bottom:1px solid #e5ebf3;overflow-wrap:anywhere;min-width:72px}.pk-smart-table td:first-child{min-width:190px}.pk-smart-table th{color:#63768d;font-weight:500;background:#f7f9fc}.pk-smart-code{font:11px ui-monospace,SFMono-Regular,Consolas,monospace;color:inherit;opacity:.8;display:block;margin-top:2px;overflow-wrap:anywhere}.pk-smart-risk-yellow{background:#fff1b8!important;color:#594000!important}.pk-smart-risk-red{background:#ffd8d2!important;color:#820d16!important}.pk-smart-risk-darkred{background:#8c1026!important;color:#fff!important}.pk-smart-risk-unknown{background:#f0f2f5;color:#5e6a7b}.pk-smart-pill{display:inline-block;border-radius:4px;padding:3px 8px;font-weight:600}.pk-smart-policy{font-size:12px;color:#63768d}.pk-smart-panel [hidden]{display:none!important}\n';function oe({win:e,store:t,getLocale:n,provider:r,findDetail:o=B,timeoutMs:a=8e3,collectionTimeoutMs:i=45e3,collectionIntervalMs:s=1500}){const l=e.document,d=l.createElement("style");d.dataset.pkSmartStyle="",d.textContent=re,l.head.append(d);let c=!1,u=null,p=null,_=0;function A(){try{return o(e)}catch{return null}}function m(e){const t=A();return Boolean(t&&t.diskId===e.diskId&&t.path===e.path&&t.root===e.root&&t.tabs===e.tabs&&t.content===e.content)}function h(){if(!u)return;const{panel:e,button:t,detail:n}=u;"running"===u.state.collection?.status&&(u.collectionAbort?.abort(),u.state.collection={...u.state.collection,status:"unknown",code:"SMART_COLLECTION_WAIT_CANCELLED"}),e.hidden=!0,t.setAttribute("aria-selected","false"),u.open&&(n.content.hidden=u.originalHidden,u.open=!1)}function T(){_++,u&&(u.abort?.abort(),u.collectionAbort?.abort(),e.clearTimeout(u.timeout),h(),u.detail.tabs.removeEventListener("click",f),u.button.remove(),u.panel.remove(),u=null)}function f(e){e.target.closest("[data-pk-smart-tab]")||h()}function g(){if(!u)return;u.button.textContent=W(n(),"Smart 信息","SMART information");const e="function"==typeof r?.collect&&"function"==typeof r?.collection;!function(e,t,n,r,o,a,i){const s=e.ownerDocument,l=(e,t)=>W(n,e,t),d=(t,n,r,o=e)=>{const a=function(e,t,n,r){const o=e.createElement(t);return void 0!==n&&(o.textContent=n),r&&(o.className=r),o}(s,t,n,r);return o.append(a),a};e.replaceChildren(),e.lang=n;const c=d("div",void 0,"pk-smart-card"),u=d("div",void 0,"pk-smart-summary",c);d("h3",l("Smart 信息","SMART information"),"",u);const p="running"===t.collection?.status,_=!0===t.result?.virtualDemo,A=d("div",void 0,"pk-smart-actions",u),m=d("button",_?l("刷新示例","Refresh example"):l("重新读取","Reload"),"",A);m.type="button",m.disabled=Boolean(t.loading||t.historyLoading||p),m.addEventListener("click",r);const h=d("button",p?l("采集中…","Collecting…"):l("立即采集","Collect now"),"",A);if(h.type="button",h.dataset.smartCollect="",h.disabled=Boolean(t.loading||t.historyLoading||p||!t.result?.identity||!t.canCollect),h.addEventListener("click",i),d("p",_?l("虚拟盘演示不执行真实采集；刷新只重新核验型号并生成本地示例。","Virtual disk demonstrations do not collect from a host. Refresh only verifies the model and generates local examples."):l("重新读取只刷新已有采样；立即采集需已配置可信设备并完成人工审核。","Reload only reads existing samples. Collect now requires a trusted device and explicit administrator approval."),"pk-smart-meta",c),t.canCollect||_||d("p",K({status:"failed",code:"SMART_COLLECTION_UNAVAILABLE"},n),"pk-smart-meta",c),t.collection&&d("p",K(t.collection,n),"pk-smart-notice pk-smart-collection",c).setAttribute("role","status"),t.loading)return void d("p",l("正在核验磁盘身份并读取数据…","Verifying disk identity and loading…"),"",c);if(t.error)return void d("p",Q(t.error,n),"pk-smart-notice",c).setAttribute("role","status");const T=t.result;if(!T)return;const f=_?T.inventory:T.identity,g=_?null:T.history.find(e=>e.collectedAt===t.selectedAt),{sample:E,previous:S}=_?{sample:T.example,previous:null}:H(g||T.latest,T.history);if(d("p",f.model||"—","pk-smart-meta",c),d("p",_?l("虚拟磁盘模拟示例","Virtual disk demonstration"):g?l("正在查看历史采样","Viewing a historical sample"):l("最近采集结果","Latest collection result"),"pk-smart-meta",c),_&&d("p",l("虚拟磁盘模拟示例 · 以下数值为本地构造，非该盘实际 SMART、健康或寿命数据。真实健康状态未知；示例不写入采样历史。","VIRTUAL DISK EXAMPLE · Values below are generated locally, not this disk’s actual SMART, health or endurance data. Real health is unknown. Examples are not stored in sample history."),"pk-smart-banner pk-smart-virtual-banner",c).setAttribute("role","status"),"mock"===E.source&&d("p",l("本地模拟数据 · 未连接真实主机 · 未启用每日采集","Local mock data · No live host connected · Daily collection is inactive"),"pk-smart-banner",c),["unavailable","unsupported"].includes(E.status))d("p","unsupported"===E.status?l("该设备不支持 SMART 或未透传；健康状态未知。","SMART is unsupported or not passed through; health is unknown."):Q(E.code,n),"pk-smart-notice",c),E.collectedAt&&d("p",`${l("采集尝试时间（UTC）","Collection attempt (UTC)")}: ${E.collectedAt}`,"pk-smart-meta",c),"SMART_NO_SAMPLE"!==E.code&&d("p",X(n),"pk-smart-meta pk-smart-failure-guidance",c);else{E.gapCode&&d("p",function(e,t){const n={SMART_COLLECTION_FAILED:["采集失败","collection failure"],SMART_UNAVAILABLE:["数据不可用","data unavailable"],SMART_UNSUPPORTED:["当时不支持 SMART","SMART was unsupported"],SMART_INVALID_DATA:["数据无效","invalid data"],SMART_DEVICE_CHANGED:["设备变化","device changed"],SMART_IDENTITY_MISMATCH:["设备身份不符","device identity mismatch"],SMART_EXECUTION_TIMEOUT:["采集超时","collection timed out"],SMART_EXECUTION_CANCELLED:["采集取消","collection cancelled"],SMART_OUTPUT_INVALID:["采集结果无效","invalid collection output"]}[e];return n?W(t,`当日曾采集失败，后恢复（${n[0]}）。此前失败时刻未提供。`,`Collection failed earlier that UTC day, then recovered (${n[1]}). The earlier failure time was not provided.`):""}(E.gapCode,n),"pk-smart-notice pk-smart-recovered",c).setAttribute("role","status"),d("span",`${_?l("示例风险（非真实判断）","Example risk (not an actual assessment)"):l("展示风险","Display risk")}: ${ee(E.risk,n)}`,`pk-smart-pill pk-smart-risk-${E.risk}`,c),d("p",`${_?l("示例生成时间（非采集时间，UTC）","Example generated (not collected, UTC)"):l("采样时间（UTC）","Sample time (UTC)")}: ${_?E.generatedAt:E.collectedAt}`,"pk-smart-meta",c),d("p",`${E.protocol} · ${l("数据来源","Source")}: ${E.source}`,"pk-smart-meta",c),"stale"===E.status&&d("p",l("数据已过期（超过 36 小时或采集服务标记过期），无法据此判断当前健康状态。","Data is stale (over 36 hours old or marked stale by the provider); current health cannot be determined."),"pk-smart-notice",c),d("p",_?l("示例不与真实历史对比，不计算该盘实际劣化。","Examples are not compared with real history and do not measure this disk’s actual deterioration."):S?`${l("变化对比上一有效采样","Changes since previous valid sample")}: ${S.collectedAt}`:l("无上一有效采样，尚不能计算劣化。","No previous valid sample; deterioration cannot yet be calculated."),"pk-smart-meta",c),T.historyUnavailable&&d("p",l("历史读取失败，当前值仍可查看；未计算劣化。","History could not be loaded. Current values remain available; deterioration was not calculated."),"pk-smart-notice",c),d("h4",_?l("SMART 模拟示例条目","Example SMART metrics"):l("SMART 条目 · 风险优先","SMART metrics · Risks first"));const e=d("div",void 0,"pk-smart-scroll"),t=d("table",void 0,"pk-smart-table",e),r=d("thead",void 0,"",t),o=d("tr",void 0,"",r);for(const e of[l("条目 / 原始名称","Metric / original name"),l("当前值","Current"),l("变化 / 劣化","Change / deterioration"),l("风险与依据","Risk and reason")])d("th",e,"",o).scope="col";const a=d("tbody",void 0,"",t),i={darkred:4,red:3,yellow:2,unknown:1,normal:0};for(const e of[...E.metrics].sort((e,t)=>i[t.risk]-i[e.risk])){const t=d("tr",void 0,`pk-smart-risk-${e.risk}`,a);t.dataset.metric=e.id;const r=d("td",Z(e.name,n),"",t);d("span",`${e.id} · ${e.name}`,"pk-smart-code",r);const o=d("td","health"===e.id?"1"===e.value?l("通过","Passed"):l("失败","Failed"):`${e.value??(e.rawText||"—")}${null===e.value?"":e.unit}`,"",t);void 0!==e.normalized?d("span",`${l("归一化 / 最差 / 阈值","Normalized / worst / threshold")}: ${e.normalized??"—"} / ${e.worst??"—"} / ${e.threshold??"—"}`,"pk-smart-code",o):void 0!==e.threshold&&d("span",`${l("设备阈值","Device threshold")}: ${e.threshold??"—"}%`,"pk-smart-code",o);const i="%"===e.unit?l(" 个百分点"," percentage points"):e.unit?` ${e.unit}`:"",s=d("td",null===e.delta?"—":`${BigInt(e.delta)>0n?"+":""}${e.delta}${i}`,"",t);null!==e.deterioration&&d("span",`${l("劣化","Deteriorated")}: ${e.deterioration}${"normalized"===e.deteriorationKind?l(" 归一化点"," normalized points"):i}`,"pk-smart-code",s),"counter-reset"===e.trend&&d("span",l("计数下降：可能重置；不当作改善","Counter decreased: possible reset; not treated as improvement"),"pk-smart-code",s);const c=d("td",ee(e.risk,n),"",t);d("span",ne(e.reason,n),"pk-smart-code",c)}}if(_)return void d("p",l("本页未读取或写入真实采样历史，示例不计为全局批次采集成功。全局采集仍只操作已绑定、已审核的真实目标。","This page did not read or write actual sample history. Examples do not count as successful global batch collections. Global collection still uses bound, approved real targets."),"pk-smart-meta");d("h4",l("最近采样记录","Recent samples")),T.historyUnavailable&&!E.metrics.length&&d("p",l("历史读取失败，请重新读取。","History could not be loaded. Reload to retry."),"pk-smart-notice");const I=d("button",l("查看最近结果","View latest result"));if(I.type="button",I.disabled=!g,I.onclick=()=>a(null),T.history.length){const e=d("ul",void 0,"pk-smart-meta pk-smart-history");for(const r of T.history){const o=d("li",void 0,"",e),i=H(r,T.history).sample,s=r.metrics.length?ee(i.risk,n):"unsupported"===r.status?l("不支持 · 健康未知","Unsupported · Health unknown"):l("采集失败 · 健康未知","Collection failed · Health unknown"),c=r.gapCode?l(" · 当日采集已恢复"," · Collection recovered that day"):"",u=d("button",`${r.collectedAt} · ${s}${c}`,"",o);u.type="button",u.dataset.sampleTime=r.collectedAt,u.setAttribute("aria-pressed",String(r.collectedAt===t.selectedAt)),u.onclick=()=>a(r.collectedAt)}}else d("p",l("暂无历史记录。","No history is available."),"pk-smart-meta");if(t.historyError&&d("p",Q(t.historyError,n),"pk-smart-notice").setAttribute("role","status"),T.hasMore){const e=d("button",t.historyLoading?l("读取中…","Loading…"):l("读取更早记录","Load older samples"));e.type="button",e.dataset.smartMore="",e.disabled=Boolean(t.historyLoading||t.historyError||p),e.onclick=o}d("p",`${l("已读取记录","Loaded records")}: ${T.history.length} / 365 · ${l("仅比较同一物理盘的有效采样；失败日不作基线。","Only valid samples from this disk generation are compared; failed days are excluded as baselines.")}`,"pk-smart-meta"),d("p",l("提示策略：NVMe 已用寿命 ≥80% 黄、≥90% 红、≥100% 深红；设备健康失败、严重警告或当前阈值越界为深红。错误计数和劣化另见条目依据。颜色用于辅助排查，不代表故障预测。厂商属性不通用推算寿命；温度、错误日志数和非正常关机数仅展示。","Display policy: NVMe endurance used ≥80% yellow, ≥90% red, ≥100% dark red. Failed health, critical warnings or current device threshold failures are dark red. See row reasons for errors and deterioration. Colors aid investigation and do not predict failures. Vendor attributes do not imply a universal lifespan. Temperature, error log entries and unsafe shutdowns are informational."),"pk-smart-policy")}(u.panel,{...u.state,canCollect:e},n(),E,S,e=>{u.state.selectedAt=e,g(),u.panel.scrollTop=0},C)}function E(){return I(!1)}function S(){if(!u?.state.result?.virtualDemo)return I(!0)}async function I(t,n){if(!u||c||!m(u.detail))return void T();if("running"===u.state.collection?.status)return;if(t&&(!u.state.result?.nextCursor||u.state.historyLoading||u.state.historyError))return;const o=u,i=++_;o.abort?.abort(),e.clearTimeout(o.timeout);const s=new e.AbortController;o.abort=s;const l=o.state.collection;o.state=t?{...o.state,historyLoading:!0}:{loading:!0,collection:l},g();const d=o.timeout=e.setTimeout(()=>{s.abort(),u!==o||_!==i||c||(o.state={error:"SMART_READ_FAILED",collection:l},g())},a);try{const e=t?await x(r,o.state.result,o.state.result.nextCursor,s.signal):await async function(e,t,n,r=Date.now()){if(!e||!["resolveDisk","readLatest","readHistory"].every(t=>"function"==typeof e[t]))throw new Error("SMART_PROVIDER_UNAVAILABLE");if("function"==typeof e.readInventory){const o=await e.readInventory({diskId:t,signal:n});if(O(n),1!==o?.schemaVersion||!b(o.disk?.diskId)||o.disk.diskId!==t||"string"!=typeof o.disk.model||o.disk.model.length>160)throw new Error("DISK_IDENTITY_UNVERIFIED");if(w(o.disk.model))return v(o.disk,r)}const o=function(e,t){if(!(e&&b(e.diskId)&&e.diskId===t&&b(e.hostId)&&/^[a-f0-9]{64}$/.test(e.generation)&&e.deviceId===e.generation&&""===e.path))throw new Error("DISK_IDENTITY_UNVERIFIED");return{diskId:e.diskId,hostId:e.hostId,deviceId:e.deviceId,generation:e.generation,path:"",model:"string"==typeof e.model?e.model.slice(0,160):""}}(await e.resolveDisk({diskId:t,signal:n}),t);if(O(n),w(o.model))return v({diskId:t,model:o.model},r);const a=U(await e.readLatest({identity:o,signal:n}),o,r);O(n);const i={identity:o,latest:H(a,[]).sample,history:[],previous:null,historyUnavailable:!1,hasMore:!1,nextCursor:null};let s;try{s=await e.readHistory({identity:o,limit:30,cursor:null,signal:n})}catch(e){if(O(n),!("TypeError"===e?.name||[408,429].includes(e?.status)||e?.status>=500)||["SMART_GENERATION_CHANGED","SMART_HISTORY_CURSOR_STALE","SMART_DISK_UNBOUND"].includes(M(e)))throw e;return{...i,historyUnavailable:!0}}return x({readHistory:async()=>s},i,null,n,r)}(r,o.detail.diskId,s.signal);if(c||s.signal.aborted||u!==o||_!==i)return;if(!m(o.detail))return void T();if(n&&(!k(e.identity,n.identity)||e.latest.source!==n.source))throw new Error("SMART_GENERATION_CHANGED");o.state={result:e,selectedAt:t?o.state.selectedAt:null,collection:e.virtualDemo?void 0:l},g()}catch(e){if(!c&&!s.signal.aborted&&u===o&&_===i){const n=M(e);o.state=t&&"SMART_HISTORY_CURSOR_STALE"===n?{...o.state,historyLoading:!1,historyError:n}:{error:n,collection:l},g()}}finally{e.clearTimeout(d)}}async function C(){if(!u||c||!u.open||!m(u.detail)||!u.state.result||u.state.result.virtualDemo||u.state.loading||u.state.historyLoading||"running"===u.state.collection?.status)return;const t=u,n=++_,o=Object.freeze({...t.state.result.identity}),a=t.state.result.latest.source;t.abort?.abort();const l=new e.AbortController;t.collectionAbort=l,t.state={...t.state,collection:{status:"running"}},g();const d=()=>!c&&!l.signal.aborted&&u===t&&_===n&&m(t.detail);try{const n=await Y(r,{identity:o,requestId:$(e.crypto),signal:l.signal,timeoutMs:i,intervalMs:s,onProgress:e=>{d()&&(t.state.collection=e,g())}});if(!d())return;t.state.collection=n,g(),("succeeded"===n.status||"failed"===n.status&&n.operationId)&&await I(!1,{identity:o,source:a})}catch(e){if(!d())return;const n=F(e),r={status:"failed",code:n};t.state=z(n)?{error:n,collection:r}:{...t.state,collection:r},g()}}function R(){if(p=null,c)return;const e=t.status().loaded&&t.get().enabled?A():null;e?(u&&!m(u.detail)&&T(),u||function(e){const t=l.createElement("button"),n=l.createElement("section");t.type="button",t.className="tab-item pk-smart-tab",t.dataset.pkSmartTab="",t.id="pk-smart-info-tab",t.setAttribute("role","tab"),t.setAttribute("aria-selected","false"),t.setAttribute("aria-controls","pk-smart-info-panel"),n.id="pk-smart-info-panel",n.className="pk-smart-panel",n.dataset.pkSmartPanel="",n.hidden=!0,n.setAttribute("role","tabpanel"),n.setAttribute("aria-labelledby",t.id),u={detail:e,button:t,panel:n,open:!1,originalHidden:e.content.hidden,state:{}},t.addEventListener("click",r=>{r.stopPropagation(),u&&m(e)?(u.open||(u.originalHidden=e.content.hidden),e.content.hidden=!0,u.open=!0,n.hidden=!1,t.setAttribute("aria-selected","true"),E()):T()}),e.tabs.append(t),e.content.after(n),e.tabs.addEventListener("click",f),g()}(e),u.locale!==n()&&(u.locale=n(),g())):T()}function N(){c||null!==p||(p=e.setTimeout(R,40))}const y=new e.MutationObserver(N);y.observe(l.body,{childList:!0,subtree:!0});const L=new e.MutationObserver(N);L.observe(l.documentElement,{attributes:!0,attributeFilter:["lang"]});const D=t.subscribe(N);return e.addEventListener("hashchange",N),e.addEventListener("popstate",N),e.addEventListener("languagechange",N),R(),()=>{c||(c=!0,T(),y.disconnect(),L.disconnect(),D(),e.clearTimeout(p),e.removeEventListener("hashchange",N),e.removeEventListener("popstate",N),e.removeEventListener("languagechange",N),d.remove())}}const ae=Object.freeze({operation:"disk.smart.read",category:"disk",template:"sudo -n -- /usr/sbin/smartctl --json=c --all <disk>",argumentSource:"fresh-host-inventory",expansion:"each-authorized-disk"}),ie={queued:["等待中","Queued"],running:["采集中","Running"],succeeded:["已完成","Succeeded"],failed:["失败","Failed"],unknown:["待确认","Unknown"],skipped:["未执行","Skipped"]},se=e=>Number.isInteger(e)&&e>=0&&e<=100?e:"—",le=e=>e&&["total",...Object.keys(ie)].every(t=>"—"!==se(e[t]))&&Object.keys(ie).reduce((t,n)=>t+e[n],0)===e.total,de=["queued","running","succeeded","failed","unknown","skipped"],ce=e=>"string"==typeof e&&/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(e),ue=()=>{throw new Error("INVALID_COLLECTION_RESPONSE")};function pe(e,t){const n=j(e,t),r=e.summary;/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(n.operationId)||ue(),r&&Object.keys(r).sort().join()===["total",...de].sort().join()&&["total",...de].every(e=>Number.isInteger(r[e])&&r[e]>=0&&r[e]<=100)&&de.reduce((e,t)=>e+r[t],0)===r.total&&Array.isArray(e.items)&&e.items.length===r.total||ue();const o=new Set,a=Object.fromEntries(de.map(e=>[e,0])),i=e.items.map(e=>(e&&ce(e.diskId)&&"string"==typeof e.generation&&/^[0-9a-f]{64}$/.test(e.generation)&&de.includes(e.status)&&!o.has(e.diskId)||ue(),o.add(e.diskId),a[e.status]++,{diskId:e.diskId,generation:e.generation,status:e.status,...void 0===e.code?{}:{code:F({code:e.code})}})),s=a.queued||a.running?"running":a.unknown?"unknown":a.succeeded===i.length?"succeeded":"failed";return i.length&&!de.some(e=>a[e]!==r[e])&&n.status===s||ue(),{...n,summary:{total:r.total,...a},items:i}}function _e({React:e,win:t,options:o={},getLocale:s=()=>"zh-CN"}){const l=e.createElement,d=function(e,t,n){const{defaults:r,equal:o,seed:a,validate:s}=n,l=function(e){let t={showFloatingButton:!0},n=!0;const r=new Set,o=()=>{for(const e of r)e({...t})};function a(e){const t=JSON.parse(e||"{}"),n=t.floatingPosition,r=n&&["x","y"].every(e=>Number.isFinite(n[e])&&n[e]>=0&&n[e]<=1e5)?{x:Math.round(n.x),y:Math.round(n.y)}:null;return{showFloatingButton:!1!==t.showFloatingButton,floatingPosition:r}}try{t=a(e.localStorage.getItem(i))}catch{n=!1}function s(e){if(e.key===i||null===e.key)try{t=a(e.newValue),o()}catch{}}return e.addEventListener("storage",s),{get:()=>({...t}),persistent:()=>n,update(r){t=a(JSON.stringify({...t,...r}));try{e.localStorage.setItem(i,JSON.stringify(t)),n=!0}catch{n=!1}return o(),{...t}},subscribe:e=>(r.add(e),()=>r.delete(e)),dispose(){e.removeEventListener("storage",s),r.clear()}}}(e),d=new Set;let c=r(),p=r(),_=[],A={loaded:!1,loading:!1,saving:!1,error:"",revision:0,updatedAt:null};const m=e=>JSON.parse(JSON.stringify(e)),h=()=>({...A,dirty:!o(c,p)}),T=()=>({...m(c),showFloatingButton:l.get().showFloatingButton}),f=()=>({...m(p),showFloatingButton:l.get().showFloatingButton}),g=()=>{for(const e of d)e(T())},E=l.subscribe(g);function S(){A.loaded&&(p=a(p,_))}return{get:T,getDraft:f,status:h,persistent:l.persistent,subscribe:e=>(d.add(e),()=>d.delete(e)),update(e){if(A.saving)return f();Object.hasOwn(e,"showFloatingButton")&&l.update({showFloatingButton:e.showFloatingButton});const t={...e};return delete t.showFloatingButton,Object.keys(t).length&&A.loaded&&(p=r({...p,...t})),g(),f()},setClusters(e){_=e;try{S()}catch{A.error="集群数量超过配置容量，未自动补全规则。"}g()},async load(){if(!A.loading&&!A.saving){A={...A,loading:!0},g();try{if(!t)throw new Error("BACKEND_UNAVAILABLE");!function(e){const t=u(e,s),n=h().dirty;c=t.settings,n||(p=m(c)),A={...A,loaded:!0,revision:t.revision,updatedAt:t.updatedAt,error:""},S()}(await t.load())}catch{A.error="共享配置读取失败，请重试。"}finally{A.loading=!1,g()}}},async save(){if(!A.loaded||!t||A.saving)return!1;const e=m(p);A={...A,saving:!0,error:""},g();try{let n;try{n=u(await t.save(e),s)}catch{if(n=u(await t.load(),s),!o(n.settings,e))throw new Error("SAVE_NOT_CONFIRMED")}if(!o(n.settings,e))throw new Error("SAVE_NOT_CONFIRMED");return c=n.settings,p=m(c),A={...A,revision:n.revision,updatedAt:n.updatedAt},!0}catch{return A.error="未能确认保存成功，修改已保留，请重试。",!1}finally{A.saving=!1,g()}},discard(){A.saving||(p=m(c),A.error="",g())},dispose(){E(),l.dispose(),d.clear()}}}(t,o.configurationBackend?.()||p(t,a,r),a),c=function(e,t,n={}){const r="function"==typeof t?.collectAll&&"function"==typeof t?.collectionAll;let o,a={active:!1,available:r,status:"idle"},i=0;const s=new Set,l=e=>{a=e;for(const e of s)e(a)},d=()=>{i++,o?.abort(),o=null,"running"===a.status&&l({...a,status:"unknown",code:"SMART_COLLECTION_WAIT_CANCELLED"})};return{snapshot:()=>a,subscribe:e=>(s.add(e),e(a),()=>{s.delete(e),s.size||d()}),start(){l({...a,active:!0})},stop(){d(),l({...a,active:!1})},async collect(){if(!a.active||!r||"running"===a.status)return;const s=++i;let d;try{d=$(e.crypto)}catch{return void l({...a,status:"failed",code:"SMART_COLLECTION_UNAVAILABLE"})}o=new e.AbortController;const c=()=>s===i&&!o?.signal.aborted&&a.active;l({active:!0,available:r,status:"running"});try{const e=await async function(e,t){if("function"!=typeof e?.collectAll||"function"!=typeof e?.collectionAll)throw new Error("SMART_COLLECTION_UNAVAILABLE");let n;const r=await Y({collect:({requestId:t,signal:n})=>e.collectAll({requestId:t,signal:n}),collection:({operationId:t,signal:n})=>e.collectionAll({operationId:t,signal:n})},{...t,validate:pe,onProgress:e=>{n=e,t.onProgress?.(e)}});return{...n||{},...r}}(t,{...n,requestId:d,signal:o.signal,onProgress:e=>{c()&&l({...e,active:!0,available:r})}});c()&&l({...e,active:!0,available:r})}catch(e){c()&&l({active:!0,available:r,status:"failed",code:F(e)})}finally{s===i&&(o=null)}}}}(t,o.diskSmartInfo?.provider),_=function(e){const t=e.createElement;return function({locale:e="zh-CN",state:n={},onCollect:r,disabled:o=!1}){const a=(t,n)=>W(e,t,n),i="running"===n.status,s="function"==typeof r,l=le(n.summary)?n.summary:null,d=Array.isArray(n.items)?n.items.slice(0,100):[];let c;return i?c=a("全局采集正在进行。关闭配置页只停止页面等待，后台任务可能继续。","Global collection is running. Closing settings only stops waiting; background work may continue."):"unknown"===n.status?c="SMART_COLLECTION_WAIT_CANCELLED"===n.code?a("已停止页面等待，后台批次可能仍在执行，未自动重发请求。请核实后再发起新的采集。","Page waiting stopped. The background batch may still be running and was not resubmitted. Verify it before starting another collection."):a("批次结果待确认，未自动重发请求。请核实后再发起新的采集。","The batch outcome is unknown. The request was not resent. Verify it before starting another collection."):"succeeded"===n.status&&(!l||l.queued>0||l.running>0)?c=a("批次结果信息不完整，请重新核实状态。","Batch result information is incomplete. Verify its status again."):0===l?.total?c=a("没有可执行的采集目标，请检查可信设备配置与审核。","No collection targets are available. Check trusted devices and approvals."):"succeeded"===n.status?c=l&&(l.failed>0||l.unknown>0||l.skipped>0)?a("批次已结束，存在失败、待确认或未执行的目标，请查看逐盘结果。","The batch finished with failed, unknown or skipped targets. Review each disk below."):a("批次采集已完成。","Batch collection completed."):"failed"===n.status&&(c=l&&l.total>0?a("批次未全部成功，存在失败、待确认或未执行的目标，请查看逐盘结果。","The batch did not fully succeed. Review failed, unknown or skipped targets below."):K({status:"failed",code:n.code},e)),t("section",{className:"pk-smart-global","aria-label":a("全局手动采集","Global manual collection")},t("h4",null,a("全局手动采集","Global manual collection")),t("section",{"data-smart-command-declaration":"","data-smart-operation":ae.operation,"data-smart-category":ae.category,"data-smart-argument-source":ae.argumentSource,"data-smart-expansion":ae.expansion,"aria-label":a("采集命令声明","Collection command declaration")},t("h5",null,a("命令范式（说明，不直接执行）","Command template (not executable input)")),t("p",null,t("code",{"data-smart-command-template":"",style:{overflowWrap:"anywhere"}},ae.template)),t("p",null,a("目标类别：物理磁盘（disk）。参数来源要求：目标主机的新鲜库存；v2由框架按授权范围逐盘展开计划。旧v1仅使用原可信映射，仍需核验，不自动迁移或扩大范围。","Target category: physical disks (disk). Argument source requirement: the target host’s fresh inventory. v2 expands authorized per-disk plans. Legacy v1 retains configured trusted mappings and requires verification; it is not automatically migrated or widened.")),t("p",null,a("v2 all：目标主机全部授权物理盘；custom：仅明确选择的盘，空集不执行。范围由 SSH 连接设置控制，不跨主机选盘。","v2 all covers every authorized physical disk on the target host; custom includes only explicitly selected disks, and an empty selection executes nothing. SSH connection settings control the scope; disks are never selected across hosts.")),t("p",null,a("模板、正则或通配符不能作为执行输入；实际路径须通过内置白名单、物理身份与人工审批检查。命令声明与展开后的逐盘计划分别审阅。","Templates, regular expressions and wildcards are not executable input. Actual paths must pass the built-in allowlist, physical identity and administrator approval checks. Review the declaration separately from its expanded per-disk plans."))),t("p",null,a("采集所有已配置、已绑定且获授权的磁盘。未配置或未审核的目标不会执行；物理盘侧栏仍可单独采集。","Collect all configured, bound and authorized disks. Unconfigured or unapproved targets are not executed. Individual disks can still be collected from their sidebar.")),t("p",null,a("点击即发起一次采集，使用服务端已保存的目标与审核；无需保存本页设置，未保存草稿不参与采集。","Click to start one collection using saved server targets and approvals. No settings save is needed; unsaved drafts are not used.")),t("p",{className:"pk-smart-meta"},a("虚拟盘的本地模拟示例不计为采集成功，也不会写入真实历史。","Local virtual disk examples do not count as collected samples and are never written to actual history.")),t("button",{type:"button","data-smart-collect-all":"",disabled:o||i||!s,onClick:r},i?a("全局采集中…","Collecting all…"):a("全局立即采集","Collect all now")),!s&&t("p",{role:"status"},a("当前框架尚未提供全局采集，请联系管理员更新。","Global collection is unavailable in this framework. Ask an administrator to update it.")),c&&t("p",{role:"status","aria-live":"polite"},c),d.some(e=>"failed"===e.status&&["SMART_COLLECTION_FAILED","SMART_EXECUTION_TIMEOUT","SMART_OUTPUT_INVALID","SMART_INVALID_DATA"].includes(e.code))&&t("p",{className:"pk-smart-meta"},X(e)),l&&t("dl",{className:"pk-smart-batch-summary",style:{display:"grid",gridTemplateColumns:"repeat(auto-fit, minmax(90px, 1fr))",gap:"12px",margin:"16px 0"}},...[["total",a("目标总数","Total targets")],...Object.entries(ie).map(([e,t])=>[e,a(...t)])].map(([e,n])=>t("div",{key:e},t("dt",null,n),t("dd",{style:{margin:"4px 0 0",fontSize:"18px",fontWeight:600}},String(se(l[e])))))),d.length>0&&t("div",{className:"pk-smart-scroll"},t("table",{className:"pk-smart-table"},t("thead",null,t("tr",null,...[a("磁盘","Disk"),a("采集状态","Collection status"),a("说明","Details")].map(e=>t("th",{key:e,scope:"col"},e)))),t("tbody",null,...d.map((n,r)=>t("tr",{key:n.key||String(r)},t("td",null,"string"==typeof n.label?n.label.slice(0,200):a("未知目标","Unknown target")),t("td",null,ie[n.status]?a(...ie[n.status]):a("待确认","Unknown")),t("td",null,n.code?K({status:"unknown"===n.status?"unknown":"failed",code:n.code},e):"—")))))))}}(e);function A({locale:t}){const[n,r]=e.useState(c.snapshot);e.useEffect(()=>c.subscribe(r),[]);const o=n.items?.map(e=>({...e,key:e.diskId,label:e.diskId}));return l(_,{locale:t,state:{...n,items:o},disabled:!n.active,onCollect:n.available?()=>c.collect():void 0})}return{id:n,store:d,Settings:function({preferences:t,locale:n}){const r=(e,t)=>W(n,e,t);return l(e.Fragment,null,l("h3",null,r("磁盘健康展示","Disk SMART information")),l("p",null,r("在物理盘详情侧栏展示 SMART 数据、历史采样和指标劣化。","Display SMART data, historical samples and metric deterioration in physical disk details.")),l("div",{className:"c89-setting"},l("div",{className:"c89-setting-row"},l("label",{htmlFor:"pk-smart-enabled"},r("显示 Smart 信息子页","Show SMART information tab")),l("input",{id:"pk-smart-enabled",type:"checkbox",checked:t.enabled,onChange:e=>d.update({enabled:e.target.checked})}))),l("p",{role:"status"},r("每日采集与“立即采集”均需要可信设备配置和独立人工审核。“重新读取”只刷新已有采样；离开侧栏只停止页面等待，后台任务可能继续。真实主机采集尚未验收。","Daily collection and Collect now require trusted device configuration and explicit administrator approval. Reload only reads existing samples. Leaving the sidebar stops waiting; a background task may continue. Live host collection has not been accepted.")),l(A,{locale:n}),l("p",null,r("功能配置复用框架的保存、丢弃和退出流程；关闭本页显示不会删除历史记录。","Settings use the framework save, discard and exit flow. Hiding the tab does not delete historical records.")))},activate(){c.start();const e=oe({win:t,store:d,getLocale:s,provider:o.diskSmartInfo?.provider,findDetail:o.diskSmartInfo?.findDetail}),n=t.setInterval(()=>{d.status().dirty||"visible"!==t.document.visibilityState||d.load()},15e3);return()=>{c.stop(),t.clearInterval(n),e()}}}}(window.RivetinPlugins=window.RivetinPlugins||{})["rivetin-disk-smart-info"]=t})();"},{"path":"LICENSE","sha256":"684bcbdab63a2fef35293d3a36b13e01a755dff694c18f0aa8367710c36e4d22","data":"TUlUIExpY2Vuc2UKCkNvcHlyaWdodCAoYykgMjAyNiBQbHVnaW5LaXQgY29udHJpYnV0b3JzCgpQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5Cm9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlICJTb2Z0d2FyZSIpLCB0byBkZWFsCmluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uIHRoZSByaWdodHMKdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbApjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXMKZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKClRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluIGFsbApjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLgoKVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IKSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCkZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRQpBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSCkxJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HIEZST00sCk9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MgSU4gVEhFClNPRlRXQVJFLgo="}]}