@synopackageland/cli 0.4.1 → 0.5.0

package/templates/native-go-vue/frontend/src/jobs/JobsPanel.vue

@@ -0,0 +1,135 @@
+<script setup lang="ts">
+import {computed,inject,onMounted,onBeforeUnmount,ref,watch} from 'vue'
+import {Button,Callout,Checkbox,SettingsSection} from '@synopackageland/ui'
+import {JobsProviderKey,type BackgroundSummary,type JobView} from './provider'
+import {unavailableJobsProvider} from './mock-provider'
+import {jobPage,consentSummary} from './validate'
+import {jobCopy} from './i18n'
+import InteractiveJobForm from './InteractiveJobForm.vue'
+import {useNasRequest} from '../nas/use-request'
+const props=defineProps<{locale:string;section?:'all'|'interactive'|'background'}>(),copy=computed(()=>jobCopy(props.locale))
+// One provider can have both modes; the shell shows them as separate pages
+// while the combined 'all' view stays the default for the standalone preview.
+const mode=computed(()=>props.section??'all')
+const showInteractive=computed(()=>mode.value!=='background'),showBackground=computed(()=>mode.value!=='interactive')
+const visibleJobs=computed(()=>mode.value==='all'?jobs.value:jobs.value.filter(job=>job.mode===(mode.value==='interactive'?'interactive':'background')))
+const provider=inject(JobsProviderKey,unavailableJobsProvider),request=useNasRequest(),{busy,error}=request
+let poll:ReturnType<typeof setTimeout>|undefined
+function clearPoll(){if(poll!==undefined)clearTimeout(poll);poll=undefined}
+function schedulePoll(){if(provider.mode==='connected'&&provider.readiness?.interactive==='ready'&&jobs.value.some(j=>['pending','running','draining','cancel-requested'].includes(j.state)))poll=setTimeout(()=>{poll=undefined;void load()},2500)}
+const invalidated=ref(false)
+const nextCursor=ref<string>()
+const jobs=ref<readonly JobView[]>([]),summary=ref<BackgroundSummary>(),agree=ref(false),uncertain=ref(false)
+watch(error,e=>{if(['denied','session_required','auth_unavailable'].includes((e as {code?:string})?.code??'')){invalidated.value=true;jobs.value=[];summary.value=undefined;agree.value=false}})
+async function load(cursor?:string){if(invalidated.value||busy.value)return;clearPoll();const result=await request.run(async signal=>jobPage(await provider.list(signal,cursor)));if(result){jobs.value=result.items;nextCursor.value=result.nextCursor;schedulePoll()}else if(error.value&&provider.readiness?.interactive!=='revalidating'){jobs.value=[];nextCursor.value=undefined}}
+async function refresh(){await load()}
+async function prepare(){agree.value=false;const result=await request.run(async signal=>consentSummary(await provider.prepare(signal)));if(result)summary.value=result}
+function discard(){request.cancel();summary.value=undefined;agree.value=false}
+async function confirm(){
+ const exact=summary.value;if(!exact||!agree.value||uncertain.value)return
+ if(Date.now()>=exact.intentExpiresAt){request.error.value={code:'expired'};return}
+ // Any missing confirmation reply is uncertain, including AbortSignal/timeout.
+ // Keep the original intent and never offer a second submission from this view.
+ uncertain.value=true
+ const ok=await request.run(async signal=>{await provider.confirm(exact,signal);return true})
+ if(ok){summary.value=undefined;uncertain.value=false;await refresh()}
+}
+async function lookup(){const exact=summary.value;if(!exact)return
+ const found=await request.run(signal=>provider.lookup(exact.intentId,signal))
+ if(found){summary.value=undefined;uncertain.value=false;await refresh()}
+}
+async function stop(job:JobView){
+ await request.run(async signal=>{
+  if(job.mode==='background'){
+   const d=job.delegation;if(!d)throw {code:'unavailable'}
+   await provider.revoke(d.id,d.revision,d.storeRevision,signal)
+  }else await provider.cancel(job.jobId,job.revision,signal)
+ });await refresh()
+}
+async function resubmit(job:JobView){
+ await request.run(signal=>provider.resubmit!(job.jobId,signal));await refresh()
+}
+async function lookupResubmission(job:JobView){
+ await request.run(signal=>provider.lookupResubmission!(job.jobId,signal));await refresh()
+}
+function fenceCanceled(job:JobView){return job.mode==='interactive'&&job.state==='canceled'&&job.safeReason==='fenced'}
+function label(job:JobView){const c=copy.value
+ return ({pending:c.pending,running:c.running,'cancel-requested':c.stopping,draining:c.stopping,succeeded:c.succeeded,failed:c.failed,canceled:c.canceled,interrupted:c.interrupted,'cleanup-required':c.cleanup})[job.state]??c.error
+}
+function time(value:number){try{return new Intl.DateTimeFormat(props.locale,{dateStyle:'medium',timeStyle:'short'}).format(value)}catch{return new Date(value).toISOString()}}
+onMounted(()=>{if(provider.mode!=='unavailable')void refresh()})
+onBeforeUnmount(()=>{clearPoll();request.cancel();provider.disconnect()})
+</script>
+<template>
+ <SettingsSection :title="copy.title" :collapsible="false" :aria-busy="busy" class="jobs-panel">
+  <Callout v-if="provider.mode==='unavailable'" tone="info" :title="copy.unavailable" />
+  <Callout v-else-if="invalidated" tone="danger" :title="copy.accessLost" role="alert" />
+  <template v-else>
+   <p v-if="provider.mode==='mock'">{{ copy.mock }}</p>
+   <template v-if="showInteractive">
+   <Callout v-if="provider.readiness?.interactive==='revalidating'" tone="info" :title="copy.revalidating" role="status" aria-live="polite" />
+   <Callout v-if="provider.readiness?.interactive==='unavailable'" tone="info" :title="copy.interactiveUnavailable" />
+   <p>{{ copy.interactiveHelp }}</p>
+   </template>
+   <template v-if="showBackground">
+   <Callout v-if="provider.readiness?.background==='unavailable'" tone="info" :title="copy.backgroundUnavailable" />
+   <p v-else>{{ copy.backgroundHelp }}</p>
+   </template>
+   <Callout v-if="error && (error as {code?:string}).code!=='revalidating'" tone="danger" :title="copy.error" role="alert" />
+   <InteractiveJobForm v-if="showInteractive && provider.interactive" :provider="provider" :locale="locale" @submitted="refresh" />
+   <div class="integration-actions">
+    <Button v-if="showBackground && provider.readiness?.background!=='unavailable'" :disabled="busy||!!summary" @click="prepare">{{ copy.prepare }}</Button>
+    <Button variant="secondary" :disabled="busy" @click="refresh">{{ copy.refresh }}</Button>
+   </div>
+   <section v-if="showBackground && summary" :aria-label="copy.prepare" class="jobs-review">
+    <dl class="nas-summary">
+     <dt>{{ copy.app }}</dt><dd>{{ summary.app }}</dd>
+     <dt>{{ copy.worker }}</dt><dd>{{ summary.worker }}</dd>
+     <dt>{{ copy.scope }}</dt><dd>{{ summary.parent }}</dd>
+     <dt>{{ copy.actions }}</dt><dd>{{ summary.actions.join(', ') }}</dd>
+     <dt>{{ copy.steps }}</dt><dd>{{ summary.steps }}</dd>
+     <dt>{{ copy.starts }}</dt><dd>{{ time(summary.notBefore) }}</dd>
+     <dt>{{ copy.expires }}</dt><dd>{{ time(summary.expiresAt) }}</dd>
+    </dl>
+    <ol><li v-for="(step,index) in summary.inputSummary" :key="index">{{ step }}</li></ol>
+    <p>{{ copy.warning }}</p>
+    <template v-if="!uncertain">
+     <Checkbox v-model="agree" class="jobs-agree" :disabled="busy" :label="copy.agree" />
+     <div class="integration-actions"><Button :disabled="busy||!agree" @click="confirm">{{ copy.confirm }}</Button><Button variant="secondary" @click="discard">{{ copy.close }}</Button></div>
+    </template>
+    <template v-else><p role="status">{{ copy.uncertain }}</p><Button :disabled="busy" @click="lookup">{{ copy.lookup }}</Button></template>
+   </section>
+   <p v-if="!visibleJobs.length&&!busy&&!error">{{ copy.empty }}</p>
+   <ul class="nas-grants">
+    <li v-for="job in visibleJobs" :key="job.jobId">
+     <p role="status">{{ label(job) }}</p>
+     <progress v-if="job.totalUnits!==undefined&&job.totalUnits>0" :value="job.completedUnits" :max="job.totalUnits" :aria-label="label(job)" />
+     <p v-else>{{ copy.unknown }}</p>
+     <p v-if="job.delegation?.revoked">{{ copy.revoked }}</p><p v-if="job.drained">{{ copy.drained }}</p>
+     <p v-if="job.effectsUnknown">{{ copy.effects }}</p>
+     <template v-if="fenceCanceled(job)">
+      <p>{{ copy.fenceCanceled }}</p>
+      <template v-if="provider.resubmissionState?.(job.jobId)==='uncertain'">
+       <p role="status">{{ copy.resubmitUncertain }}</p>
+       <Button variant="secondary" :disabled="busy||provider.readiness?.interactive!=='ready'" @click="lookupResubmission(job)">{{ copy.resubmitLookup }}</Button>
+      </template>
+      <p v-else-if="provider.resubmissionState?.(job.jobId)==='submitted'" role="status">{{ copy.resubmitSubmitted }}</p>
+      <template v-else>
+       <p v-if="!provider.canResubmit?.(job.jobId)">{{ copy.resubmitUnavailable }}</p>
+       <Button variant="secondary" :disabled="busy||provider.readiness?.interactive!=='ready'||!provider.canResubmit?.(job.jobId)" @click="resubmit(job)">{{ copy.resubmit }}</Button>
+      </template>
+     </template>
+     <Button v-if="['pending','running','draining','cancel-requested'].includes(job.state)" variant="secondary" :disabled="busy||provider.readiness?.interactive==='revalidating'" @click="stop(job)">{{ job.mode==='background'?copy.revoke:copy.cancel }}</Button>
+    </li>
+   </ul>
+   <Button v-if="nextCursor" :disabled="busy" variant="secondary" @click="load(nextCursor)">{{ copy.next }}</Button>
+  </template>
+ </SettingsSection>
+</template>
+<style scoped>
+.jobs-panel { max-inline-size: 70ch; overflow-wrap: anywhere; }
+.jobs-review { margin-block: var(--ui-space-4, 1rem); }
+.jobs-agree { margin-block: var(--ui-space-4, 1rem); }
+dd { overflow-wrap: anywhere; }
+progress { max-inline-size: 100%; accent-color: var(--ui-accent); }
+</style>

