@synopackageland/cli 0.5.0 → 0.6.0

package/dist/templates/native-go-jobs/frontend/src/background/BackgroundPanel.vue

@@ -0,0 +1,170 @@
+<script setup lang="ts">
+import {computed,onBeforeUnmount,onMounted,ref} from 'vue'
+import {Button,Callout,Checkbox,Form,FormActions,FormItem,Link,Select,SettingsSection} from '@synopackageland/ui'
+import type {Context} from '../context'
+import NasPicker from '../nas/NasPicker.vue'
+import {backgroundCopy,backgroundErrorCopy} from './i18n'
+import {createBackgroundPickerProvider} from './picker-provider'
+import {requestKey} from './request-key'
+interface Status{owner?:Owner;admin:boolean;revision:number;worker:{username:string;alive:boolean}|null;limits:{maxInputBytes:number;maxQueued:number;maxOwnerPending:number;maxOwnerBytes:number;jobTimeoutSeconds:number}}
+interface Owner{user:string;uid:string}
+interface Job{copyRetained?:boolean;scheduleId?:string;submitter:Owner;id:string;name:string;state:'queued'|'running'|'succeeded'|'failed'|'canceled'|'interrupted'}
+interface Schedule{id:string;name:string;owner:Owner;enabled:boolean;nextAt:string;intervalSeconds:number;workerRevision:number;missed:number;reason?:string}
+const props=defineProps<{ctx:Pick<Context,'call'|'locale'>}>()
+const copy=computed(()=>backgroundCopy(props.ctx.locale))
+const fill=(text:string,values:Record<string,string|number>)=>text.replace(/\{(\w+)\}/g,(_,k)=>String(values[k]??''))
+const status=ref<Status>(),jobs=ref<Job[]>([]),error=ref<unknown>(),unsupported=ref(false),busy=ref(false)
+const schedules=ref<Schedule[]>([]),scheduleSource=ref<Job>(),scheduleConsent=ref(false),scheduleInterval=ref('3600'),scheduleDelete=ref<Schedule>(),scheduleEnable=ref<Schedule>()
+const purgeOwner=ref<Owner>(),refreshing=ref(false)
+const picking=ref(false),picked=ref<{folder:string;relative:string}>(),download=ref(''),downloadName=ref('')
+const picker=createBackgroundPickerProvider(props.ctx)
+let timer:ReturnType<typeof setInterval>|undefined,disposed=false
+const settled=(j:Job)=>!['queued','running'].includes(j.state)
+async function call<T>(method:string,params?:Record<string,unknown>):Promise<T|undefined>{
+ try{return await props.ctx.call<T>(method,params)}
+ catch(e){
+  if(disposed)return undefined
+  if((e as {code?:string})?.code==='unsupported'){unsupported.value=true;jobs.value=[];schedules.value=[];scheduleSource.value=undefined;scheduleDelete.value=undefined;scheduleEnable.value=undefined;status.value=undefined;purgeOwner.value=undefined;picked.value=undefined;if(download.value)URL.revokeObjectURL(download.value);download.value=''}
+  else if(!disposed)error.value=e
+  return undefined
+ }
+}
+async function refresh(){
+ if(disposed||refreshing.value)return
+ refreshing.value=true
+ try{
+ const s=await call<Status>('bg.status')
+ if(!s||disposed)return
+ if(!s.limits||typeof s.admin!=='boolean'){error.value={code:'unavailable'};return}
+ unsupported.value=false;status.value=s
+ const list=await call<{jobs:Job[]}>('bg.jobs.list')
+ if(list&&!disposed)jobs.value=list.jobs??[]
+ const scheduleList=await call<{schedules:Schedule[]}>('bg.schedules.list')
+ if(scheduleList&&!disposed)schedules.value=scheduleList.schedules??[]
+ if(!disposed&&jobs.value.every(settled)&&schedules.value.every(s=>!s.enabled)&&timer){clearInterval(timer);timer=undefined}
+ }finally{refreshing.value=false}
+}
+function poll(){if(!timer)timer=setInterval(()=>void refresh(),3000)}
+async function guarded(work:()=>Promise<unknown>){
+ if(busy.value)return
+ busy.value=true;error.value=undefined
+ try{await work();await refresh();if(schedules.value.some(s=>s.enabled)||jobs.value.some(j=>!settled(j)))poll()}finally{if(!disposed)busy.value=false}
+}
+const purge=()=>guarded(async()=>{if(!purgeOwner.value)return;const out=await call('bg.jobs.purge',{owner:purgeOwner.value});if(out)purgeOwner.value=undefined})
+const intervalOptions=computed(()=>[{value:'3600',label:copy.value.hourly},{value:'86400',label:copy.value.daily},{value:'604800',label:copy.value.weekly}])
+const selectSchedule=(job:Job)=>{scheduleSource.value=job;scheduleConsent.value=false;scheduleInterval.value='3600'}
+const createSchedule=()=>guarded(async()=>{if(!scheduleSource.value||!scheduleConsent.value)return;const out=await call('bg.schedules.create',{key:requestKey(),jobId:scheduleSource.value.id,intervalSeconds:Number(scheduleInterval.value),consent:true});if(out)scheduleSource.value=undefined})
+const disableSchedule=(id:string)=>guarded(()=>call('bg.schedules.disable',{id}))
+const deleteSchedule=()=>guarded(async()=>{if(!scheduleDelete.value)return;const out=await call('bg.schedules.delete',{id:scheduleDelete.value.id});if(out)scheduleDelete.value=undefined})
+const enableSchedule=()=>guarded(async()=>{if(!scheduleEnable.value)return;const out=await call('bg.schedules.enable',{id:scheduleEnable.value.id,consent:true});if(out)scheduleEnable.value=undefined})
+const formatTime=(value:string)=>{const date=new Date(value);return Number.isFinite(date.getTime())?date.toLocaleString():copy.value.unknownTime}
+const ownCopy=(job:Job)=>job.copyRetained&&job.state==='succeeded'&&!job.scheduleId&&job.submitter?.user===status.value?.owner?.user&&job.submitter?.uid===status.value?.owner?.uid
+const cancel=(id:string)=>guarded(()=>call('bg.jobs.cancel',{id}))
+const pick=(path:string)=>{const at=path.lastIndexOf('/');picked.value={folder:path.slice(0,at),relative:path.slice(at+1)}}
+// The signed-in caller's own File Station session decides whether the
+// file can be read; the submit itself is the consent to copy that one file.
+const submit=()=>guarded(async()=>{
+ if(!picked.value)return
+ const sent=await call('bg.jobs.submit',{key:requestKey(),...picked.value})
+ if(sent)picked.value=undefined
+})
+async function fetchResult(job:Job){
+ const value=await call<{result:unknown}>('bg.jobs.result',{id:job.id})
+ if(!value||disposed)return
+ if(download.value)URL.revokeObjectURL(download.value)
+ download.value=URL.createObjectURL(new Blob([JSON.stringify(value.result,null,2)],{type:'application/json'}))
+ downloadName.value=`${job.name||job.id}.sha256.json`
+}
+onMounted(()=>void refresh().then(()=>{if(schedules.value.some(s=>s.enabled)||jobs.value.some(j=>!settled(j)))poll()}))
+onBeforeUnmount(()=>{disposed=true;picker.dispose();if(timer)clearInterval(timer);if(download.value)URL.revokeObjectURL(download.value)})
+</script>
+<template>
+ <SettingsSection :aria-busy="busy||refreshing" :title="copy.title" :collapsible="false" data-background-panel>
+  <Callout v-if="unsupported" tone="warning">{{ copy.unsupported }}</Callout>
+  <template v-else>
+   <p class="integration-help">{{ copy.help }}</p>
+   <Callout v-if="error" tone="danger" role="alert">{{ backgroundErrorCopy(error,copy) }}</Callout>
+   <template v-if="status">
+    <p role="status">{{ status.worker?.alive ? fill(copy.workerRunning,{user:status.worker.username}) : copy.workerStopped }}</p>
+    <p class="integration-help">{{ fill(copy.limits,{size:status.limits.maxInputBytes/1024,queue:status.limits.maxQueued,seconds:status.limits.jobTimeoutSeconds}) }}</p>
+    <p class="integration-help">{{ status.admin ? copy.adminScope : copy.ownerScope }}</p>
+    <p class="integration-help">{{ fill(copy.ownerLimits,{jobs:status.limits.maxOwnerPending,size:status.limits.maxOwnerBytes/1024}) }}</p>
+    <div class="integration-actions">
+     <Button variant="secondary" :disabled="busy" @click="refresh">{{ copy.refresh }}</Button>
+    </div>
+    <template>
+     <div class="integration-actions">
+      <Button variant="secondary" :disabled="busy" @click="picking=true">{{ copy.chooseFile }}</Button>
+      <Button variant="primary" :disabled="busy||!picked" @click="submit">{{ copy.submit }}</Button>
+     </div>
+     <p v-if="picked" role="status" data-bg-picked>{{ fill(copy.chosen,{path:`${picked.folder}/${picked.relative}`}) }}</p>
+     <NasPicker v-model:open="picking" :locale="ctx.locale" :provider="picker" mode="file" :title="copy.pickerTitle" :description="copy.pickerConsent" @selected="pick" />
+    </template>
+    <Callout v-if="purgeOwner&&status.admin" tone="warning">
+     <p>{{ fill(copy.purgeConfirm,{user:purgeOwner.user,uid:purgeOwner.uid}) }}</p>
+     <div class="integration-actions">
+      <Button variant="secondary" :disabled="busy" @click="purge">{{ copy.confirmPurge }}</Button>
+      <Button variant="secondary" :disabled="busy" @click="purgeOwner=undefined">{{ copy.keepJobs }}</Button>
+     </div>
+    </Callout>
+    <p v-if="!jobs.length">{{ copy.noJobs }}</p>
+    <ul v-else class="integration-jobs">
+     <li v-for="job in jobs" :key="job.id" :data-job-state="job.state" :data-job-id="job.id">
+      <span class="nas-folder-name">{{ job.name }} — {{ copy[`state_${job.state}`] }}</span>
+      <span v-if="status.admin&&job.submitter" class="integration-help">{{ fill(copy.owner,{user:job.submitter.user,uid:job.submitter.uid}) }}</span>
+      <Button v-if="status.admin&&job.submitter" variant="secondary" :disabled="busy" @click="purgeOwner=job.submitter">{{ copy.purgeOwner }}</Button>
+      <Button v-if="!settled(job)" variant="secondary" :disabled="busy" @click="cancel(job.id)">{{ copy.cancel }}</Button>
+      <Button v-if="ownCopy(job)" variant="secondary" :disabled="busy" @click="selectSchedule(job)">{{ copy.scheduleCopy }}</Button>
+      <span v-if="job.scheduleId" class="integration-help">{{ copy.scheduledJob }}</span>
+      <Button v-if="job.state==='succeeded'" variant="secondary" :disabled="busy" @click="fetchResult(job)">{{ copy.result }}</Button>
+     </li>
+    </ul>
+    <section data-bg-schedules class="bg-schedules" :aria-label="copy.schedulesTitle">
+     <h3>{{ copy.schedulesTitle }}</h3>
+     <p class="integration-help">{{ copy.scheduleHelp }}</p>
+     <Form v-if="scheduleSource" class="bg-schedule-form" @submit.prevent="createSchedule">
+      <p>{{ fill(copy.scheduleSource,{name:scheduleSource.name}) }}</p>
+      <FormItem :label="copy.interval"><Select v-model="scheduleInterval" data-schedule-interval :options="intervalOptions" :disabled="busy" /></FormItem>
+      <Checkbox v-model="scheduleConsent" data-schedule-consent :disabled="busy" :label="copy.scheduleConsent" />
+      <FormActions><Button type="submit" variant="primary" :disabled="busy||!scheduleConsent">{{ copy.createSchedule }}</Button><Button type="button" variant="secondary" :disabled="busy" @click="scheduleSource=undefined">{{ copy.cancel }}</Button></FormActions>
+     </Form>
+     <p v-if="!schedules.length">{{ copy.noSchedules }}</p>
+     <ul v-else class="integration-jobs">
+      <li v-for="schedule in schedules" :key="schedule.id" :data-schedule-id="schedule.id">
+       <span class="nas-folder-name">{{ schedule.name }} — {{ schedule.enabled ? copy.scheduleOn : copy.scheduleOff }}</span>
+       <span v-if="status.admin" class="integration-help">{{ fill(copy.owner,{user:schedule.owner.user,uid:schedule.owner.uid}) }}</span>
+       <span v-if="schedule.enabled" class="integration-help">{{ fill(copy.nextRun,{time:formatTime(schedule.nextAt)}) }}</span>
+       <span class="integration-help">{{ fill(copy.missedRuns,{count:schedule.missed}) }}</span>
+       <Callout v-if="schedule.reason==='worker-changed'" tone="warning">{{ copy.revisionChanged }}</Callout>
+       <Callout v-else-if="schedule.reason==='input-unavailable'" tone="warning">{{ copy.errors['input-unavailable'] }}</Callout>
+       <div class="integration-actions">
+       <Button v-if="schedule.enabled" variant="secondary" :disabled="busy" @click="disableSchedule(schedule.id)">{{ copy.disableSchedule }}</Button>
+       <Button v-else-if="status.admin" variant="secondary" :disabled="busy" @click="scheduleEnable=schedule">{{ copy.enableSchedule }}</Button>
+       <Button variant="secondary" :disabled="busy" @click="scheduleDelete=schedule">{{ copy.deleteSchedule }}</Button>
+       </div>
+      </li>
+     </ul>
+     <Callout v-if="scheduleDelete" tone="warning">
+      <p>{{ fill(copy.deleteScheduleConsent,{name:scheduleDelete.name}) }}</p>
+      <div class="integration-actions"><Button variant="danger" :disabled="busy" @click="deleteSchedule">{{ copy.confirmDeleteSchedule }}</Button><Button variant="secondary" :disabled="busy" @click="scheduleDelete=undefined">{{ copy.cancel }}</Button></div>
+     </Callout>
+     <Callout v-if="scheduleEnable" tone="warning">
+      <p>{{ fill(copy.enableScheduleConsent,{name:scheduleEnable.name}) }}</p>
+      <div class="integration-actions"><Button variant="primary" :disabled="busy" @click="enableSchedule">{{ copy.confirmEnableSchedule }}</Button><Button variant="secondary" :disabled="busy" @click="scheduleEnable=undefined">{{ copy.cancel }}</Button></div>
+     </Callout>
+    </section>
+    <Link v-if="download" :href="download" :download="downloadName">{{ copy.download }}</Link>
+   </template>
+  </template>
+ </SettingsSection>
+</template>
+
+<style scoped>
+.integration-jobs { overflow-wrap:anywhere; min-width:0; }
+.bg-schedules { margin-block-start: var(--ui-space-6,24px); min-width:0; overflow-wrap:anywhere; }
+.bg-schedules .integration-jobs { display:grid; gap:var(--ui-space-4,16px); padding-inline-start:var(--ui-space-5,20px); }
+.bg-schedules .integration-jobs li { display:flex; flex-direction:column; align-items:flex-start; gap:var(--ui-space-2,8px); min-width:0; }
+.bg-schedules p, .bg-schedules li > span { min-width:0; max-width:100%; }
+.bg-schedules h3 { font-size:15px; font-weight:600; }
+.bg-schedule-form { margin-block:var(--ui-space-4,16px); }
+</style>

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

