@synopackageland/cli 0.8.0 → 0.9.0

package/dist/templates/native-go-vue/frontend/package.json

@@ -1,6 +0,0 @@
-{
-  "name": "native-dsm-vue-app", "private": true, "type": "module",
-  "scripts": {"build": "vue-tsc --noEmit && vite build", "test": "vitest run"},
-  "dependencies": {"@lucide/vue": "1.48.0", "@synopackageland/ui": "0.8.1", "vue": "3.5.43"},
-  "devDependencies": {"@vitejs/plugin-vue": "6.0.9", "vite": "7.3.6", "typescript": "5.9.3", "vue-tsc": "3.3.11", "vitest": "4.1.11", "jsdom": "27.4.0"}
-}

package/dist/templates/native-go-vue/frontend/src/App.vue

@@ -1,96 +0,0 @@
-<script setup lang="ts">
-import {computed, onMounted, onUnmounted, ref, watch} from 'vue'
-import {AppRoot, ConfigProvider, Button, Callout, Form, FormActions, FormItem, SettingsSection, Textarea} from '@synopackageland/ui'
-import {uiLocale} from './nas/locale'
-import {appCopy} from './i18n'
-import type {AppStatus, Context} from './context'
-import AppShell from './shell/AppShell.vue'
-import CapabilityPanels from './CapabilityPanels.vue'
-import FilesPage from './files/FilesPage.vue'
-import PortalSettings from './portal/PortalSettings.vue'
-import {shellPages, type ShellPage} from './shell/pages'
-import {createSession} from './identity/session'
-import LoginPage from './identity/LoginPage.vue'
-const props = defineProps<{ctx: Context}>()
-const login = createSession(props.ctx)
-const copy = computed(() => appCopy(props.ctx.locale))
-const app = ref<AppStatus>()
-const busy = ref(false)
-const error = ref('')
-const notice = ref('')
-const text = ref('')
-let disposed = false
-let unsubscribe: (() => void) | undefined
-// The CLI substitutes this only for a declared package-account background worker.
-const backgroundEnabled = (('__BACKGROUND_ENABLED__') as string) === 'true'
-const page = ref<ShellPage>('status')
-const pages = computed(() => shellPages({background:backgroundEnabled}))
-const subtitle = computed(() => app.value ? `${app.value.package} · ${app.value.user} · ${app.value.version}` : undefined)
-function message(e: unknown) {
- const code = (e as {code?: string})?.code || 'request_failed'
- const errors = copy.value.errors as Record<string, string>
- return (code !== 'request_failed' && errors[code]) || errors.request_failed!.replace('{code}', code)
-}
-async function refresh() {
- if(disposed || busy.value || (login.enabled.value && !login.subject.value)) return
- busy.value = true; error.value = ''
- try {
-  const a = await login.call<AppStatus>('app.status')
-  if(!disposed) app.value = a
-  if(a.admin) {const greeting = await login.call<{text:string}>('greeting.get'); if(!disposed) text.value = greeting.text}
- } catch(e) {if(!disposed) error.value = message(e)} finally {if(!disposed) busy.value=false}
-}
-async function save() {
- if(disposed || busy.value) return
- busy.value = true; error.value='';notice.value=''
- try {await login.call('greeting.set',{text:text.value});if(!disposed) notice.value=copy.value.saved}
- catch(e) {if(!disposed) error.value=message(e)} finally {if(!disposed) busy.value=false}
-}
-watch(login.subject, (subject, previous) => {
- if(!subject) {app.value=undefined;text.value='';notice.value='';error.value=''}
- else if((!previous || previous.user!==subject.user)) void refresh()
-})
-async function signOut() {
- try {await login.logout()} catch(e) {if(!disposed) error.value=message(e)}
-}
-onMounted(async()=>{
- unsubscribe = props.ctx.reopen(()=>{if(!disposed) void refresh()})
- await login.start()
- if((!login.enabled.value || login.subject.value)) await refresh()
-})
-onUnmounted(()=>{disposed=true;unsubscribe?.();login.dispose();text.value=''})
-</script>
-
-<template>
- <AppRoot modal-scope="app" style="height: 100%">
-  <ConfigProvider :locale="uiLocale(ctx.locale)">
-  <p v-if="!login.ready.value" role="status">{{ copy.checking }}</p>
-  <LoginPage v-else-if="login.enabled.value && !login.subject.value" :session="login" :locale="ctx.locale" />
-  <AppShell v-else v-model="page" :locale="ctx.locale" :pages="pages" :description="subtitle">
-   <template #actions><Button variant="secondary" :disabled="busy" @click="refresh">{{ copy.refresh }}</Button><Button v-if="login.enabled.value" variant="secondary" :disabled="busy" @click="signOut">{{ copy.signOut }}</Button></template>
-   <div class="integration-app" :aria-busy="busy" :aria-label="copy.settings">
-    <p v-if="busy" role="status">{{ copy.loading }}</p>
-    <Callout v-if="error" tone="danger" :title="copy.actionRequired"><span role="alert">{{ error }}</span></Callout>
-    <p v-if="notice" role="status">{{ notice }}</p>
-    <div data-page="status" v-show="page==='status'">
-     <SettingsSection :title="copy.statusTitle" :collapsible="false">
-      <p v-if="app">{{ app.package }} · {{ app.user }} · {{ app.version }}</p>
-      <p v-else-if="error" role="status">{{ copy.statusError }}</p>
-     </SettingsSection>
-     <PortalSettings v-if="ctx.portal && app" :key="app.user" :portal="ctx.portal" />
-     <SettingsSection v-if="app?.admin" :title="copy.greeting" :collapsible="false">
-      <Form @submit.prevent="save"><FormItem :label="copy.greeting"><Textarea v-model="text" :disabled="busy" /></FormItem>
-       <FormActions><Button variant="primary" :disabled="busy || !text.trim()" @click="save">{{ copy.save }}</Button></FormActions>
-      </Form>
-     </SettingsSection>
-    </div>
-    <CapabilityPanels v-if="app" :key="app.user" :ctx="ctx" :admin="app.admin" />
-    <FilesPage v-if="page==='status'" :ctx="ctx" />
-    <div data-page="background" v-show="page==='background'">
-   <!-- BACKGROUND_PANEL -->
-    </div>
-   </div>
-  </AppShell>
-  </ConfigProvider>
- </AppRoot>
-</template>