package/templates/native-go-vue/frontend/src/jobs/connected-provider.ts

@@ -0,0 +1,179 @@
+import {reactive,shallowRef} from 'vue'
+import type {Context} from '../context'
+import type {JobsProvider,JobsAdminProvider,JobPage,JobView,BackgroundSummary,InteractivePlan,PreparedInteractive,InteractiveWorker} from './provider'
+import {jobPage,adminPage,jobViews} from './validate'
+
+export const ATTACH_RENEW_MS=2000
+export const ATTACH_TTL_MS=6000
+const REQUEST_MS=3000
+const MAX_ATTACH=2
+const ref=(x:unknown):x is string=>typeof x==='string'&&/^[a-f0-9]{64}$/.test(x)
+const positive=(x:unknown):x is number=>Number.isSafeInteger(x)&&Number(x)>0
+const refused=(code='invalid-request'):never=>{throw {code}}
+const safeCodes=new Set(['invalid-request','incompatible','unsupported','replay','stale','expired','denied','unavailable','suspended','revoked','fenced','revalidating','busy','limit-exceeded','canceled','timeout','cleanup-required','session_required','auth_unavailable'])
+function safeError(e:unknown){const code=(e as {code?:string})?.code;return {code:code&&safeCodes.has(code)?code:'unavailable'}}
+export type {PreparedInteractive} from './provider'
+interface Lease {jobId:string;attachId:string;revision:number;deadline:number}
+interface WireJob extends Omit<JobView,'completedUnits'|'totalUnits'|'delegation'> {
+ progress:{completedUnits:number;totalUnits?:number}
+ delegation?:{id:string;revision:number;storeRevision:number;state:string}
+}
+function view(raw:WireJob):JobView{
+ if(!raw||!ref(raw.jobId)||!raw.progress)refused()
+ return jobViews([{jobId:raw.jobId,revision:raw.revision,mode:raw.mode,state:raw.state,drained:raw.drained,effectsUnknown:raw.effectsUnknown,completedUnits:raw.progress.completedUnits,...(raw.safeReason?{safeReason:raw.safeReason}:{}),...(raw.progress.totalUnits===undefined?{}:{totalUnits:raw.progress.totalUnits}),...(raw.delegation?{delegation:{id:raw.delegation.id,revision:raw.delegation.revision,storeRevision:raw.delegation.storeRevision,revoked:raw.delegation.state==='revoked'}}:{})}])[0]
+}
+function prepared(raw:PreparedInteractive):PreparedInteractive{
+ if(!raw||!ref(raw.intentId)||!ref(raw.jobId)||!ref(raw.summaryDigest)||!positive(raw.expiresAt))refused()
+ return {intentId:raw.intentId,jobId:raw.jobId,summaryDigest:raw.summaryDigest,expiresAt:raw.expiresAt}
+}
+function workerViews(raw:unknown):InteractiveWorker[]{
+ if(raw===undefined)return [] // Older owners have no submission form.
+ if(!Array.isArray(raw)||raw.length>16)return refused()
+ const ids=new Set<string>()
+ return raw.map(w=>{
+  if(!w||typeof w.id!=='string'||! /^[a-z][a-z0-9_]{0,31}$/.test(w.id)||ids.has(w.id)||!positive(w.revision)||!positive(w.maxBytes)||w.maxBytes>524288||!Array.isArray(w.actions)||!w.actions.length||w.actions.length>3||new Set(w.actions).size!==w.actions.length||w.actions.some((a:unknown)=>!['nas.files.list','nas.files.stat','nas.files.read'].includes(a as string)))refused()
+  ids.add(w.id);return {id:w.id,revision:w.revision,actions:[...w.actions],maxBytes:w.maxBytes}
+ })
+}
+export function createConnectedJobsProvider(ctx:Pick<Context,'call'>){
+ let disposed=false,timer:ReturnType<typeof setTimeout>|undefined
+ const readiness=reactive<{interactive:'ready'|'revalidating'|'unavailable';background:'unavailable'}>({interactive:'unavailable',background:'unavailable'})
+ const workers=shallowRef<readonly InteractiveWorker[]>([])
+ // Local plans are display/retry input, never authority or persisted credentials.
+ const preparedPlans=new Map<string,InteractivePlan>(),plans=new Map<string,InteractivePlan>()
+ const resubmissions=new Map<string,{state:'preparing'|'uncertain'|'submitted';prepared?:PreparedInteractive}>()
+ function retain<K,V>(map:Map<K,V>,key:K,value:V){if(map.size>=256&&!map.has(key))map.delete(map.keys().next().value!);map.set(key,value)}
+ const life=new AbortController(),leases=new Map<string,Lease>(),known=new Map<string,JobView>()
+ async function request<T>(method:string,args:Record<string,unknown>,signal:AbortSignal):Promise<T>{
+  if(disposed||signal.aborted)refused('canceled')
+  let cleanup=()=>{}
+  const abort=new Promise<never>((_,reject)=>{
+   const canceled=()=>reject({code:'canceled'})
+   const deadline=setTimeout(()=>reject({code:'timeout'}),REQUEST_MS)
+   signal.addEventListener('abort',canceled,{once:true});life.signal.addEventListener('abort',canceled,{once:true})
+   cleanup=()=>{clearTimeout(deadline);signal.removeEventListener('abort',canceled);life.signal.removeEventListener('abort',canceled)}
+  })
+  try{
+   const value=await Promise.race([ctx.call<T>(method,args),abort])
+   if(disposed||signal.aborted)refused('canceled')
+   return value
+  }catch(e){const error=safeError(e);if(error.code==='revalidating')readiness.interactive='revalidating';else if(readiness.interactive!=='revalidating')readiness.interactive='unavailable';throw error}finally{cleanup()}
+ }
+ function schedule(){if(!disposed&&leases.size&&timer===undefined)timer=setTimeout(()=>{timer=undefined;void renew()},ATTACH_RENEW_MS)}
+ async function renew(){
+  for(const lease of [...leases.values()]){
+   if(disposed)break
+   if(performance.now()>=lease.deadline){leases.delete(lease.jobId);continue}
+   try{
+    await request('jobs.attach',{jobId:lease.jobId,attachId:lease.attachId},life.signal)
+    if(!disposed&&leases.get(lease.jobId)===lease)lease.deadline=performance.now()+ATTACH_TTL_MS
+   }catch(e){
+    if(['expired','stale','denied','fenced','revalidating','canceled','session_required','auth_unavailable'].includes(safeError(e).code))leases.delete(lease.jobId)
+    // Busy/network failure cannot extend the original client deadline. Root
+    // monotonic TTL is authoritative even while this tab's timer is suspended.
+   }
+  }
+  schedule()
+ }
+ function remember(job:JobView){
+  if(known.size>=256&&!known.has(job.jobId))known.clear()
+  known.set(job.jobId,job)
+  const lease=leases.get(job.jobId)
+  if(lease){lease.revision=job.revision;if(['succeeded','failed','canceled','interrupted','cleanup-required'].includes(job.state))leases.delete(job.jobId)}
+ }
+ function disconnect(){
+  if(disposed)return
+  disposed=true
+  readiness.interactive='unavailable'
+  if(timer!==undefined)clearTimeout(timer)
+  timer=undefined
+  window.removeEventListener('pagehide',disconnect)
+  life.abort()
+  for(const lease of leases.values()){
+   // Best effort only. ctx.call preserves native session/CSRF transport. We do
+   // not claim delivery or Q and never renew after pagehide/bfcache/unmount.
+   void ctx.call('jobs.cancel',{jobId:lease.jobId,revision:lease.revision}).catch(()=>{})
+  }
+  workers.value=[];leases.clear();known.clear();preparedPlans.clear();plans.clear();resubmissions.clear()
+ }
+ window.addEventListener('pagehide',disconnect)
+ const provider:JobsProvider={
+  mode:'connected',readiness,
+  async list(signal,cursor){
+   const raw=await request<{revision:number;items:WireJob[];nextCursor?:string;availability?:string;workers?:unknown}>('jobs.status',cursor?{cursor}:{},signal)
+   if(!raw||!Array.isArray(raw.items)||raw.items.length>10)refused()
+   const page=jobPage({revision:raw.revision,items:raw.items.map(view),...(raw.nextCursor?{nextCursor:raw.nextCursor}:{})})
+   try{workers.value=raw.availability==='session-required'?workerViews(raw.workers):[]}
+   catch(e){workers.value=[];readiness.interactive='unavailable';throw e}
+   if(raw.availability==='session-required')readiness.interactive='ready'
+   else if(readiness.interactive!=='revalidating')readiness.interactive='unavailable'
+   page.items.forEach(remember);return page
+  },
+  async prepare(){return refused('unavailable')},
+  async confirm(_summary:BackgroundSummary){return refused('unavailable')},
+  async lookup(intentId,signal){if(!ref(intentId))refused();const job=view(await request<WireJob>('jobs.lookup',{intentId},signal));remember(job);return job},
+  async cancel(jobId,revision,signal){if(!ref(jobId)||!positive(revision))refused();await request('jobs.cancel',{jobId,revision},signal);leases.delete(jobId)},
+  async revoke(id,revision,storeRevision,signal){
+   const job=[...known.values()].find(j=>j.delegation?.id===id)
+   if(!job)return refused('stale')
+   const raw=await request<{revoked:boolean;drained:boolean}>('jobs.revoke',{jobId:job.jobId,revision:job.revision,delegationRevision:revision,storeRevision},signal)
+   if(typeof raw?.revoked!=='boolean'||typeof raw.drained!=='boolean')refused()
+   return {revoked:raw.revoked,drained:raw.drained}
+  },
+  canResubmit(jobId){const job=known.get(jobId);return !!job&&job.mode==='interactive'&&job.state==='canceled'&&job.safeReason==='fenced'&&plans.has(jobId)&&!resubmissions.has(jobId)},
+  resubmissionState(jobId){const state=resubmissions.get(jobId)?.state;return state==='preparing'?undefined:state},
+  async resubmit(jobId,signal){
+   if(!provider.canResubmit?.(jobId)||readiness.interactive!=='ready')return refused('unavailable')
+   const plan=plans.get(jobId)!
+   // Reserve locally before the first await, preventing simultaneous clicks.
+   retain(resubmissions,jobId,{state:'preparing'})
+   let value:PreparedInteractive
+   try{value=await connected.prepareInteractive(signal,plan.worker,plan.parent,plan.input)}
+   catch(e){resubmissions.delete(jobId);throw e}
+   plans.delete(jobId) // consume the old plan before the one submit attempt
+   resubmissions.set(jobId,{state:'uncertain',prepared:value})
+   const result=await connected.submitInteractive(value,signal)
+   resubmissions.set(jobId,{state:'submitted',prepared:value})
+   return result
+  },
+  async lookupResubmission(jobId,signal){
+   const retry=resubmissions.get(jobId)
+   if(!retry||retry.state!=='uncertain'||!retry.prepared)return refused('unavailable')
+   const job=await provider.lookup(retry.prepared.intentId,signal)
+   if(!job||job.jobId!==retry.prepared.jobId)return refused('unavailable')
+   retry.state='submitted';return {jobId:job.jobId}
+  },disconnect,
+ }
+ const connected=Object.assign(provider,{
+  readiness,
+  async prepareInteractive(signal:AbortSignal,worker:InteractivePlan['worker'],parent:InteractivePlan['parent'],input:InteractivePlan['input']){
+   const plan:InteractivePlan={worker:{id:worker.id,revision:worker.revision},parent:{id:parent.id,revision:parent.revision},input:{steps:input.steps.map(s=>({action:s.action,segments:[...s.segments],...(s.limit===undefined?{}:{limit:s.limit}),...(s.maxBytes===undefined?{}:{maxBytes:s.maxBytes})}))}}
+   const value=prepared(await request<PreparedInteractive>('jobs.prepare',plan as unknown as Record<string,unknown>,signal))
+   retain(preparedPlans,value.intentId,plan);return value
+  },
+  async submitInteractive(value:PreparedInteractive,signal:AbortSignal){
+   const input=prepared(value)
+   if(leases.size>=MAX_ATTACH)refused('busy')
+   const plan=preparedPlans.get(input.intentId);preparedPlans.delete(input.intentId)
+   // Never retry submit automatically, including after a lost response.
+   const raw=await request<Lease&{renewAfterMs:number;ttlMs:number}>('jobs.submit',{intentId:input.intentId,summaryDigest:input.summaryDigest},signal)
+   if(!raw||raw.jobId!==input.jobId||!ref(raw.attachId)||!positive(raw.revision)||raw.renewAfterMs!==ATTACH_RENEW_MS||raw.ttlMs!==ATTACH_TTL_MS)refused()
+   leases.set(raw.jobId,{jobId:raw.jobId,attachId:raw.attachId,revision:raw.revision,deadline:performance.now()+ATTACH_TTL_MS})
+   if(plan)retain(plans,raw.jobId,plan)
+   schedule()
+   return {jobId:raw.jobId}
+  },
+ })
+ return Object.assign(connected,{interactive:{get workers(){return workers.value},prepareInteractive:connected.prepareInteractive,submitInteractive:connected.submitInteractive}})
+}
+export function createConnectedJobsAdminProvider(ctx:Pick<Context,'call'>):JobsAdminProvider{
+ return {mode:'connected',async list(signal,cursor){
+  if(signal.aborted)refused('canceled')
+  const page=adminPage(await ctx.call('jobs.admin.status',cursor?{cursor}:{}))
+  if(signal.aborted)refused('canceled');return page
+ },async cancel(jobId,revision,signal){
+  if(signal.aborted)refused('canceled')
+  await ctx.call('jobs.admin.cancel',{jobId,revision})
+  if(signal.aborted)refused('canceled')
+ }}
+}