@@ -0,0 +1,75 @@
+{
+  "title": "Hintergrundaufträge",
+  "help": "Kopiert eine ausgewählte Datei ins Paket und berechnet ihren SHA-256 als Paketbenutzer. Aufträge laufen nach der Abmeldung weiter. Kopie und Ergebnis bleiben im Paket; geänderte Quellberechtigungen rufen sie nicht zurück. Melden Sie sich erneut an, um Ihr Ergebnis zu sehen.",
+  "worker": "Worker",
+  "workerRunning": "Worker läuft als {user}",
+  "workerStopped": "Worker läuft nicht",
+  "chooseFile": "Datei auswählen",
+  "chosen": "Ausgewählte Datei: {path}",
+  "pickerTitle": "Datei zum Importieren auswählen",
+  "pickerConsent": "Die ausgewählte Datei wird einmalig mit Ihrer aktuellen DSM-Anmeldung gelesen und an den Hintergrundjob übergeben. Es wird keine Berechtigung gespeichert.",
+  "submit": "Importieren und senden",
+  "refresh": "Aktualisieren",
+  "cancel": "Abbrechen",
+  "result": "Ergebnis",
+  "download": "Ergebnis herunterladen",
+  "noJobs": "Noch keine Aufträge",
+  "state_queued": "In Warteschlange",
+  "state_running": "Läuft",
+  "state_succeeded": "Erfolgreich",
+  "state_failed": "Fehlgeschlagen",
+  "state_canceled": "Abgebrochen",
+  "state_interrupted": "Unterbrochen",
+  "limits": "Bis zu {size} KiB pro Datei, {queue} Aufträge in der Warteschlange, {seconds} Sekunden pro Auftrag.",
+  "errors": {
+    "jobs_busy": "Das System ist beschäftigt. Bitte versuchen Sie es später erneut.",
+    "failed": "Die Anfrage konnte nicht abgeschlossen werden. Aktualisieren und erneut versuchen.",
+    "limit-exceeded": "Die Datei überschreitet das Limit.",
+    "queue-full": "Die Warteschlange ist voll.",
+    "quota-exceeded": "Der Hintergrundspeicher ist voll.",
+    "conflict": "Der Auftragsstatus hat sich geändert. Aktualisieren.",
+    "not_found": "Nicht gefunden.",
+    "denied": "Zugriff verweigert.",
+    "session_required": "Ihre DSM-Sitzung ist abgelaufen. Melden Sie sich erneut an.",
+    "owner-queue-full": "Ihr Limit für offene Aufträge ist erreicht. Warten Sie auf einen Abschluss oder brechen Sie einen Auftrag ab.",
+    "owner-quota-exceeded": "Ihr Speicherlimit ist erreicht. Bitten Sie einen Administrator, alte Aufträge zu löschen.",
+    "identity_unavailable": "Ihre DSM-Benutzer-UID konnte nicht geprüft werden. Melden Sie sich erneut an oder fragen Sie einen Administrator.",
+    "schedule-full": "Maximal 8 Zeitpläne. Löschen Sie einen Zeitplan.",
+    "input-unavailable": "Die private Kopie fehlt oder wurde geändert. Importieren Sie sie erneut.",
+    "unsupported": "Hintergrundaufträge sind nicht verfügbar. Aktualisieren Sie und versuchen Sie es erneut."
+  },
+  "ownerScope": "Sie können nur eigene Aufträge sehen, abbrechen und herunterladen.",
+  "adminScope": "Administratoren können Aufträge aller Benutzer sehen und abbrechen.",
+  "ownerLimits": "Pro Benutzer: {jobs} offene Aufträge und {size} KiB für Eingaben und reservierte Ergebnisse.",
+  "owner": "Besitzer: {user} (UID {uid})",
+  "purgeOwner": "Aufträge des Besitzers löschen",
+  "purgeConfirm": "Alle Aufträge von {user} (UID {uid}) löschen? Laufende Aufträge werden abgebrochen und beendet; gespeicherte Ergebnisse werden entfernt.",
+  "confirmPurge": "Löschen bestätigen",
+  "keepJobs": "Aufträge behalten",
+  "schedulesTitle": "Zeitpläne",
+  "scheduleHelp": "Die feste private Kopie wird als Paketbenutzer stündlich, täglich oder wöchentlich neu berechnet. Bis zu 8 Zeitpläne. Verpasste Läufe werden protokolliert, nicht nachgeholt.",
+  "scheduleCopy": "Diese Kopie planen",
+  "scheduleSource": "Private Kopie: {name}",
+  "interval": "Wiederholungsintervall",
+  "hourly": "Stündlich",
+  "daily": "Täglich",
+  "weekly": "Wöchentlich",
+  "scheduleConsent": "Ich stimme zu, diese feste Kopie zu speichern und als Paketbenutzer neu zu berechnen. Neue Quelldateien und persönliche ACLs werden nicht gelesen.",
+  "createSchedule": "Zeitplan erstellen",
+  "noSchedules": "Noch keine Zeitpläne",
+  "scheduleOn": "Aktiviert",
+  "scheduleOff": "Deaktiviert",
+  "nextRun": "Nächster Lauf: {time}",
+  "missedRuns": "Verpasste Läufe: {count}",
+  "disableSchedule": "Zeitplan deaktivieren",
+  "deleteSchedule": "Zeitplan löschen",
+  "deleteScheduleConsent": "Zeitplan für {name} löschen? Wartende Jobs werden abgebrochen, laufende Jobs werden gestoppt und abgeschlossen. Fertige Ergebnisse bleiben erhalten.",
+  "confirmDeleteSchedule": "Löschen bestätigen",
+  "enableSchedule": "Zeitplan aktivieren",
+  "enableScheduleConsent": "Zeitplan für {name} mit der aktuellen Worker-Revision aktivieren? Ich stimme der Neuberechnung dieser festen Kopie zu. Frühere Läufe werden nicht wiederholt.",
+  "confirmEnableSchedule": "Aktivierung bestätigen",
+  "revisionChanged": "Die Worker-Revision hat sich geändert. Ein Administrator muss diesen Zeitplan prüfen und ausdrücklich aktivieren.",
+  "scheduledJob": "Geplanter Lauf",
+  "unknownTime": "Unbekannt",
+  "unsupported": "Hintergrundaufträge sind nicht verfügbar. Aktualisieren Sie und versuchen Sie es erneut."
+}

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