package/dist/templates/native-go-vue/frontend/src/CapabilityPanels.vue

@@ -1,6 +0,0 @@
-<script setup lang="ts">
-import type {Context} from './context'
-import ExecutorSettings from './delegate/ExecutorSettings.vue'
-defineProps<{ctx:Context;admin:boolean}>()
-</script>
-<template><ExecutorSettings v-if="ctx.executor" :admin="admin" :locale="ctx.locale" /></template>

package/dist/templates/native-go-vue/frontend/src/context.ts

@@ -1,78 +0,0 @@
-export interface HostPlatformSnapshot {
- readonly web: boolean
- readonly host: 'dsm' | 'standalone-web' | 'unavailable'
- readonly dsmStandalone: boolean | null
- readonly dsmLanguage: string | null
- readonly appLocale: string | null
- readonly systemVersion: string | null
- readonly fullVersion: string | null
- readonly theme: null
-}
-export type HostTitleResult = {status: 'ok'; target: 'dsm-window' | 'document'} |
- {status: 'unsupported' | 'unavailable' | 'invalid-input' | 'failed'}
-export type HostRequestResult = {status: 'requested'} |
- {status: 'unsupported' | 'unavailable' | 'invalid-input' | 'blocked' | 'failed'}
-export type HostURLResult = {status: 'requested'; windowHandleAvailable: boolean} |
- {status: 'unsupported' | 'unavailable' | 'invalid-input' | 'failed'}
-export type HostEvent = 'window-resize' | 'host-theme-change' | 'host-language-change'
-export type HostSubscriptionResult = {status: 'subscribed'; dispose(): void} |
- {status: 'unsupported' | 'unavailable' | 'invalid-input' | 'failed'}
-export type HostFileNavigationResult = {status: 'requested'; action: 'locate-folder' | 'highlight-file'} |
- {status: 'unsupported' | 'unavailable' | 'invalid-input' | 'failed'}
-export type HostUnsupportedResult = {status: 'unsupported' | 'unavailable'}
-export interface HostAdapter {
- platform(): HostPlatformSnapshot
- setTitle(title: string): HostTitleResult
- activateWindow(): HostRequestResult
- requestClose(): HostRequestResult
- openApp(appId: string): HostRequestResult
- openURL(url: string): HostURLResult
- openFileManager(path: string): HostFileNavigationResult
- revealFile(path: string): HostFileNavigationResult
- openFile(path: string): HostUnsupportedResult
- showFileDetails(paths: readonly string[]): HostUnsupportedResult
- openAppSetting(): HostUnsupportedResult
- subscribe(event: HostEvent, listener: () => void): HostSubscriptionResult
- dispose(): void
-}
-export interface PortalStatus {
- state: 'active' | 'inactive' | 'unavailable'
- // Set when active: https://<the NAS address in use>/<alias>/
- alias?: string
- url?: string
- // An administrator can set or clear the alias here; otherwise Control Panel or nothing.
- canManage: boolean
- controlPanel: boolean
- defaultAlias: string
-}
-
-// Rejects {code}: portal_alias_invalid, portal_alias_reserved, portal_alias_in_use, admin_required, portal_unavailable.
-export interface PortalAccess {
- // SDK panel text in DSM's language, keyed like the error codes plus title, link, apply, …
- messages: Record<string, string>
- status(): Promise<PortalStatus>
- apply(alias: string): Promise<PortalStatus>
- disable(): Promise<PortalStatus>
- openControlPanel(): void
- // The SDK's plain panel; Vue apps use portal/PortalSettings.vue instead.
- mountPanel(element: HTMLElement): {refresh(): Promise<void>; dispose(): void}
-}
-
-export interface Context {
- // Explicit long-running opt-in; bind with createBackgroundSaveFacade and an
- // owner-bound App job metadata provider. Legacy downloads use the other panel.
- delegate?: import('./delegate/long-running').BackgroundSaveFacade
- files?: {endpoint:string;token?:()=>string|undefined}
- displayName?: string
- executor?: import('./delegate/executor-setup').ExecutorSetup
- // DSM's signed-in account. isAdmin only hides or disables administrator
- // settings; the backend enforces access with permissions.json and RequireAdmin.
- user?: {readonly name: string; readonly isAdmin: boolean}
- // DSM Application Portal, present only when dsm-package.yaml declares portal.
- portal?: PortalAccess
- call<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>
- reopen(fn: () => void): () => void
- locale: string
- host: HostAdapter
-}
-export interface AppStatus {package: string; version: string; user: string; admin: boolean}