package/templates/native-go-vue/frontend/src/jobs/i18n/de.json

@@ -0,0 +1,62 @@
+{
+  "title": "Aufträge",
+  "unavailable": "Aufträge sind in diesem Build nicht verfügbar.",
+  "mock": "Testvorschau: keine NAS-Aktion",
+  "interactiveHelp": "Diese Ansicht erneuert interaktive Aufträge alle 2 Sekunden. Nach 6 Sekunden ohne Erneuerung beginnt der Abbruch; er endet erst nach bestätigter Bereinigung. Schließen fordert den Abbruch an. Verborgene Tabs können zum Ablauf und Abbruch führen.",
+  "backgroundHelp": "Bestätigte Hintergrundarbeit kann nach Schließen oder Abmelden bis zum Ablauf oder Neustart weiterlaufen. Kein Fortsetzen nach Neustart.",
+  "prepare": "Hintergrundauftrag prüfen",
+  "confirm": "Einmal bestätigen",
+  "agree": "Ich stimme diesem einmaligen Nur-Lese-Auftrag auch während meiner Abwesenheit zu.",
+  "refresh": "Aktualisieren",
+  "lookup": "Ursprünglichen Auftrag prüfen",
+  "uncertain": "Bestätigungsantwort verloren. Ursprünglichen Auftrag prüfen, nicht erneut senden.",
+  "close": "Prüfung verwerfen",
+  "cancel": "Auftrag abbrechen",
+  "revoke": "Hintergrundzustimmung widerrufen",
+  "revoked": "Widerrufen",
+  "drained": "Bereinigung bestätigt",
+  "cleanup": "Bereinigung erforderlich",
+  "unknown": "Gesamtfortschritt unbekannt",
+  "error": "Anfrage fehlgeschlagen. Aktuellen Zustand durch Aktualisieren prüfen.",
+  "empty": "Keine Aufträge",
+  "pending": "Ausstehend",
+  "running": "Läuft",
+  "stopping": "Wird beendet",
+  "succeeded": "Abgeschlossen",
+  "failed": "Fehlgeschlagen",
+  "canceled": "Abgebrochen",
+  "interrupted": "Unterbrochen",
+  "app": "App",
+  "worker": "Worker",
+  "scope": "Bereichsreferenz",
+  "actions": "Aktionen",
+  "steps": "Schritte",
+  "expires": "Ablauf",
+  "starts": "Frühester Start",
+  "warning": "Bereits erfolgte Aktionen sind nicht rückgängig zu machen. Zustimmung gilt einmal im aktuellen Lauf.",
+  "effects": "Auswirkungen möglicherweise unbekannt",
+  "next": "Nächste Seite",
+  "accessLost": "Zugriff nicht bestätigt. Melden Sie sich erneut an und öffnen Sie diese Ansicht neu.",
+  "interactiveUnavailable": "Interaktive Aufträge sind erst nach Anbindung der nativen Sitzungs- und Berechtigungsprüfung verfügbar.",
+  "backgroundUnavailable": "Hintergrundaufträge sind nicht verfügbar.",
+  "adminTitle": "Auftragsverwaltung",
+  "loadManagement": "Aktualisieren, um den Verwaltungsstatus zu laden.",
+  "revalidating": "Die Paketprüfungen werden erneut validiert. Neue Aufträge sind pausiert. Aktualisieren Sie zur Prüfung der Wiederherstellung. Abgebrochene Aufträge werden nicht fortgesetzt.",
+  "fenceCanceled": "Dieser Auftrag wurde abgebrochen, weil die Paketprüfungen nicht verfügbar waren. Nach der Wiederherstellung erstellt erneutes Senden einen neuen Auftrag mit erneuter Berechtigungsprüfung. Es erfolgt kein automatisches Senden.",
+  "resubmit": "Erneut senden",
+  "resubmitUnavailable": "Der ursprüngliche Ablauf ist in dieser Ansicht nicht verfügbar. Wählen Sie die Eingaben erneut, um einen neuen Auftrag zu erstellen.",
+  "resubmitUncertain": "Die Antwort auf das erneute Senden fehlt. Prüfen Sie den neuen Auftrag und senden Sie nicht erneut.",
+  "resubmitLookup": "Neuen Auftrag prüfen",
+  "resubmitSubmitted": "Ein neuer Auftrag wurde gesendet. Der abgebrochene Auftrag bleibt gestoppt.",
+  "newInteractive": "Neuer interaktiver Auftrag",
+  "chooseSource": "Quelldatei oder Ordner wählen",
+  "sourceHelp": "Nur lesender Auftrag mit Ihrer aktuellen DSM-Sitzung. Die Dateiauswahl speichert die Zustimmung für den übergeordneten Ordner. Inhalte werden verworfen; nur Zähler werden gemeldet.",
+  "operation": "Aktion",
+  "statOperation": "Metadaten prüfen",
+  "listOperation": "Ordner auflisten",
+  "readOperation": "Datei lesen (Bytes zählen)",
+  "entryLimit": "Maximale Einträge (1–100)",
+  "byteLimit": "Maximale Bytes",
+  "submitInteractive": "Auftrag einmal senden",
+  "interactiveSubmitted": "Auftrag gesendet. Prüfen Sie unten den Fortschritt."
+}