@@ -0,0 +1,75 @@
+{
+  "title": "Background jobs",
+  "help": "Copies one selected file into this package and computes its SHA-256 as the package user. Jobs continue after sign-out. The package keeps the copy and result; changes to source permissions do not recall them. Sign back in to read your result.",
+  "worker": "Worker",
+  "workerRunning": "Worker is running as {user}",
+  "workerStopped": "Worker is not running",
+  "chooseFile": "Choose a file",
+  "chosen": "Selected file: {path}",
+  "pickerTitle": "Choose a file to import",
+  "pickerConsent": "The selected file is read once with your current DSM sign-in and handed to the background job. No permission is saved.",
+  "submit": "Import and submit",
+  "refresh": "Refresh",
+  "cancel": "Cancel",
+  "result": "Result",
+  "download": "Download result",
+  "noJobs": "No jobs yet",
+  "state_queued": "Queued",
+  "state_running": "Running",
+  "state_succeeded": "Succeeded",
+  "state_failed": "Failed",
+  "state_canceled": "Canceled",
+  "state_interrupted": "Interrupted",
+  "limits": "Up to {size} KiB per file, {queue} queued jobs, {seconds} seconds per job.",
+  "errors": {
+    "jobs_busy": "Busy, please try again later.",
+    "failed": "The request could not be completed. Refresh and try again.",
+    "limit-exceeded": "The file is larger than the limit.",
+    "queue-full": "The queue is full.",
+    "quota-exceeded": "The background storage is full.",
+    "conflict": "The job changed state. Refresh.",
+    "not_found": "Not found.",
+    "denied": "Access was denied.",
+    "session_required": "Your DSM session expired. Sign in again.",
+    "owner-queue-full": "Your pending job limit is reached. Wait for a job to finish or cancel one.",
+    "owner-quota-exceeded": "Your background storage limit is reached. Ask an administrator to clear your old jobs.",
+    "identity_unavailable": "Your DSM user UID could not be verified. Sign in again or ask an administrator.",
+    "schedule-full": "The 8-schedule limit is reached. Delete a schedule.",
+    "input-unavailable": "The private copy is unavailable or changed. Import it again.",
+    "unsupported": "Background jobs are unavailable. Refresh and try again."
+  },
+  "ownerScope": "You can see, cancel and download only your own jobs.",
+  "adminScope": "Administrators can see and cancel every user’s jobs.",
+  "ownerLimits": "Per user: {jobs} pending jobs and {size} KiB of input and reserved result storage.",
+  "owner": "Owner: {user} (UID {uid})",
+  "purgeOwner": "Clear owner’s jobs",
+  "purgeConfirm": "Clear all jobs owned by {user} (UID {uid})? Running jobs are canceled and drained; this removes their saved results.",
+  "confirmPurge": "Confirm clear",
+  "keepJobs": "Keep jobs",
+  "schedulesTitle": "Schedules",
+  "scheduleHelp": "Reprocess a fixed private copy hourly, daily or weekly as the package user. Up to 8 schedules; missed runs are recorded and never replayed.",
+  "scheduleCopy": "Schedule this copy",
+  "scheduleSource": "Private copy: {name}",
+  "interval": "Repeat every",
+  "hourly": "Hour",
+  "daily": "Day",
+  "weekly": "Week",
+  "scheduleConsent": "I agree to keep and reprocess this fixed copy as the package user. No new source files or personal ACLs are read.",
+  "createSchedule": "Create schedule",
+  "noSchedules": "No schedules yet",
+  "scheduleOn": "Enabled",
+  "scheduleOff": "Disabled",
+  "nextRun": "Next run: {time}",
+  "missedRuns": "Missed runs: {count}",
+  "disableSchedule": "Disable schedule",
+  "deleteSchedule": "Delete schedule",
+  "deleteScheduleConsent": "Delete the schedule for {name}? Queued jobs are canceled and running jobs drain. Finished results remain.",
+  "confirmDeleteSchedule": "Confirm delete",
+  "enableSchedule": "Enable schedule",
+  "enableScheduleConsent": "Enable the schedule for {name} with the current worker revision? I agree to reprocess this fixed copy. Past runs will not be replayed.",
+  "confirmEnableSchedule": "Confirm enable",
+  "revisionChanged": "The worker revision changed. An administrator must review and explicitly enable this schedule.",
+  "scheduledJob": "Scheduled run",
+  "unknownTime": "Unknown",
+  "unsupported": "Background jobs are unavailable. Refresh and try again."
+}

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