package/dist/templates/native-go-vue/frontend/src/delegate/ExecutorSettings.vue

@@ -1,70 +0,0 @@
-<script setup lang="ts">
-import {computed,onBeforeUnmount,onMounted,ref} from 'vue'
-import {Button,Callout,Form,FormActions,FormItem,Input,Select,SettingsSection} from '@synopackageland/ui'
-import type {Context} from '../context'
-import type {ScopeSelection} from './long-running'
-import {useExecutorSetup,type CapabilityStatus} from './executor-setup'
-import {delegateCopy} from './copy'
-const props=defineProps<{admin:boolean;locale?:string;ctx?:Pick<Context,'call'>}>()
-const emit=defineEmits<{confirmed:[]}>()
-const setup=useExecutorSetup(),copy=computed(()=>delegateCopy(props.locale))
-const status=ref<CapabilityStatus>(),password=ref(''),busy=ref(false),error=ref(false)
-const scope=ref<{scope_mode?:string;preselection?:string;selection?:ScopeSelection|null;mismatch?:boolean}>(),chosen=ref(''),shares=ref<Array<{label:string;value:string}>>([])
-const dynamic=computed(()=>scope.value?.scope_mode==='install-selected')
-const options=computed(()=>[{label:copy.value.homeScope,value:'home'},...shares.value])
-const canConfirm=computed(()=>!dynamic.value||!!chosen.value&&options.value.some(o=>o.value===chosen.value))
-const needsScope=computed(()=>dynamic.value&&!scope.value?.selection)
-const changed=computed(()=>chosen.value!==scope.value?.selection?.scope)
-let disposed=false
-async function load(approved?:CapabilityStatus){
- const next=approved??await setup.status()
- if(disposed)return
- status.value=next
- if(!props.ctx)return
- const detail=await props.ctx.call<NonNullable<typeof scope.value>>('delegate.status')
- if(disposed)return
- scope.value=detail
- if(detail.scope_mode!=='install-selected')return
- const all:Array<{label:string;value:string}>=[]
- let offset=0
- for(let count=0;count<128;count++){
-  const page=await props.ctx.call<{shares:Array<{name:string;path:string;isdir:boolean}>;total:number;offset:number}>('bg.browse',{offset})
-  if(disposed)return
-  if(!Array.isArray(page.shares)||!Number.isSafeInteger(page.total)||page.total<0||!page.shares.length&&offset<page.total)throw {code:'EXECUTOR_PROTOCOL'}
-  for(const entry of page.shares){if(entry.isdir&&entry.path==='/'+entry.name&&!['home','homes'].includes(entry.name.toLowerCase()))all.push({label:entry.name,value:'shared:'+entry.name})}
-  offset+=page.shares.length
-  if(offset>=page.total)break
-  if(count===127)throw {code:'EXECUTOR_PROTOCOL'}
- }
- shares.value=all
- chosen.value=detail.selection?.scope??detail.preselection??''
-}
-async function refresh(){if(!props.admin||busy.value)return;busy.value=true;error.value=false;try{await load()}catch{if(!disposed)error.value=true}finally{if(!disposed)busy.value=false}}
-async function authorize(){
- if(!props.admin||busy.value||!password.value||!canConfirm.value||error.value)return
- busy.value=true;error.value=false;const entered=password.value;password.value=''
- try{const next=dynamic.value?await setup.authorize(entered,chosen.value):await setup.authorize(entered);await load(next);if(!disposed)emit('confirmed')}
- catch{if(!disposed)error.value=true}
- finally{if(!disposed)busy.value=false}
-}
-onMounted(()=>{setup.subscribe?.(next=>{if(!disposed)status.value=next});void refresh()});onBeforeUnmount(()=>{disposed=true;password.value=''})
-</script>
-<template>
- <SettingsSection v-if="admin" :title="copy.setupTitle" :collapsible="false" :aria-busy="busy">
-  <p>{{ copy.setupHelp }}</p>
-  <Callout v-if="error" tone="danger" role="alert">{{ copy.setupError }}</Callout>
-  <p role="status">{{ status?.state==='ready'?(needsScope?copy.scopeNeeds:copy.ready):status?.state==='needs-admin-approval'?copy.needs:copy.blocked }}</p>
-  <p v-if="status?.reason&&(status.state==='blocked'||status.state==='unsupported')">{{ copy.details }}: {{ status.reason }}</p>
-  <p v-if="scope?.selection">{{ copy.protectedScope }}: {{ scope.selection.root }}</p>
-  <Callout v-if="scope?.mismatch" tone="warning">{{ copy.scopeMismatch }} {{ copy.preselection }}: {{ scope.preselection }} · {{ copy.protectedScope }}: {{ scope.selection?.root }}</Callout>
-  <Form v-if="status?.state==='needs-admin-approval'||status?.retry||dynamic&&status?.state==='ready'" @submit.prevent="authorize">
-   <template v-if="dynamic">
-    <p>{{ scope?.selection?copy.scopeChangeHelp:copy.preselectionHelp }}</p>
-    <FormItem :label="copy.scopeLabel" label-for="delegate-scope"><Select id="delegate-scope" v-model="chosen" :options="options" :disabled="busy||error" /></FormItem>
-   </template>
-   <FormItem :label="copy.password" label-for="delegate-password"><Input id="delegate-password" v-model="password" type="password" autocomplete="current-password" :disabled="busy||error" /></FormItem>
-   <FormActions><Button type="submit" variant="primary" :disabled="busy||error||!password||!canConfirm||dynamic&&!!scope?.selection&&!changed">{{ dynamic?(scope?.selection?copy.confirmScope:copy.confirmShare):copy.authorize }}</Button></FormActions>
-  </Form>
-  <Button variant="secondary" :disabled="busy" @click="refresh">{{ copy.refresh }}</Button>
- </SettingsSection>
-</template>