package/templates/native-go-vue/frontend/src/jobs/i18n/en.json

@@ -0,0 +1,62 @@
+{
+  "title": "Jobs",
+  "unavailable": "Jobs are unavailable in this build.",
+  "mock": "Mock preview — no NAS operation",
+  "interactiveHelp": "This view renews interactive work every 2 seconds. After 6 seconds without renewal, cancellation starts; it completes only after cleanup is confirmed. Closing the view requests cancellation. Hidden tabs may expire and cancel the job.",
+  "backgroundHelp": "An explicitly confirmed background job may continue after closing or signing out, until expiry or restart. Restart does not resume it.",
+  "prepare": "Review background job",
+  "confirm": "Confirm once",
+  "agree": "I agree to this one-time read-only job continuing while I am offline.",
+  "refresh": "Refresh",
+  "lookup": "Check original job",
+  "uncertain": "Confirmation reply was lost. Check the original job; do not submit again.",
+  "close": "Discard review",
+  "cancel": "Cancel job",
+  "revoke": "Revoke background consent",
+  "revoked": "Revoked",
+  "drained": "Cleanup confirmed",
+  "cleanup": "Cleanup required",
+  "unknown": "Progress total unknown",
+  "error": "Request could not be completed. Refresh to check the current state.",
+  "empty": "No jobs",
+  "pending": "Pending",
+  "running": "Running",
+  "stopping": "Stopping",
+  "succeeded": "Completed",
+  "failed": "Failed",
+  "canceled": "Canceled",
+  "interrupted": "Interrupted",
+  "app": "App",
+  "worker": "Worker",
+  "scope": "Scope reference",
+  "actions": "Actions",
+  "steps": "Steps",
+  "expires": "Expires",
+  "starts": "Earliest start",
+  "warning": "Effects already completed cannot be undone. Consent is valid for one job before the app restarts.",
+  "effects": "Effects may be unknown",
+  "next": "Next page",
+  "accessLost": "Access could not be verified. Sign in again and reopen this view.",
+  "interactiveUnavailable": "Interactive jobs are unavailable until native session and permission checks are connected.",
+  "backgroundUnavailable": "Background jobs are unavailable.",
+  "adminTitle": "Job management",
+  "loadManagement": "Refresh to load management status.",
+  "revalidating": "Package checks are being revalidated. New jobs are paused. Refresh to check recovery; canceled jobs will not resume.",
+  "fenceCanceled": "This job was canceled because package checks became unavailable. After recovery, resubmit to create a new job and check permissions again. Nothing is resubmitted automatically.",
+  "resubmit": "Resubmit",
+  "resubmitUnavailable": "The original plan is unavailable in this view. Select the inputs again to create a new job.",
+  "resubmitUncertain": "The resubmission reply was lost. Check the new job; do not submit again.",
+  "resubmitLookup": "Check new job",
+  "resubmitSubmitted": "A new job was submitted. The canceled job remains stopped.",
+  "newInteractive": "New interactive job",
+  "chooseSource": "Choose source file or folder",
+  "sourceHelp": "Read-only job using your current DSM session. Selecting a file saves consent for its containing folder. File contents are discarded; jobs report counters only.",
+  "operation": "Operation",
+  "statOperation": "Inspect metadata",
+  "listOperation": "List folder",
+  "readOperation": "Read file (count bytes)",
+  "entryLimit": "Maximum entries (1–100)",
+  "byteLimit": "Maximum bytes",
+  "submitInteractive": "Submit job once",
+  "interactiveSubmitted": "Job submitted. Check progress below."
+}