@@ -0,0 +1,75 @@
+{
+  "title": "Trabajos en segundo plano",
+  "help": "Copia un archivo seleccionado al paquete y calcula su SHA-256 con la cuenta del paquete. Los trabajos continúan al cerrar sesión. El paquete conserva la copia y el resultado; cambiar los permisos de origen no los retira. Inicia sesión de nuevo para ver tu resultado.",
+  "worker": "Worker",
+  "workerRunning": "El worker se ejecuta como {user}",
+  "workerStopped": "El worker no se está ejecutando",
+  "chooseFile": "Elegir un archivo",
+  "chosen": "Archivo seleccionado: {path}",
+  "pickerTitle": "Elegir un archivo para importar",
+  "pickerConsent": "El archivo seleccionado se lee una sola vez con su inicio de sesión de DSM actual y se entrega al trabajo en segundo plano. No se guarda ningún permiso.",
+  "submit": "Importar y enviar",
+  "refresh": "Actualizar",
+  "cancel": "Cancelar",
+  "result": "Resultado",
+  "download": "Descargar resultado",
+  "noJobs": "Aún no hay trabajos",
+  "state_queued": "En cola",
+  "state_running": "En ejecución",
+  "state_succeeded": "Correcto",
+  "state_failed": "Error",
+  "state_canceled": "Cancelado",
+  "state_interrupted": "Interrumpido",
+  "limits": "Hasta {size} KiB por archivo, {queue} trabajos en cola, {seconds} segundos por trabajo.",
+  "errors": {
+    "jobs_busy": "El sistema está ocupado. Vuelve a intentarlo más tarde.",
+    "failed": "No se pudo completar la solicitud. Actualice e inténtelo de nuevo.",
+    "limit-exceeded": "El archivo supera el límite.",
+    "queue-full": "La cola está llena.",
+    "quota-exceeded": "El almacenamiento en segundo plano está lleno.",
+    "conflict": "El estado del trabajo cambió. Actualice.",
+    "not_found": "No encontrado.",
+    "denied": "Acceso denegado.",
+    "session_required": "Su sesión de DSM caducó. Inicie sesión de nuevo.",
+    "owner-queue-full": "Has alcanzado el límite de trabajos pendientes. Espera a que termine uno o cancélalo.",
+    "owner-quota-exceeded": "Has alcanzado el límite de almacenamiento. Pide a un administrador que borre trabajos antiguos.",
+    "identity_unavailable": "No se pudo verificar tu UID de usuario DSM. Inicia sesión de nuevo o contacta con un administrador.",
+    "schedule-full": "Se alcanzó el límite de 8 programaciones. Elimine una.",
+    "input-unavailable": "La copia privada no está disponible o cambió. Impórtela de nuevo.",
+    "unsupported": "Los trabajos en segundo plano no están disponibles. Actualiza e inténtalo de nuevo."
+  },
+  "ownerScope": "Solo puedes ver, cancelar y descargar tus propios trabajos.",
+  "adminScope": "Los administradores pueden ver y cancelar los trabajos de todos los usuarios.",
+  "ownerLimits": "Por usuario: {jobs} trabajos pendientes y {size} KiB para entradas y resultados reservados.",
+  "owner": "Propietario: {user} (UID {uid})",
+  "purgeOwner": "Borrar trabajos del propietario",
+  "purgeConfirm": "¿Borrar todos los trabajos de {user} (UID {uid})? Los trabajos en curso se cancelarán y terminarán; se eliminarán los resultados guardados.",
+  "confirmPurge": "Confirmar borrado",
+  "keepJobs": "Conservar trabajos",
+  "schedulesTitle": "Programaciones",
+  "scheduleHelp": "Recalcula la copia privada fija como usuario del paquete cada hora, día o semana. Hasta 8 programaciones. Las ejecuciones perdidas se registran sin recuperarlas.",
+  "scheduleCopy": "Programar esta copia",
+  "scheduleSource": "Copia privada: {name}",
+  "interval": "Intervalo de repetición",
+  "hourly": "Cada hora",
+  "daily": "Cada día",
+  "weekly": "Cada semana",
+  "scheduleConsent": "Acepto conservar esta copia fija y recalcularla como usuario del paquete. No se leen nuevos archivos de origen ni ACL personales.",
+  "createSchedule": "Crear programación",
+  "noSchedules": "No hay programaciones",
+  "scheduleOn": "Activada",
+  "scheduleOff": "Desactivada",
+  "nextRun": "Próxima ejecución: {time}",
+  "missedRuns": "Ejecuciones perdidas: {count}",
+  "disableSchedule": "Desactivar programación",
+  "deleteSchedule": "Eliminar programación",
+  "deleteScheduleConsent": "¿Eliminar la programación de {name}? Los trabajos en cola se cancelan y los activos se detienen y finalizan. Se conservan los resultados completados.",
+  "confirmDeleteSchedule": "Confirmar eliminación",
+  "enableSchedule": "Activar programación",
+  "enableScheduleConsent": "¿Activar la programación de {name} con la revisión actual del worker? Acepto recalcular esta copia fija. No se repetirán ejecuciones anteriores.",
+  "confirmEnableSchedule": "Confirmar activación",
+  "revisionChanged": "La revisión del worker cambió. Un administrador debe revisar y activar explícitamente esta programación.",
+  "scheduledJob": "Ejecución programada",
+  "unknownTime": "Desconocida",
+  "unsupported": "Los trabajos en segundo plano no están disponibles. Actualiza e inténtalo de nuevo."
+}

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