package/dist/templates/native-go-vue/frontend/src/delegate/catalogs.ts

@@ -1,11 +0,0 @@
-import en from './i18n/en.json'
-import zhTW from './i18n/zh-TW.json'
-import zhCN from './i18n/zh-CN.json'
-import ja from './i18n/ja.json'
-import ko from './i18n/ko.json'
-import de from './i18n/de.json'
-import fr from './i18n/fr.json'
-import es from './i18n/es.json'
-import it from './i18n/it.json'
-export type DelegateCopy=typeof en
-export const delegateCatalogs:Record<string,DelegateCopy>={en,'zh-TW':zhTW,'zh-CN':zhCN,ja,ko,de,fr,es,it}

package/dist/templates/native-go-vue/frontend/src/delegate/copy.test.ts

@@ -1,12 +0,0 @@
-import {expect,test} from 'vitest'
-import {delegateCopy} from './copy'
-import {saveCopy} from './save-copy'
-import zhCN from './i18n/zh-CN.json'
-import saveJa from './i18n/save/ja.json'
-test('delegate and save copy follow the DSM language across all nine catalogs',()=>{
- expect(delegateCopy('chs')).toMatchObject(zhCN)
- expect(delegateCopy('zh_CN')).toMatchObject(zhCN)
- expect(saveCopy('jpn')).toEqual(saveJa)
- expect(delegateCopy('unknown').refresh).toBe('Refresh')
- expect(saveCopy().refresh).toBe('Refresh')
-})

package/dist/templates/native-go-vue/frontend/src/delegate/copy.ts

@@ -1,4 +0,0 @@
-import {uiLocale} from '../nas/locale'
-import {delegateCatalogs,type DelegateCopy} from './catalogs'
-export function delegateCopy(locale='en'){return delegateCatalogs[uiLocale(locale)]!}
-export function errorCopy(error:unknown,copy:DelegateCopy){const code=(error as {code?:string})?.code;return ['session_required','AUTH_DENIED'].includes(code??'')?copy.session:['DENIED','SCOPE_DENIED','PERMISSION_DENIED','APP_DENIED','INELIGIBLE','denied'].includes(code??'')?copy.denied:copy.error}

package/dist/templates/native-go-vue/frontend/src/delegate/executor-settings.test.ts

@@ -1,23 +0,0 @@
-// @vitest-environment jsdom
-import {expect,test} from 'vitest'
-import {createApp,h,nextTick} from 'vue'
-import {AppRoot} from '@synopackageland/ui'
-import ExecutorSettings from './ExecutorSettings.vue'
-import {ExecutorSetupKey,type CapabilityStatus} from './executor-setup'
-const settle=async()=>{for(let i=0;i<10;i++){await nextTick();await new Promise(r=>setTimeout(r))}}
-// t-0237: a wrong password left only "Check status"; a retryable result keeps the form.
-test('a retryable blocked approval keeps the password form for another try',async()=>{
- const blocked:CapabilityStatus&{retry:boolean}={state:'blocked',reason:'dsm_3121: DSM rejected the administrator password. Nothing was created.',retry:true}
- const setup={async status():Promise<CapabilityStatus>{return {state:'needs-admin-approval'}},async authorize(){return blocked},async control(){return blocked}}
- const root=document.createElement('div');document.body.append(root)
- const app=createApp({render:()=>h(AppRoot,{},()=>h(ExecutorSettings,{admin:true,locale:'en'}))})
- app.provide(ExecutorSetupKey,setup)
- try{
-  app.mount(root);await settle()
-  const input=root.querySelector<HTMLInputElement>('#delegate-password')!
-  input.value='wrong';input.dispatchEvent(new Event('input'));await settle()
-  root.querySelector('form')!.dispatchEvent(new Event('submit'));await settle()
-  expect(root.textContent).toContain('dsm_3121')
-  expect(root.querySelector('#delegate-password')).not.toBeNull()
- }finally{app.unmount();root.remove()}
-})

package/dist/templates/native-go-vue/frontend/src/delegate/executor-setup.ts

@@ -1,24 +0,0 @@
-import {inject,type InjectionKey} from 'vue'
-export type CapabilityState='unsupported'|'needs-admin-approval'|'ready'|'blocked'|'incompatible'
-// requested: a scope change whose root task may still land; it applied once
-// status() reports that scope with a generation above this one.
-// retry: approving again may succeed: nothing of this approval is left behind, or
-// the approved tasks remain and approving again restarts the executor.
-export interface CapabilityStatus {state:CapabilityState;reason?:string;requested?:{scope:string;generation:number};retry?:boolean}
-// p2-setup supplies the implementation through app.provide(ExecutorSetupKey, setup).
-// Passwords belong only to this call and must never be persisted or logged.
-export interface ExecutorSetup {
- status():Promise<CapabilityStatus>
- authorize(password:string,selectedScope?:string):Promise<CapabilityStatus>
- control(action:'start'|'stop'|'purge'):Promise<CapabilityStatus>
- // Results of calls made elsewhere (the DSM window panel) on the same access.
- subscribe?(listener:(status:CapabilityStatus)=>void):void
-}
-export const ExecutorSetupKey:InjectionKey<ExecutorSetup>=Symbol('executor-setup')
-export function useExecutorSetup():ExecutorSetup {
- return inject(ExecutorSetupKey,{
-  async status(){return {state:'blocked',reason:'setup-unavailable'}},
-  async authorize(){throw {code:'setup-unavailable'}},
-  async control(){throw {code:'setup-unavailable'}},
- })
-}