package/templates/native-go-vue/frontend/src/jobs/i18n/es.json

@@ -0,0 +1,62 @@
+{
+  "title": "Trabajos",
+  "unavailable": "Los trabajos no están disponibles en esta versión.",
+  "mock": "Vista simulada: sin operaciones NAS",
+  "interactiveHelp": "Esta vista renueva las tareas interactivas cada 2 segundos. Tras 6 segundos sin renovación, empieza la cancelación; termina cuando se confirma la limpieza. Cerrar la vista solicita la cancelación. Las pestañas ocultas pueden provocar la caducidad y la cancelación.",
+  "backgroundHelp": "Un trabajo de fondo confirmado puede continuar tras cerrar o salir hasta caducar o reiniciar. No se reanuda tras reiniciar.",
+  "prepare": "Revisar trabajo de fondo",
+  "confirm": "Confirmar una vez",
+  "agree": "Acepto este trabajo único de solo lectura mientras estoy desconectado.",
+  "refresh": "Actualizar",
+  "lookup": "Consultar trabajo original",
+  "uncertain": "Se perdió la respuesta. Consulte el trabajo original sin enviarlo de nuevo.",
+  "close": "Descartar revisión",
+  "cancel": "Cancelar trabajo",
+  "revoke": "Revocar consentimiento",
+  "revoked": "Revocado",
+  "drained": "Limpieza confirmada",
+  "cleanup": "Limpieza necesaria",
+  "unknown": "Total desconocido",
+  "error": "No se pudo completar la solicitud. Actualice para comprobar el estado.",
+  "empty": "Sin trabajos",
+  "pending": "Pendiente",
+  "running": "En ejecución",
+  "stopping": "Deteniéndose",
+  "succeeded": "Completado",
+  "failed": "Fallido",
+  "canceled": "Cancelado",
+  "interrupted": "Interrumpido",
+  "app": "Aplicación",
+  "worker": "Worker",
+  "scope": "Referencia de alcance",
+  "actions": "Acciones",
+  "steps": "Pasos",
+  "expires": "Caducidad",
+  "starts": "Inicio más temprano",
+  "warning": "Los efectos ya producidos no se pueden deshacer. El consentimiento vale una vez en el período actual.",
+  "effects": "Puede haber efectos desconocidos",
+  "next": "Página siguiente",
+  "accessLost": "No se pudo verificar el acceso. Inicie sesión y abra esta vista de nuevo.",
+  "interactiveUnavailable": "Las tareas interactivas no están disponibles hasta conectar las comprobaciones nativas de sesión y permisos.",
+  "backgroundUnavailable": "Las tareas en segundo plano no están disponibles.",
+  "adminTitle": "Gestión de tareas",
+  "loadManagement": "Actualice para cargar el estado de gestión.",
+  "revalidating": "Se están revalidando las comprobaciones del paquete. Los trabajos nuevos están en pausa. Actualice para comprobar la recuperación; los trabajos cancelados no se reanudan.",
+  "fenceCanceled": "Este trabajo se canceló porque las comprobaciones del paquete no estaban disponibles. Tras la recuperación, reenviarlo crea un trabajo nuevo y vuelve a comprobar los permisos. No hay reenvío automático.",
+  "resubmit": "Volver a enviar",
+  "resubmitUnavailable": "El plan original no está disponible en esta vista. Seleccione de nuevo las entradas para crear un trabajo nuevo.",
+  "resubmitUncertain": "Se perdió la respuesta al reenvío. Compruebe el trabajo nuevo y no vuelva a enviarlo.",
+  "resubmitLookup": "Comprobar trabajo nuevo",
+  "resubmitSubmitted": "Se envió un trabajo nuevo. El trabajo cancelado sigue detenido.",
+  "newInteractive": "Nueva tarea interactiva",
+  "chooseSource": "Elegir archivo o carpeta de origen",
+  "sourceHelp": "Tarea de solo lectura con su sesión DSM actual. Elegir un archivo guarda el consentimiento para su carpeta. El contenido se descarta; solo se informan contadores.",
+  "operation": "Operación",
+  "statOperation": "Consultar metadatos",
+  "listOperation": "Listar carpeta",
+  "readOperation": "Leer archivo (contar bytes)",
+  "entryLimit": "Máximo de entradas (1–100)",
+  "byteLimit": "Máximo de bytes",
+  "submitInteractive": "Enviar tarea una vez",
+  "interactiveSubmitted": "Tarea enviada. Consulte el progreso abajo."
+}