@@ -0,0 +1,75 @@
+{
+  "title": "Tâches en arrière-plan",
+  "help": "Copie un fichier sélectionné dans le paquet et calcule son SHA-256 avec le compte du paquet. Les tâches continuent après la déconnexion. Le paquet conserve la copie et le résultat ; une modification des droits de la source ne les retire pas. Reconnectez-vous pour consulter votre résultat.",
+  "worker": "Worker",
+  "workerRunning": "Le worker s’exécute sous {user}",
+  "workerStopped": "Le worker n’est pas en cours d’exécution",
+  "chooseFile": "Choisir un fichier",
+  "chosen": "Fichier sélectionné : {path}",
+  "pickerTitle": "Choisir un fichier à importer",
+  "pickerConsent": "Le fichier sélectionné est lu une seule fois avec votre connexion DSM actuelle et transmis à la tâche en arrière-plan. Aucune autorisation n'est enregistrée.",
+  "submit": "Importer et envoyer",
+  "refresh": "Actualiser",
+  "cancel": "Annuler",
+  "result": "Résultat",
+  "download": "Télécharger le résultat",
+  "noJobs": "Aucune tâche",
+  "state_queued": "En attente",
+  "state_running": "En cours",
+  "state_succeeded": "Réussie",
+  "state_failed": "Échec",
+  "state_canceled": "Annulée",
+  "state_interrupted": "Interrompue",
+  "limits": "Jusqu’à {size} Kio par fichier, {queue} tâches en attente, {seconds} secondes par tâche.",
+  "errors": {
+    "jobs_busy": "Le système est occupé. Veuillez réessayer plus tard.",
+    "failed": "La requête n’a pas pu aboutir. Actualisez puis réessayez.",
+    "limit-exceeded": "Le fichier dépasse la limite.",
+    "queue-full": "La file d’attente est pleine.",
+    "quota-exceeded": "Le stockage en arrière-plan est plein.",
+    "conflict": "L’état de la tâche a changé. Actualisez.",
+    "not_found": "Introuvable.",
+    "denied": "Accès refusé.",
+    "session_required": "Votre session DSM a expiré. Reconnectez-vous.",
+    "owner-queue-full": "Votre limite de tâches en attente est atteinte. Attendez une fin ou annulez une tâche.",
+    "owner-quota-exceeded": "Votre limite de stockage est atteinte. Demandez à un administrateur d’effacer vos anciennes tâches.",
+    "identity_unavailable": "L’UID de votre utilisateur DSM n’a pas pu être vérifié. Reconnectez-vous ou contactez un administrateur.",
+    "schedule-full": "La limite de 8 planifications est atteinte. Supprimez-en une.",
+    "input-unavailable": "La copie privée manque ou a changé. Importez-la à nouveau.",
+    "unsupported": "Les tâches en arrière-plan sont indisponibles. Actualisez et réessayez."
+  },
+  "ownerScope": "Vous pouvez voir, annuler et télécharger uniquement vos propres tâches.",
+  "adminScope": "Les administrateurs peuvent voir et annuler les tâches de tous les utilisateurs.",
+  "ownerLimits": "Par utilisateur : {jobs} tâches en attente et {size} KiB pour les entrées et résultats réservés.",
+  "owner": "Propriétaire : {user} (UID {uid})",
+  "purgeOwner": "Effacer les tâches du propriétaire",
+  "purgeConfirm": "Effacer toutes les tâches de {user} (UID {uid}) ? Les tâches en cours seront annulées et terminées ; les résultats enregistrés seront supprimés.",
+  "confirmPurge": "Confirmer l’effacement",
+  "keepJobs": "Conserver les tâches",
+  "schedulesTitle": "Planifications",
+  "scheduleHelp": "Recalcule la copie privée fixe avec le compte du paquet chaque heure, jour ou semaine. Jusqu’à 8 planifications. Les exécutions manquées sont consignées sans rattrapage.",
+  "scheduleCopy": "Planifier cette copie",
+  "scheduleSource": "Copie privée : {name}",
+  "interval": "Intervalle de répétition",
+  "hourly": "Chaque heure",
+  "daily": "Chaque jour",
+  "weekly": "Chaque semaine",
+  "scheduleConsent": "J’accepte de conserver cette copie fixe et de la recalculer avec le compte du paquet. Aucun nouveau fichier source ni ACL personnel n’est lu.",
+  "createSchedule": "Créer la planification",
+  "noSchedules": "Aucune planification",
+  "scheduleOn": "Activée",
+  "scheduleOff": "Désactivée",
+  "nextRun": "Prochaine exécution : {time}",
+  "missedRuns": "Exécutions manquées : {count}",
+  "disableSchedule": "Désactiver la planification",
+  "deleteSchedule": "Supprimer la planification",
+  "deleteScheduleConsent": "Supprimer la planification de {name} ? Les tâches en attente sont annulées et celles en cours s’arrêtent proprement. Les résultats terminés sont conservés.",
+  "confirmDeleteSchedule": "Confirmer la suppression",
+  "enableSchedule": "Activer la planification",
+  "enableScheduleConsent": "Activer la planification de {name} avec la révision actuelle du worker ? J’accepte de recalculer cette copie fixe. Les anciennes exécutions ne seront pas rejouées.",
+  "confirmEnableSchedule": "Confirmer l’activation",
+  "revisionChanged": "La révision du worker a changé. Un administrateur doit vérifier et activer explicitement cette planification.",
+  "scheduledJob": "Exécution planifiée",
+  "unknownTime": "Inconnue",
+  "unsupported": "Les tâches en arrière-plan sont indisponibles. Actualisez et réessayez."
+}