package/dist/templates/native-go-vue/frontend/src/delegate/facade.test.ts

@@ -1,100 +0,0 @@
-import {expect,test,vi} from 'vitest'
-import {createBackgroundSaveFacade} from './facade'
-test('destination lookup returns protected selection and rejects a grant outside its root',async()=>{
- const selection={scope:'shared:reports',root:'/reports',generation:2}
- const destination={id:'mine',key:'save',path:'/reports/exports',username:'alice',lifetime:'until-revoked'}
- const call=vi.fn(async()=>({key:'save',selection,destination,status:'active'}))
- const sdk=createBackgroundSaveFacade({call:call as any})
- expect(await sdk.destination('save')).toEqual({key:'save',selection,destination,status:'active'})
- expect(call).toHaveBeenCalledExactlyOnceWith('delegate.destination',{key:'save'})
- call.mockResolvedValue({key:'save',selection,destination:{...destination,path:'/other'},status:'active'})
- await expect(sdk.destination('save')).rejects.toMatchObject({code:'EXECUTOR_PROTOCOL'})
-})
-const ref={delegation_id:'mine',job_id:'original'}
-test('operation cancellation keeps its bounded readable cause through the facade',async()=>{
- const call=vi.fn(async()=>({job_id:'original',state:'canceled',code:'OPERATION_CANCELED',reason:'grant-revoked'}))
- const sdk=createBackgroundSaveFacade({call:call as any})
- expect(await sdk.cancel(ref)).toMatchObject({state:'canceled',reason:'grant-revoked'})
- for(const reason of [123, 'x'.repeat(129), 'raw DSM response /path']){
-  call.mockResolvedValue({...await call(),reason} as any)
-  await expect(sdk.cancel(ref)).rejects.toMatchObject({code:'EXECUTOR_PROTOCOL'})
- }
-})
-test('a copy cancel acknowledgement passes through unchanged for same-ref polling',async()=>{
- const ack={job_id:'original',state:'copying',code:'CANCEL_REQUESTED',reason:'operation-canceled-by-user'}
- const call=vi.fn(async()=>ack)
- expect(await createBackgroundSaveFacade({call:call as any}).cancel(ref)).toEqual(ack)
- expect(call).toHaveBeenCalledWith('delegate.operations.cancel',ref)
-})
-const grant={delegation_id:'mine',destination:'save',path:'/home/Exports',subject:{username:'normal1',uid:1205},lifetime:'until-revoked',revoked:false}
-function fixture(){
- const call=vi.fn(async(method:string)=>{
-  if(method==='delegate.status')return {state:'ready',disabled:false}
-  if(method==='delegate.list')return {delegations:[grant,{...grant,delegation_id:'revoked',revoked:true},{...grant,delegation_id:'legacy',lifetime:''}]}
-  if(method==='delegate.operations.get')return {job_id:'original',state:'committed',receipt:{path:'/home/Exports/report.csv',size:4}}
-  if(method==='delegate.operations.cancel')return {job_id:'original',state:'canceled'}
-  if(method==='delegate.revoke')return {revoked:true}
-  if(method==='delegate.disable')return {disabled:true}
-  if(method==='delegate.enable')return {disabled:false}
-  if(method==='delegate.select_destination')return {id:'mine',key:'save',path:'/home/Exports',username:'normal1',lifetime:'until-revoked'}
-  throw {code:'unknown_method'}
- })
- const jobs=vi.fn(async()=>[{...ref,name:'report.csv'}])
- return {call,jobs,sdk:createBackgroundSaveFacade({call:call as any},jobs)}
-}
-test('W2 list is mapped to active permanent destinations without changing owner or legacy semantics',async()=>{
- const {sdk,call}=fixture()
- expect(await sdk.list()).toEqual([{id:'mine',key:'save',path:'/home/Exports',username:'normal1',lifetime:'until-revoked'}])
- expect(call).toHaveBeenCalledExactlyOnceWith('delegate.list')
- await sdk.selectDestination({key:'save',path:'/home/Exports'})
- expect(call).toHaveBeenLastCalledWith('delegate.select_destination',{key:'save',path:'/home/Exports'})
-})
-test('App metadata is joined with protected status by the original two IDs, never a synthetic list route',async()=>{
- const {sdk,call,jobs}=fixture()
- expect(await sdk.operations()).toEqual([{...ref,name:'report.csv',state:'committed',receipt:{path:'/home/Exports/report.csv',size:4}}])
- expect(jobs).toHaveBeenCalledOnce()
- expect(call).toHaveBeenCalledExactlyOnceWith('delegate.operations.get',ref)
- await sdk.cancel(ref);expect(call).toHaveBeenLastCalledWith('delegate.operations.cancel',ref)
- await sdk.revoke({delegation_id:'mine'});expect(call).toHaveBeenLastCalledWith('delegate.revoke',{delegation_id:'mine'})
-})
-test('missing protected disabled status cannot be reported as enabled',async()=>{
- const {sdk,call}=fixture();call.mockResolvedValue({state:'ready'} as any)
- await expect(sdk.status()).rejects.toMatchObject({code:'EXECUTOR_PROTOCOL'})
-})
-test('malformed grant and App metadata references cannot be coerced into valid IDs',async()=>{
- const {sdk,call}=fixture()
- call.mockResolvedValue({delegations:[{...grant,delegation_id:undefined}]} as any)
- await expect(sdk.list()).rejects.toMatchObject({code:'EXECUTOR_PROTOCOL'})
- const invalid=createBackgroundSaveFacade({call:call as any},async()=>[{job_id:undefined,delegation_id:'mine',name:'report.csv'}] as any)
- await expect(invalid.operations()).rejects.toMatchObject({code:'EXECUTOR_PROTOCOL'})
- expect(call).toHaveBeenCalledTimes(1)
-})
-test('malformed or mismatched operation evidence never becomes Saved',async()=>{
- for(const value of [{job_id:'other',state:'committed',receipt:{path:'/home/a',size:1}},{job_id:'original',state:'committed'},{job_id:'original',state:'copying',receipt:{path:'/home/a',size:1}},{job_id:'original',state:'committed',receipt:{path:'/home/a',size:-1}}]){
-  const {sdk,call}=fixture();call.mockResolvedValue(value as any)
-  await expect(sdk.operations()).rejects.toMatchObject({code:'EXECUTOR_PROTOCOL'})
- }
-})
-test('read timeout never admits or resubmits an operation',async()=>{
- const {sdk,call}=fixture();call.mockRejectedValue({code:'EXECUTOR_TIMEOUT'})
- await expect(sdk.operations()).rejects.toMatchObject({code:'EXECUTOR_TIMEOUT'})
- expect(call).toHaveBeenCalledExactlyOnceWith('delegate.operations.get',ref)
-})
-test('disable and enable use authenticated protected routes, not mailbox controls',async()=>{
- const {sdk,call}=fixture()
- expect(await sdk.status()).toEqual({disabled:false})
- expect(await sdk.disable()).toEqual({disabled:true});expect(call).toHaveBeenLastCalledWith('delegate.disable')
- expect(await sdk.enable()).toEqual({disabled:false});expect(call).toHaveBeenLastCalledWith('delegate.enable')
- call.mockResolvedValue({} as any);await expect(sdk.disable()).rejects.toMatchObject({code:'EXECUTOR_PROTOCOL'})
-})
-test('the default facade lists backend mirrors but ignores their committed claim until live receipt',async()=>{
- const {call}=fixture()
- call.mockImplementation(async(method:string)=>{
-  if(method==='delegate.operations.list')return {operations:[{...ref,name:'report.csv',state:'committed'}]} as any
-  if(method==='delegate.operations.get')return {job_id:'original',state:'uncertain'} as any
-  throw {code:'unexpected'}
- })
- const sdk=createBackgroundSaveFacade({call:call as any})
- expect(await sdk.operations()).toEqual([{...ref,name:'report.csv',state:'uncertain'}])
- expect(call.mock.calls).toEqual([['delegate.operations.list'],['delegate.operations.get',ref]])
-})