package/templates/native-go-vue/frontend/src/jobs/i18n/fr.json

@@ -0,0 +1,62 @@
+{
+  "title": "Tâches",
+  "unavailable": "Les tâches ne sont pas disponibles dans cette version.",
+  "mock": "Aperçu simulé : aucune opération NAS",
+  "interactiveHelp": "Cette vue renouvelle les tâches interactives toutes les 2 secondes. Après 6 secondes sans renouvellement, leur annulation commence et se termine après confirmation du nettoyage. Fermer la vue demande une annulation. Un onglet masqué peut entraîner une expiration et une annulation.",
+  "backgroundHelp": "Une tâche de fond confirmée peut continuer après fermeture ou déconnexion jusqu’à expiration ou redémarrage. Aucun redémarrage de tâche automatique.",
+  "prepare": "Examiner la tâche de fond",
+  "confirm": "Confirmer une fois",
+  "agree": "J’accepte cette tâche unique en lecture seule pendant mon absence.",
+  "refresh": "Actualiser",
+  "lookup": "Vérifier la tâche initiale",
+  "uncertain": "Réponse perdue. Vérifiez la tâche initiale sans la soumettre à nouveau.",
+  "close": "Abandonner l’examen",
+  "cancel": "Annuler la tâche",
+  "revoke": "Révoquer le consentement",
+  "revoked": "Révoqué",
+  "drained": "Nettoyage confirmé",
+  "cleanup": "Nettoyage nécessaire",
+  "unknown": "Total inconnu",
+  "error": "Impossible de terminer la demande. Actualisez pour vérifier l’état.",
+  "empty": "Aucune tâche",
+  "pending": "En attente",
+  "running": "En cours",
+  "stopping": "Arrêt en cours",
+  "succeeded": "Terminé",
+  "failed": "Échec",
+  "canceled": "Annulé",
+  "interrupted": "Interrompu",
+  "app": "Application",
+  "worker": "Worker",
+  "scope": "Référence du périmètre",
+  "actions": "Actions",
+  "steps": "Étapes",
+  "expires": "Expiration",
+  "starts": "Début au plus tôt",
+  "warning": "Les effets déjà produits ne sont pas annulables. Le consentement ne vaut qu’une fois dans cette session de fonctionnement.",
+  "effects": "Effets potentiellement inconnus",
+  "next": "Page suivante",
+  "accessLost": "Accès non vérifié. Reconnectez-vous et rouvrez cette vue.",
+  "interactiveUnavailable": "Les tâches interactives attendent la connexion des contrôles natifs de session et de droits.",
+  "backgroundUnavailable": "Les tâches en arrière-plan sont indisponibles.",
+  "adminTitle": "Gestion des tâches",
+  "loadManagement": "Actualisez pour charger l’état de gestion.",
+  "revalidating": "Les vérifications du paquet sont en cours de revalidation. Les nouveaux travaux sont suspendus. Actualisez pour vérifier le rétablissement ; les travaux annulés ne reprennent pas.",
+  "fenceCanceled": "Ce travail a été annulé car les vérifications du paquet étaient indisponibles. Après rétablissement, une nouvelle soumission crée un nouveau travail et revérifie les permissions. Aucune soumission automatique.",
+  "resubmit": "Soumettre à nouveau",
+  "resubmitUnavailable": "Le plan initial est indisponible dans cette vue. Sélectionnez à nouveau les entrées pour créer un nouveau travail.",
+  "resubmitUncertain": "La réponse à la nouvelle soumission a été perdue. Vérifiez le nouveau travail sans le soumettre à nouveau.",
+  "resubmitLookup": "Vérifier le nouveau travail",
+  "resubmitSubmitted": "Un nouveau travail a été soumis. Le travail annulé reste arrêté.",
+  "newInteractive": "Nouvelle tâche interactive",
+  "chooseSource": "Choisir un fichier ou dossier source",
+  "sourceHelp": "Tâche en lecture seule avec votre session DSM actuelle. Choisir un fichier enregistre le consentement pour son dossier parent. Le contenu est supprimé ; seuls les compteurs sont rapportés.",
+  "operation": "Opération",
+  "statOperation": "Vérifier les métadonnées",
+  "listOperation": "Lister le dossier",
+  "readOperation": "Lire le fichier (compter les octets)",
+  "entryLimit": "Nombre maximal (1–100)",
+  "byteLimit": "Octets maximaux",
+  "submitInteractive": "Envoyer la tâche une fois",
+  "interactiveSubmitted": "Tâche envoyée. Consultez la progression ci-dessous."
+}