package/dist/templates/native-go-jobs/frontend/src/background/i18n/it.json

@@ -0,0 +1,75 @@
+{
+  "title": "Processi in background",
+  "help": "Copia un file selezionato nel pacchetto e calcola il suo SHA-256 con l’account del pacchetto. I processi continuano dopo la disconnessione. Il pacchetto conserva copia e risultato; i cambiamenti ai permessi di origine non li revocano. Accedi di nuovo per vedere il tuo risultato.",
+  "worker": "Worker",
+  "workerRunning": "Il worker è in esecuzione come {user}",
+  "workerStopped": "Il worker non è in esecuzione",
+  "chooseFile": "Scegli un file",
+  "chosen": "File selezionato: {path}",
+  "pickerTitle": "Scegli un file da importare",
+  "pickerConsent": "Il file selezionato viene letto una sola volta con l'accesso DSM corrente e passato al processo in background. Nessuna autorizzazione viene salvata.",
+  "submit": "Importa e invia",
+  "refresh": "Aggiorna",
+  "cancel": "Annulla",
+  "result": "Risultato",
+  "download": "Scarica il risultato",
+  "noJobs": "Nessun processo",
+  "state_queued": "In coda",
+  "state_running": "In esecuzione",
+  "state_succeeded": "Riuscito",
+  "state_failed": "Non riuscito",
+  "state_canceled": "Annullato",
+  "state_interrupted": "Interrotto",
+  "limits": "Fino a {size} KiB per file, {queue} processi in coda, {seconds} secondi per processo.",
+  "errors": {
+    "jobs_busy": "Il sistema è occupato. Riprova più tardi.",
+    "failed": "Impossibile completare la richiesta. Aggiornate e riprovate.",
+    "limit-exceeded": "Il file supera il limite.",
+    "queue-full": "La coda è piena.",
+    "quota-exceeded": "Lo spazio di archiviazione in background è pieno.",
+    "conflict": "Lo stato del processo è cambiato. Aggiornate.",
+    "not_found": "Non trovato.",
+    "denied": "Accesso negato.",
+    "session_required": "La sessione DSM è scaduta. Accedete di nuovo.",
+    "owner-queue-full": "Hai raggiunto il limite dei processi in attesa. Attendi il completamento o annulla un processo.",
+    "owner-quota-exceeded": "Hai raggiunto il limite di archiviazione. Chiedi a un amministratore di cancellare i vecchi processi.",
+    "identity_unavailable": "Impossibile verificare l’UID dell’utente DSM. Accedi di nuovo o contatta un amministratore.",
+    "schedule-full": "Limite di 8 pianificazioni raggiunto. Eliminane una.",
+    "input-unavailable": "La copia privata non è disponibile o è cambiata. Importala di nuovo.",
+    "unsupported": "I processi in background non sono disponibili. Aggiorna e riprova."
+  },
+  "ownerScope": "Puoi vedere, annullare e scaricare solo i tuoi processi.",
+  "adminScope": "Gli amministratori possono vedere e annullare i processi di tutti gli utenti.",
+  "ownerLimits": "Per utente: {jobs} processi in attesa e {size} KiB per input e risultati riservati.",
+  "owner": "Proprietario: {user} (UID {uid})",
+  "purgeOwner": "Cancella processi del proprietario",
+  "purgeConfirm": "Cancellare tutti i processi di {user} (UID {uid})? I processi in corso saranno annullati e terminati; i risultati salvati saranno rimossi.",
+  "confirmPurge": "Conferma cancellazione",
+  "keepJobs": "Conserva processi",
+  "schedulesTitle": "Pianificazioni",
+  "scheduleHelp": "Ricalcola la copia privata fissa come utente del pacchetto ogni ora, giorno o settimana. Fino a 8 pianificazioni. Le esecuzioni perse vengono registrate, senza recupero.",
+  "scheduleCopy": "Pianifica questa copia",
+  "scheduleSource": "Copia privata: {name}",
+  "interval": "Intervallo di ripetizione",
+  "hourly": "Ogni ora",
+  "daily": "Ogni giorno",
+  "weekly": "Ogni settimana",
+  "scheduleConsent": "Acconsento a conservare questa copia fissa e a ricalcolarla come utente del pacchetto. Non vengono letti nuovi file di origine o ACL personali.",
+  "createSchedule": "Crea pianificazione",
+  "noSchedules": "Nessuna pianificazione",
+  "scheduleOn": "Attiva",
+  "scheduleOff": "Disattivata",
+  "nextRun": "Prossima esecuzione: {time}",
+  "missedRuns": "Esecuzioni perse: {count}",
+  "disableSchedule": "Disattiva pianificazione",
+  "deleteSchedule": "Elimina pianificazione",
+  "deleteScheduleConsent": "Eliminare la pianificazione di {name}? I lavori in coda vengono annullati e quelli in corso vengono arrestati e conclusi. I risultati completati restano.",
+  "confirmDeleteSchedule": "Conferma eliminazione",
+  "enableSchedule": "Attiva pianificazione",
+  "enableScheduleConsent": "Attivare la pianificazione di {name} con la revisione attuale del worker? Acconsento a ricalcolare questa copia fissa. Le esecuzioni passate non saranno ripetute.",
+  "confirmEnableSchedule": "Conferma attivazione",
+  "revisionChanged": "La revisione del worker è cambiata. Un amministratore deve verificare e attivare esplicitamente questa pianificazione.",
+  "scheduledJob": "Esecuzione pianificata",
+  "unknownTime": "Sconosciuta",
+  "unsupported": "I processi in background non sono disponibili. Aggiorna e riprova."
+}