package/dist/templates/native-go-vue/frontend/src/delegate/facade.ts

@@ -1,85 +0,0 @@
-import type {Context} from '../context'
-import type {BackgroundSaveFacade,DestinationGrant,DestinationState,ScopeSelection,OperationRef,OperationResult,SaveOperation} from './long-running'
-// Supply an owner-bound App backend view, not browser storage or an executor list.
-// Producers persist these references alongside their own business job metadata.
-export interface AppSaveJob extends OperationRef {name:string;refusal?:string}
-const token=/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/
-const id=(value:unknown):value is string=>typeof value==='string'&&token.test(value)
-const validRef=(ref:OperationRef)=>ref&&id(ref.delegation_id)&&id(ref.job_id)
-const path=(value:unknown):value is string=>typeof value==='string'&&value.startsWith('/')&&value!=='/'&&!value.includes('\0')&&!value.slice(1).split('/').some(part=>!part||part==='.'||part==='..')
-function protocol():never{throw {code:'EXECUTOR_PROTOCOL'}}
-function validSelection(value:ScopeSelection){return value&&Number.isSafeInteger(value.generation)&&value.generation>=0&&path(value.root)&&(value.scope==='home'?value.root==='/home':value.scope.startsWith('shared:')&&value.root==='/'+value.scope.slice(7))}
-function result(value:OperationResult,ref:OperationRef):OperationResult{
- if(!value||value.job_id!==ref.job_id||!['queued','copying','committed','canceled','interrupted','uncertain'].includes(value.state))protocol()
- if(value.state==='committed'){
-  if(!value.receipt||!path(value.receipt.path)||!Number.isSafeInteger(value.receipt.size)||value.receipt.size<0||value.receipt.size>16*1024**3)protocol()
- }else if(value.receipt!==undefined)protocol()
- if(value.reason!==undefined&&(typeof value.reason!=='string'||!/^[A-Za-z][A-Za-z0-9_-]{0,127}$/.test(value.reason)))protocol()
- return {job_id:value.job_id,state:value.state,...(value.receipt?{receipt:{...value.receipt}}:{}),...(value.code?{code:value.code}:{}),...(value.reason?{reason:value.reason}:{})}
-}
-/** Bind the portable UI facade to W2's existing authenticated routes. */
-export function createBackgroundSaveFacade(ctx:Pick<Context,'call'>,jobs:()=>Promise<readonly AppSaveJob[]>=async()=>{
- const out=await ctx.call<{operations:AppSaveJob[]}>('delegate.operations.list')
- if(!Array.isArray(out?.operations))protocol()
- return out.operations
-}):BackgroundSaveFacade{
- const operation=async(method:string,ref:OperationRef)=>{
-  if(!validRef(ref))protocol()
-  return result(await ctx.call<OperationResult>(method,{delegation_id:ref.delegation_id,job_id:ref.job_id}),ref)
- }
- return {
-  async destination(key){
-   if(!id(key))protocol()
-   const out=await ctx.call<DestinationState>('delegate.destination',{key})
-   if(!out||out.key!==key||!['active','missing','reselection-required','needs-scope-confirmation','disabled'].includes(out.status)||out.selection!==null&&!validSelection(out.selection))protocol()
-   if(out.status==='active'){
-    const g=out.destination,s=out.selection
-    if(!g||!s||!id(g.id)||g.key!==key||g.lifetime!=='until-revoked'||!g.username||!path(g.path)||!(g.path===s.root||g.path.startsWith(s.root+'/')))protocol()
-   }else if(out.destination!==null)protocol()
-   return out
-  },
-  async exportExample(input){
-   if(!id(input.key)||!id(input.job_id))protocol()
-   const out=await ctx.call<OperationRef>('delegate.example.export',{key:input.key,job_id:input.job_id})
-   if(!validRef(out)||out.job_id!==input.job_id)protocol()
-   return out
-  },
-  selectDestination:input=>ctx.call<DestinationGrant>('delegate.select_destination',{key:input.key,path:input.path}),
-  async status(){
-   const value=await ctx.call<{state:string;disabled?:boolean;scope_mode?:string;preselection?:string;selection?:ScopeSelection|null;mismatch?:boolean}>('delegate.status')
-   // Capability readiness and the protected admission switch are independent.
-   if(!['ready','disabled','needs-scope-confirmation'].includes(value?.state))throw {code:'EXECUTOR_UNAVAILABLE'}
-   if(typeof value?.disabled!=='boolean')protocol()
-   if(value.selection&&!validSelection(value.selection))protocol()
-   return {disabled:value.disabled,...(value.scope_mode?{scopeMode:value.scope_mode,selection:value.selection??null,preselection:value.preselection,mismatch:value.mismatch}:{} )}
-  },
-  async list(){
-   const value=await ctx.call<{delegations:Array<{delegation_id:string;destination:string;path:string;subject:{username:string};lifetime:string;revoked:boolean}>}>('delegate.list')
-   if(!Array.isArray(value?.delegations))protocol()
-   return value.delegations.filter(g=>g.lifetime==='until-revoked'&&!g.revoked).map(g=>{
-    if(!id(g.delegation_id)||typeof g.destination!=='string'||!g.destination||!path(g.path)||typeof g.subject?.username!=='string'||!g.subject.username)protocol()
-    return {id:g.delegation_id,key:g.destination,path:g.path,username:g.subject.username,lifetime:'until-revoked' as const}
-   })
-  },
-  async operations(){
-   const metadata=await jobs()
-   return Promise.all(metadata.map(async job=>{
-    if(typeof job?.name!=='string'||!job.name||!validRef(job))protocol()
-    const ref={delegation_id:job.delegation_id,job_id:job.job_id}
-    try{return {...ref,name:job.name,...await operation('delegate.operations.get',ref)} satisfies SaveOperation}
-    catch(e){
-     if(job.refusal&&(e as {code?:string})?.code==='operation-not-found')return {...ref,name:job.name,state:'interrupted',code:job.refusal} satisfies SaveOperation
-     throw e
-    }
-   }))
-  },
-  async revoke(input){
-   const out=await ctx.call<{revoked:boolean}>('delegate.revoke',{delegation_id:input.delegation_id})
-   if(out?.revoked!==true)protocol()
-   return {revoked:true}
-  },
-  cancel:ref=>operation('delegate.operations.cancel',ref),
-  async disable(){const out=await ctx.call<{disabled:boolean}>('delegate.disable');if(out?.disabled!==true)protocol();return {disabled:true}},
-  async enable(){const out=await ctx.call<{disabled:boolean}>('delegate.enable');if(out?.disabled!==false)protocol();return {disabled:false}},
- }
-}

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

@@ -1,47 +0,0 @@
-{
-  "title": "Dateizugriff im Hintergrund",
-  "help": "Downloads laufen weiter, nachdem Sie diese App schließen. Jeder Auftrag darf bis zu einer Stunde lang nur in den ausgewählten Ordner schreiben. Vorhandene Dateien werden nie ersetzt.",
-  "setupTitle": "Administratoreinrichtung",
-  "setupHelp": "Genehmigen Sie diese App einmal, damit sie Dateiaufträge abschließen kann, während Benutzer offline sind.",
-  "password": "DSM-Passwort",
-  "authorize": "Dateizugriff im Hintergrund genehmigen",
-  "confirmShare": "Freigegebenen Ordner bestätigen",
-  "scopeNeeds": "Der freigegebene Ordner muss bestätigt werden. Wählen Sie unten einen freigegebenen Ordner und bestätigen Sie ihn mit Ihrem DSM-Passwort.",
-  "ready": "Der Dateizugriff im Hintergrund ist bereit.",
-  "needs": "Ein Administrator muss den Dateizugriff im Hintergrund genehmigen.",
-  "blocked": "Der Dateizugriff im Hintergrund ist nicht verfügbar. Bitten Sie einen Administrator, die App-Einrichtung zu prüfen.",
-  "details": "Details",
-  "refresh": "Aktualisieren",
-  "revoke": "Widerrufen",
-  "cancel": "Auftrag abbrechen",
-  "noDelegations": "Sie haben keine aktiven Delegierungen.",
-  "delegations": "Meine Delegierungen",
-  "expires": "Ablauf",
-  "downloads": "Meine Downloads",
-  "noJobs": "Sie haben keine Download-Aufträge.",
-  "url": "Download-URL",
-  "name": "Dateiname",
-  "choose": "Ordner auswählen",
-  "submit": "In meinen Ordner herunterladen",
-  "destination": "Ziel",
-  "pending": "Auftrag abgebrochen. Der Widerruf steht noch aus; die App versucht es erneut.",
-  "error": "Die Aktion konnte nicht abgeschlossen werden. Aktualisieren Sie die Ansicht und versuchen Sie es erneut. Wenn der Fehler bestehen bleibt, wenden Sie sich an Ihren Administrator.",
-  "setupError": "Die Genehmigung konnte nicht abgeschlossen werden. Geben Sie Ihr DSM-Passwort erneut ein und versuchen Sie es noch einmal, oder prüfen Sie die App-Einrichtung.",
-  "denied": "Der Zugriff wurde verweigert. Prüfen Sie Ihre Ordnerberechtigungen und versuchen Sie es erneut.",
-  "session": "Melden Sie sich erneut bei DSM an und aktualisieren Sie dann die Ansicht.",
-  "size": "Downloads sind auf 64 MB und 60 Sekunden begrenzt.",
-  "queued": "In Warteschlange",
-  "running": "Wird heruntergeladen",
-  "succeeded": "Gespeichert",
-  "failed": "Fehlgeschlagen",
-  "canceled": "Abgebrochen",
-  "interrupted": "Unterbrochen",
-  "homeScope": "Home-Ordner jedes Benutzers",
-  "scopeLabel": "Bereich für Speichern im Hintergrund",
-  "protectedScope": "Bestätigter Bereich",
-  "preselection": "Vorauswahl bei der Installation",
-  "preselectionHelp": "Die Vorauswahl bei der Installation ist nur ein Vorschlag. Bestätigen Sie diesen Bereich mit Ihrem DSM-Passwort, wenn Sie den Hintergrundzugriff aktivieren.",
-  "scopeMismatch": "Die Vorauswahl bei der Installation weicht vom bestätigten Bereich ab. Speichervorgänge im Hintergrund folgen dem bestätigten Bereich.",
-  "scopeChangeHelp": "Eine Änderung des Bereichs widerruft vorhandene Ziele und bricht ausstehende Speichervorgänge ab. Benutzer müssen ihre Ziele neu auswählen. Bereits gespeicherte Dateien bleiben erhalten.",
-  "confirmScope": "Bereichsänderung bestätigen"
-}

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

@@ -1,47 +0,0 @@
-{
-  "title": "Background file access",
-  "help": "Downloads continue after you close this app. Each job can write only to the folder you select, for up to one hour. Existing files are never replaced.",
-  "setupTitle": "Administrator setup",
-  "setupHelp": "Approve this app once to let it complete file jobs while users are offline.",
-  "password": "DSM password",
-  "authorize": "Approve background file access",
-  "confirmShare": "Confirm share",
-  "scopeNeeds": "Share needs confirmation. Choose a share below and confirm it with your DSM password.",
-  "ready": "Background file access is ready.",
-  "needs": "An administrator must approve background file access.",
-  "blocked": "Background file access is unavailable. Ask an administrator to check the app setup.",
-  "details": "Details",
-  "refresh": "Refresh",
-  "revoke": "Revoke",
-  "cancel": "Cancel job",
-  "noDelegations": "You have no active delegations.",
-  "delegations": "My delegations",
-  "expires": "Expires",
-  "downloads": "My downloads",
-  "noJobs": "You have no download jobs.",
-  "url": "Download URL",
-  "name": "File name",
-  "choose": "Choose folder",
-  "submit": "Download to my folder",
-  "destination": "Destination",
-  "pending": "Job canceled. Revocation is pending; the app will retry.",
-  "error": "The action could not be completed. Refresh and try again. If it keeps failing, contact your administrator.",
-  "setupError": "Approval could not be completed. Re-enter your DSM password and try again, or check the app setup.",
-  "denied": "Access was refused. Check your folder permissions and try again.",
-  "session": "Sign in to DSM again, then refresh.",
-  "size": "Downloads are limited to 64 MB and 60 seconds.",
-  "queued": "Queued",
-  "running": "Downloading",
-  "succeeded": "Saved",
-  "failed": "Failed",
-  "canceled": "Canceled",
-  "interrupted": "Interrupted",
-  "homeScope": "Each user’s home folder",
-  "scopeLabel": "Background save scope",
-  "protectedScope": "Confirmed scope",
-  "preselection": "Installer pre-selection",
-  "preselectionHelp": "The installer pre-selection is a suggestion. Confirm this scope with your DSM password when enabling background access.",
-  "scopeMismatch": "The installer pre-selection differs from the confirmed scope. Background saves follow the confirmed scope.",
-  "scopeChangeHelp": "Changing the scope revokes existing destinations and cancels pending saves. Users must choose destinations again. Saved files remain.",
-  "confirmScope": "Confirm scope change"
-}