@synopackageland/cli 0.4.0 → 0.5.0

package/dist/templates/native-go-vue/frontend/test/apps.test.ts

@@ -2,6 +2,7 @@
 import {expect, test, vi} from 'vitest'
 import {nextTick} from 'vue'
 import {mount} from '../src/main'
+import {nasCopy} from '../src/nas/i18n'
 import type {Context, IntegrationState} from '../src/context'
 
 function fixture(id: string, admin: boolean, state: IntegrationState = 'ready') {
@@ -21,14 +22,35 @@ function fixture(id: string, admin: boolean, state: IntegrationState = 'ready')
 async function settle(){for(let i=0;i<12;i++){await Promise.resolve();await nextTick()}await new Promise(resolve=>setTimeout(resolve,25))}
 function click(root:HTMLElement,text:string){const node=[...root.querySelectorAll('button')].find(node=>node.textContent?.trim()===text);expect(node, text).toBeTruthy();node!.click()}
 
-test('six states and ordinary-user errors give actionable status without approval controls',async()=>{
- for(const state of ['not-enabled','ready','needs-approval','incompatible','stopped','failed'] as IntegrationState[]){
+test('seven states and ordinary-user errors give actionable status without approval controls',async()=>{
+ for(const state of ['not-enabled','ready','needs-approval','incompatible','stopped','failed','pending'] as IntegrationState[]){
   const f=fixture('Ordinary',false,state);await settle()
   expect(f.root.querySelector('[data-integration-state]')?.getAttribute('data-integration-state')).toBe(state)
   expect(f.root.textContent).not.toContain('Approve and activate')
   f.app.unmount();f.root.remove()
  }
 })
+test('package-only integration shows its own status and no helper controls, then the personal sample',async()=>{
+ const call=vi.fn(async(method:string)=>{
+  if(method==='app.status') return {package:'PackageOnly',version:'0.1.0-0001',user:'admin',admin:true}
+  if(method==='integration.status') return {state:'ready',reason:'package-only',packageRunning:'running',scheduler:'not-required'}
+  if(method==='personal.list') return {items:[{id:'PackageOnly-private',name:'My sample note'}]}
+  if(method==='personal.read') return {id:'PackageOnly-private',text:'Private PackageOnly'}
+  throw {code:'unknown_method'}
+ })
+ const root=document.createElement('div');document.body.append(root)
+ const app=mount(root,{call,reopen:()=>()=>{},locale:'en'} as unknown as Context)
+ await settle()
+ const status=root.querySelector('[data-integration-state]')
+ expect(status?.getAttribute('data-integration-state')).toBe('ready')
+ expect(status?.textContent).toContain('No privileged helper is installed')
+ expect(status?.textContent).not.toContain('helper passed')
+ expect(status?.textContent).not.toContain('Scheduler')
+ expect(root.textContent).not.toContain('Approve and activate')
+ expect(root.textContent).not.toContain('Repair cleanup')
+ expect(root.textContent).toContain('My sample data')
+ app.unmount();root.remove()
+})
 test('approval cancellation never runs the root task and all fixed controls recheck status',async()=>{
  const f=fixture('Admin',true,'needs-approval');await settle()
  f.ctx.root!.authorize=vi.fn(async()=> 'cancelled')
@@ -146,3 +168,44 @@ test('unmount releases its sizing class and preserves an existing host class',as
  expect(f.root.classList.contains('dsmapp-vue-root')).toBe(true)
  f.root.remove()
 })
+
+test('repair is administrator-only and cancellation or refusal never starts recovery',async()=>{
+ const user=fixture('UserRepair',false,'failed'),admin=fixture('AdminRepair',true,'failed')
+ try {
+  await settle()
+  expect(user.root.textContent).not.toContain('Repair cleanup')
+  admin.ctx.root!.authorize=vi.fn(async()=> 'cancelled')
+  click(admin.root,'Repair cleanup');await settle()
+  expect(admin.ctx.root!.authorize).toHaveBeenCalledWith('helper_repair')
+  expect(admin.ctx.root!.run).not.toHaveBeenCalled()
+  admin.ctx.root!.authorize=vi.fn(async()=> 'ready')
+  admin.ctx.root!.run=vi.fn(async()=>{throw {code:'root_task_failed'}})
+  click(admin.root,'Repair cleanup');await settle()
+  expect(admin.ctx.root!.run).toHaveBeenCalledWith('helper_repair')
+  expect(admin.ctx.root!.run).not.toHaveBeenCalledWith('helper_recover')
+  expect(admin.root.textContent).toContain('Repair could not verify safe cleanup')
+  expect(admin.call.mock.calls.filter(args=>args[0]==='integration.status').length).toBeGreaterThan(1)
+  admin.ctx.root!.run=vi.fn(async()=>{throw {code:'root_cancelled'}})
+  click(admin.root,'Repair cleanup');await settle()
+  expect(admin.root.textContent).toContain('Repair confirmation cancelled. No operation was run.')
+  admin.ctx.root!.run=vi.fn(async()=>{})
+  click(admin.root,'Repair cleanup');await settle()
+  expect(admin.root.textContent).toContain('Cleanup repaired. Use Recover or Approve and activate')
+  expect(admin.ctx.root!.run).not.toHaveBeenCalledWith('helper_recover')
+ } finally {user.app.unmount();admin.app.unmount();user.root.remove();admin.root.remove()}
+})
+
+ test('pending health shows localized waiting copy without exposing sample authority',async()=>{
+ const locales=['en','zh-TW','zh-CN','ja','ko','de','fr','es','it']
+ for(const locale of locales){
+  const f=fixture('Pending',false,'pending');f.ctx.locale=locale
+  f.reopen.forEach(fn=>fn());await settle()
+  expect(f.root.querySelector('[data-integration-state="pending"]')).toBeTruthy()
+  expect(f.root.textContent).not.toContain('Administrator action needed')
+  expect(f.root.textContent).not.toContain('My sample data')
+  expect(f.call.mock.calls.some(args=>args[0]==='personal.list')).toBe(false)
+  expect(f.root.querySelector('.integration-status h2')?.textContent?.trim()).toBe(nasCopy(locale).healthPending)
+  expect(f.root.textContent).toContain(nasCopy(locale).healthPendingHelp)
+  f.app.unmount();f.root.remove()
+ }
+})

package/dist/templates/native-go-vue/frontend/test/jobs-connected.test.ts

@@ -0,0 +1,163 @@
+// @vitest-environment jsdom
+import {afterEach,expect,test,vi} from 'vitest'
+import {createConnectedJobsProvider,ATTACH_RENEW_MS,ATTACH_TTL_MS} from '../src/jobs/connected-provider'
+const id=(c:string)=>c.repeat(64)
+const signal=()=>new AbortController().signal
+const rawPage=()=>({revision:1,items:[{jobId:id('a'),revision:1,mode:'interactive',state:'running',progress:{completedUnits:0,totalUnits:1},drained:false,effectsUnknown:false}]})
+afterEach(()=>vi.useRealTimers())
+test('connected provider renews root-issued lease, never resubmits, and cancels best effort on pagehide',async()=>{
+ vi.useFakeTimers()
+ const call=vi.fn(async(method:string)=>{
+  if(method==='jobs.prepare')return {intentId:id('b'),jobId:id('a'),summaryDigest:id('c'),expiresAt:Date.now()+30000}
+  if(method==='jobs.submit')return {jobId:id('a'),attachId:id('d'),renewAfterMs:2000,ttlMs:6000,revision:1}
+  if(method==='jobs.status')return rawPage()
+  return {}
+ })
+ const p=createConnectedJobsProvider({call:call as any})
+ const prepared=await p.prepareInteractive(signal(),{id:'scan',revision:1},{id:id('e'),revision:1},{steps:[{action:'nas.files.stat',segments:['fixture']}]})
+ await p.submitInteractive(prepared,signal())
+ expect(p.mode).toBe('connected');expect(p.readiness.background).toBe('unavailable')
+ await vi.advanceTimersByTimeAsync(2000)
+ expect(call.mock.calls.filter(([m])=>m==='jobs.attach')).toHaveLength(1)
+ window.dispatchEvent(new Event('pagehide'));await Promise.resolve()
+ expect(call.mock.calls.some(([m])=>m==='jobs.cancel')).toBe(true)
+ await vi.advanceTimersByTimeAsync(12000)
+ expect(call.mock.calls.filter(([m])=>m==='jobs.attach')).toHaveLength(1)
+ expect(call.mock.calls.filter(([m])=>m==='jobs.submit')).toHaveLength(1)
+ expect(ATTACH_RENEW_MS).toBe(2000);expect(ATTACH_TTL_MS).toBe(6000)
+ p.disconnect()
+})
+test('a throttled or failed renewal does not extend the client deadline or retry submit',async()=>{
+ vi.useFakeTimers()
+ const call=vi.fn(async(method:string)=>{
+  if(method==='jobs.submit')return {jobId:id('a'),attachId:id('d'),renewAfterMs:2000,ttlMs:6000,revision:1}
+  if(method==='jobs.attach')throw {code:'expired'}
+  return rawPage()
+ })
+ const p=createConnectedJobsProvider({call:call as any})
+ await p.submitInteractive({intentId:id('b'),jobId:id('a'),summaryDigest:id('c'),expiresAt:Date.now()+30000},signal())
+ await vi.advanceTimersByTimeAsync(10000)
+ expect(call.mock.calls.filter(([m])=>m==='jobs.attach')).toHaveLength(1)
+ expect(call.mock.calls.filter(([m])=>m==='jobs.submit')).toHaveLength(1)
+ p.disconnect()
+})
+test('late submit callback after unmount never installs a renewal timer',async()=>{
+ vi.useFakeTimers()
+ let done!:(x:unknown)=>void
+ const call=vi.fn(()=>new Promise(r=>done=r))
+ const p=createConnectedJobsProvider({call:call as any})
+ const pending=p.submitInteractive({intentId:id('b'),jobId:id('a'),summaryDigest:id('c'),expiresAt:Date.now()+30000},signal())
+ p.disconnect()
+ done({jobId:id('a'),attachId:id('d'),renewAfterMs:2000,ttlMs:6000,revision:1})
+ await expect(pending).rejects.toMatchObject({code:'canceled'})
+ await vi.advanceTimersByTimeAsync(10000)
+ expect(call.mock.calls).toHaveLength(1)
+})
+test('background controls stay unavailable; projection strips private unexpected fields',async()=>{
+ const call=vi.fn(async()=>({...rawPage(),token:'secret'}))
+ const p=createConnectedJobsProvider({call:call as any})
+ await expect(p.prepare(signal())).rejects.toMatchObject({code:'unavailable'})
+ const page=await p.list(signal());expect(JSON.stringify(page)).not.toContain('secret')
+ p.disconnect()
+})
+
+test('interactive readiness requires the live session mode response',async()=>{
+ let available=false
+ const p=createConnectedJobsProvider({call:vi.fn(async()=>({revision:1,items:[],...(available?{availability:'session-required'}:{})})) as never})
+ expect(p.readiness.interactive).toBe('unavailable')
+ await p.list(signal());expect(p.readiness.interactive).toBe('unavailable')
+ available=true
+ await p.list(signal());expect(p.readiness.interactive).toBe('ready')
+ expect(p.readiness.background).toBe('unavailable')
+ p.disconnect();expect(p.readiness.interactive).toBe('unavailable')
+})
+
+ test('revalidating sticks through unrelated failures until a valid ready status, and keeps safe reason',async()=>{
+ let mode='revalidating'
+ const p=createConnectedJobsProvider({call:(async()=>{
+  if(mode!=='ready')throw {code:mode}
+  return {...rawPage(),availability:'session-required',items:[{...rawPage().items[0],state:'canceled',safeReason:'fenced',secret:'CANARY'}]}
+ }) as any})
+ await expect(p.list(signal())).rejects.toMatchObject({code:'revalidating'})
+ expect(p.readiness.interactive).toBe('revalidating')
+ mode='timeout';await expect(p.list(signal())).rejects.toMatchObject({code:'timeout'})
+ expect(p.readiness.interactive).toBe('revalidating')
+ mode='ready';const page=await p.list(signal())
+ expect(p.readiness.interactive).toBe('ready');expect(page.items[0].safeReason).toBe('fenced')
+ expect(JSON.stringify(page)).not.toContain('CANARY');p.disconnect()
+ })
+ test('explicit resubmission uses a snapshot and fresh intent/id, never retries a lost submit reply',async()=>{
+ let number=0,lost=false
+ const calls:any[]=[]
+ const call=vi.fn(async(method:string,args:any)=>{
+  calls.push([method,args])
+  if(method==='jobs.prepare'){number++;return {intentId:id(String(number)),jobId:id(String(number+2)),summaryDigest:id('c'),expiresAt:Date.now()+30000}}
+  if(method==='jobs.submit'){if(lost)throw {code:'timeout'};return {jobId:id(String(number+2)),attachId:id('d'),renewAfterMs:2000,ttlMs:6000,revision:1}}
+  if(method==='jobs.status')return {revision:2,availability:'session-required',items:[{...rawPage().items[0],jobId:id('3'),state:'canceled',safeReason:'fenced'}]}
+  return {}
+ })
+ const p=createConnectedJobsProvider({call:call as any})
+ const input={steps:[{action:'nas.files.stat',segments:['fixture']}]}
+ const prepared=await p.prepareInteractive(signal(),{id:'scan',revision:1},{id:id('e'),revision:1},input)
+ await p.submitInteractive(prepared,signal());input.steps[0].segments[0]='changed'
+ await p.list(signal());expect(p.canResubmit?.(id('3'))).toBe(true)
+ expect(calls.filter(([m])=>m==='jobs.submit')).toHaveLength(1)
+ lost=true;await expect(p.resubmit?.(id('3'),signal())).rejects.toMatchObject({code:'timeout'})
+ expect(calls.filter(([m])=>m==='jobs.prepare')[1][1].input.steps[0].segments).toEqual(['fixture'])
+ expect(calls.filter(([m])=>m==='jobs.submit')[1][1].intentId).toBe(id('2'))
+ expect(p.canResubmit?.(id('3'))).toBe(false)
+ await expect(p.resubmit?.(id('3'),signal())).rejects.toMatchObject({code:'unavailable'})
+ expect(calls.filter(([m])=>m==='jobs.submit')).toHaveLength(2)
+ p.disconnect()
+ })
+
+test('successful resubmit makes a distinct job and is unavailable for other reasons or after disconnect',async()=>{
+ let number=0,reason='fenced'
+ const call=vi.fn(async(method:string)=>{
+  if(method==='jobs.prepare'){number++;return {intentId:id(String(number)),jobId:id(String(number+2)),summaryDigest:id('c'),expiresAt:Date.now()+30000}}
+  if(method==='jobs.submit')return {jobId:id(String(number+2)),attachId:id('d'),renewAfterMs:2000,ttlMs:6000,revision:1}
+  if(method==='jobs.status')return {revision:2,availability:'session-required',items:[{...rawPage().items[0],jobId:id('3'),state:'canceled',safeReason:reason}]}
+  return {}
+ })
+ const p=createConnectedJobsProvider({call:call as any})
+ const prepared=await p.prepareInteractive(signal(),{id:'scan',revision:1},{id:id('e'),revision:1},{steps:[{action:'nas.files.stat',segments:['fixture']}]})
+ await p.submitInteractive(prepared,signal())
+ reason='expired';await p.list(signal());expect(p.canResubmit?.(id('3'))).toBe(false)
+ reason='fenced';await p.list(signal())
+ const result=await p.resubmit!(id('3'),signal());expect(result.jobId).toBe(id('4'))
+ expect(result.jobId).not.toBe(prepared.jobId);expect(p.canResubmit?.(id('3'))).toBe(false)
+ expect(p.resubmissionState?.(id('3'))).toBe('submitted')
+ expect(call.mock.calls.filter(([m])=>m==='jobs.submit')).toHaveLength(2)
+ p.disconnect();expect(p.canResubmit?.(id('3'))).toBe(false)
+})
+
+test('lost resubmit reply uses only lookup of the fresh intent, even when lookup itself is refused',async()=>{
+ let number=0,lookupRefused=true
+ const call=vi.fn(async(method:string,args:any)=>{
+  if(method==='jobs.prepare'){number++;return {intentId:id(String(number)),jobId:id(String(number+2)),summaryDigest:id('c'),expiresAt:Date.now()+30000}}
+  if(method==='jobs.submit'){if(number===2)throw {code:'timeout'};return {jobId:id('3'),attachId:id('d'),renewAfterMs:2000,ttlMs:6000,revision:1}}
+  if(method==='jobs.lookup'){expect(args.intentId).toBe(id('2'));if(lookupRefused)throw {code:'denied'};return {...rawPage().items[0],jobId:id('4')}}
+  if(method==='jobs.status')return {revision:2,availability:'session-required',items:[{...rawPage().items[0],jobId:id('3'),state:'canceled',safeReason:'fenced'}]}
+  return {}
+ })
+ const p=createConnectedJobsProvider({call:call as any})
+ const prepared=await p.prepareInteractive(signal(),{id:'scan',revision:1},{id:id('e'),revision:1},{steps:[{action:'nas.files.stat',segments:['fixture']}]})
+ await p.submitInteractive(prepared,signal());await p.list(signal())
+ await expect(p.resubmit!(id('3'),signal())).rejects.toMatchObject({code:'timeout'})
+ expect(p.resubmissionState?.(id('3'))).toBe('uncertain')
+ await expect(p.lookupResubmission!(id('3'),signal())).rejects.toMatchObject({code:'denied'})
+ expect(p.resubmissionState?.(id('3'))).toBe('uncertain');expect(p.canResubmit?.(id('3'))).toBe(false)
+ lookupRefused=false
+ expect(await p.lookupResubmission!(id('3'),signal())).toEqual({jobId:id('4')})
+ expect(p.resubmissionState?.(id('3'))).toBe('submitted')
+ expect(call.mock.calls.filter(([m])=>m==='jobs.submit')).toHaveLength(2)
+ p.disconnect()
+})
+
+ test('live worker projection validates limits and drops private authority metadata',async()=>{
+ let workers:any=[{id:'inspect',revision:7,actions:['nas.files.read'],maxBytes:4096,handlerBinding:'CANARY'}]
+ const p=createConnectedJobsProvider({call:(async()=>({revision:1,items:[],availability:'session-required',workers})) as any})
+ await p.list(signal());expect(p.interactive.workers).toEqual([{id:'inspect',revision:7,actions:['nas.files.read'],maxBytes:4096}])
+ for(const invalid of [[{...workers[0],maxBytes:524289}],[{...workers[0],actions:['nas.files.write']}],[workers[0],workers[0]],null]){workers=invalid;await expect(p.list(signal())).rejects.toMatchObject({code:'invalid-request'})}
+ p.disconnect();expect(p.interactive.workers).toEqual([])
+ })

package/dist/templates/native-go-vue/frontend/test/jobs-preview.html

@@ -0,0 +1,22 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>S5 local mock fixture</title>
+<style>body{margin:0;background:#f3f5f7}main{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,28rem),1fr));gap:24px;padding:24px}.preview{padding:20px;background:white;min-width:0}.preview h1{font:600 18px system-ui;margin:0 0 20px}</style></head>
+<body><main><section class="preview"><h1>Owner one · mock</h1><div id="owner-one"></div></section><section class="preview"><h1>Owner two · mock</h1><div id="owner-two"></div></section><section class="preview"><h1>Administrator · redacted mock</h1><div id="admin"></div></section><section class="preview"><h1>Production · unavailable</h1><div id="unavailable"></div></section></main>
+<script type="module">
+import {createApp,h} from 'vue'
+import {AppRoot} from '@synopackageland/ui'
+import '@synopackageland/ui/themes/dsm7-embedded.css'
+import '../src/style.css'
+import JobsPanel from '../src/jobs/JobsPanel.vue'
+import JobsAdminPanel from '../src/jobs/JobsAdminPanel.vue'
+import {JobsProviderKey,JobsAdminProviderKey} from '../src/jobs/provider'
+import {createMockJobsService,unavailableJobsProvider} from '../src/jobs/mock-provider'
+if(!import.meta.env.DEV)throw new Error('Mock fixture is development only')
+const service=createMockJobsService(),one=service.connect('one'),two=service.connect('two')
+function mount(id,component,key,provider){const app=createApp({render:()=>h(AppRoot,{},()=>h(component,{locale:'en'}))});app.config.idPrefix=id;app.provide(key,provider);app.mount('#'+id);return app}
+const first=mount('owner-one',JobsPanel,JobsProviderKey,one)
+mount('owner-two',JobsPanel,JobsProviderKey,two)
+mount('admin',JobsAdminPanel,JobsAdminProviderKey,service.connectAdmin())
+mount('unavailable',JobsPanel,JobsProviderKey,unavailableJobsProvider)
+window.s5Preview={unmountFirst(){first.unmount()},async states(){return (await one.list(new AbortController().signal)).items}}
+</script></body></html>

package/dist/templates/native-go-vue/frontend/test/jobs.test.ts

@@ -0,0 +1,176 @@
+// @vitest-environment jsdom
+import {test,expect,vi} from 'vitest'
+import {createApp,h,nextTick} from 'vue'
+import {AppRoot} from '@synopackageland/ui'
+import JobsPanel from '../src/jobs/JobsPanel.vue'
+import {createMockJobsService,unavailableJobsProvider} from '../src/jobs/mock-provider'
+import {JobsProviderKey,type JobsProvider} from '../src/jobs/provider'
+import {jobCatalogs,jobCopy} from '../src/jobs/i18n'
+async function settle(){for(let i=0;i<20;i++){await Promise.resolve();await nextTick()}}
+function mount(provider:JobsProvider,locale='en'){
+ const root=document.createElement('div');document.body.append(root)
+ const app=createApp({render:()=>h(AppRoot,{},()=>h(JobsPanel,{locale}))})
+ app.config.idPrefix=`jobs-${Math.random()}`;app.provide(JobsProviderKey,provider);app.mount(root)
+ return {root,close(){app.unmount();root.remove()}}
+}
+function click(root:HTMLElement,text:string){const b=[...root.querySelectorAll('button')].find(b=>b.textContent?.trim()===text)!;expect(b).toBeTruthy();b.click()}
+test('unavailable is visible and contains no action that pretends to work',async()=>{
+ const f=mount(unavailableJobsProvider);await settle();expect(f.root.textContent).toContain(jobCopy('en').unavailable);expect(f.root.querySelector('button')).toBeNull();f.close()
+})
+test('two AppRoots, explicit server consent, lost confirm reply, close modes and nine locales',async()=>{
+ for(const locale of Object.keys(jobCatalogs)){
+  const s=createMockJobsService(),a=s.connect('one'),b=s.connect('two'),f=mount(a,locale),g=mount(b,locale),copy=jobCopy(locale)
+  await settle();expect(f.root.textContent).toContain(copy.interactiveHelp)
+  click(f.root,copy.prepare);await settle();expect(g.root.textContent).not.toContain('Mock App')
+  const consent=f.root.querySelector<HTMLElement>('[role=checkbox]')!;consent.focus();expect(document.activeElement).toBe(consent)
+  expect([...f.root.querySelectorAll('button')].find(x=>x.textContent===copy.confirm)?.disabled).toBe(true)
+  consent.click();await settle();s.loseConfirmReply=true;click(f.root,copy.confirm);await settle()
+  expect(s.confirmCount).toBe(1);expect(f.root.textContent).toContain(copy.uncertain)
+  click(f.root,copy.lookup);await settle();expect(s.confirmCount).toBe(1)
+  const jobs=await a.list(new AbortController().signal);expect(jobs.items.some(j=>j.mode==='background')).toBe(true)
+  f.close();g.close();const after=await a.list(new AbortController().signal)
+  expect(after.items.find(j=>j.mode==='interactive')?.state).toBe('canceled');expect(after.items.find(j=>j.mode==='background')?.state).toBe('pending')
+  expect(Object.keys(copy).sort()).toEqual(Object.keys(jobCatalogs.en).sort())
+ }
+})
+test('late prepare callback cannot restore closed consent or issue confirm',async()=>{
+ const s=createMockJobsService(),p=s.connect('one');let release!:(x:any)=>void
+ const summary=await p.prepare(new AbortController().signal)
+ p.prepare=()=>new Promise(r=>release=r);const confirm=vi.spyOn(p,'confirm'),f=mount(p);await settle();click(f.root,jobCopy('en').prepare);await settle();f.close();release(summary);await settle();expect(confirm).not.toHaveBeenCalled()
+})
+test('mock enforces cross-user/CAS and preserves revoked versus drained',async()=>{
+ const s=createMockJobsService(),a=s.connect('one'),b=s.connect('two'),signal=new AbortController().signal
+ const summary=await a.prepare(signal)
+ await expect(b.confirm(summary,signal)).rejects.toMatchObject({code:'denied'})
+ await expect(a.confirm({...summary,storeRevision:0},signal)).rejects.toMatchObject({code:'stale'})
+ await a.confirm(summary,signal);const job=await a.lookup(summary.intentId,signal);expect(job).toBeTruthy()
+ await expect(b.lookup(summary.intentId,signal)).rejects.toMatchObject({code:'denied'})
+ s.drain=false;const d=job!.delegation!;const r=await a.revoke(d.id,d.revision,d.storeRevision,signal)
+ expect(r).toEqual({revoked:true,drained:false});expect((await a.lookup(summary.intentId,signal))?.state).toBe('cleanup-required')
+})
+
+test('malicious progress, error payloads and terminal labels never become success',async()=>{
+ const s=createMockJobsService(),p=s.connect('one'),f=mount(p);await settle()
+ p.list=async()=>({revision:1,items:[{jobId:'safe',revision:1,mode:'interactive',state:'running',completedUnits:'CANARY/path' as any,totalUnits:1,drained:false,effectsUnknown:false}]})
+ click(f.root,jobCopy('en').refresh);await settle()
+ expect(f.root.innerHTML).not.toContain('CANARY');expect(f.root.textContent).toContain(jobCopy('en').error)
+ p.list=async()=>{throw {code:'CANARY',message:'/volume1/SECRET',stack:'TOKEN'}}
+ click(f.root,jobCopy('en').refresh);await settle();expect(f.root.innerHTML).not.toMatch(/SECRET|TOKEN|CANARY/)
+ f.close()
+})
+
+test('admin panel shows safe management only and cancels through its separate provider',async()=>{
+ const {default:AdminPanel}=await import('../src/jobs/JobsAdminPanel.vue')
+ const {JobsAdminProviderKey}=await import('../src/jobs/provider')
+ const s=createMockJobsService();s.connect('one');const admin=s.connectAdmin()
+ const root=document.createElement('div');document.body.append(root)
+ const app=createApp({render:()=>h(AppRoot,{},()=>h(AdminPanel,{locale:'en'}))});app.provide(JobsAdminProviderKey,admin);app.mount(root);await settle()
+ expect(root.textContent).not.toContain('one');expect(root.querySelector('progress')).toBeNull()
+ click(root,jobCopy('en').cancel);await settle();expect(root.textContent).toContain(jobCopy('en').drained)
+ app.unmount();root.remove()
+})
+
+test('mock pagination is bounded and cursor is bound to provider and snapshot',async()=>{
+ const s=createMockJobsService(),a=s.connect('one'),b=s.connect('two'),signal=new AbortController().signal
+ for(let i=0;i<10;i++)s.connect('one')
+ const page=await a.list(signal);expect(page.items).toHaveLength(10);expect(page.nextCursor).toBeTruthy()
+ const rest=await a.list(signal,page.nextCursor);expect(rest.items).toHaveLength(1)
+ await expect(b.list(signal,page.nextCursor)).rejects.toMatchObject({code:'stale'})
+ await a.cancel(page.items[0].jobId,page.items[0].revision,signal)
+ await expect(a.list(signal,page.nextCursor)).rejects.toMatchObject({code:'stale'})
+})
+
+test('loss of native access discards cached rows and consent for that mount only',async()=>{
+ const s=createMockJobsService(),p=s.connect('one'),f=mount(p),g=mount(s.connect('two'));await settle()
+ click(f.root,jobCopy('en').prepare);await settle();expect(f.root.textContent).toContain('Mock App')
+ p.list=async()=>{throw {code:'session_required',message:'SECRET'}}
+ click(f.root,jobCopy('en').refresh);await settle()
+ expect(f.root.textContent).not.toContain('Mock App');expect(f.root.textContent).not.toContain(jobCopy('en').running)
+ expect(f.root.querySelectorAll('button')).toHaveLength(0);expect(g.root.textContent).toContain(jobCopy('en').running)
+ f.close();g.close()
+})
+
+test('owner DOM advances a bounded page and refresh returns to the first snapshot page',async()=>{
+ const s=createMockJobsService(),p=s.connect('one');for(let i=0;i<10;i++)s.connect('one')
+ const f=mount(p);await settle();expect(f.root.querySelectorAll('.nas-grants > li')).toHaveLength(10)
+ click(f.root,jobCopy('en').next);await settle();expect(f.root.querySelectorAll('.nas-grants > li')).toHaveLength(1)
+ click(f.root,jobCopy('en').refresh);await settle();expect(f.root.querySelectorAll('.nas-grants > li')).toHaveLength(10)
+ f.close()
+})
+
+ test('connected unavailable modes explain attach expiry and hide background consent',async()=>{
+ const {createConnectedJobsProvider}=await import('../src/jobs/connected-provider')
+ const p=createConnectedJobsProvider({call:async()=>({revision:1,items:[]}) as any}),f=mount(p)
+ await settle()
+ expect(f.root.textContent).not.toContain(jobCopy('en').mock)
+ expect(f.root.textContent).toContain('6 seconds')
+ expect(f.root.textContent).toContain('Background jobs are unavailable')
+ expect([...f.root.querySelectorAll('button')].some(b=>b.textContent===jobCopy('en').prepare)).toBe(false)
+ f.close()
+})
+
+test('connected admin view requests management data explicitly and never claims mock or empty before loading',async()=>{
+ const {default:AdminPanel}=await import('../src/jobs/JobsAdminPanel.vue')
+ const {JobsAdminProviderKey}=await import('../src/jobs/provider')
+ const {createConnectedJobsAdminProvider}=await import('../src/jobs/connected-provider')
+ const call=vi.fn(async()=>({revision:1,items:[]}))
+ const root=document.createElement('div');document.body.append(root)
+ const app=createApp({render:()=>h(AppRoot,{},()=>h(AdminPanel,{locale:'en'}))});app.provide(JobsAdminProviderKey,createConnectedJobsAdminProvider({call:call as any}));app.mount(root);await settle()
+ expect(root.textContent).not.toContain(jobCopy('en').mock);expect(root.textContent).not.toContain(jobCopy('en').empty)
+ expect(call).not.toHaveBeenCalled();click(root,jobCopy('en').refresh);await settle()
+ expect(call).toHaveBeenCalledWith('jobs.admin.status',{});expect(root.textContent).toContain(jobCopy('en').empty)
+ app.unmount();root.remove()
+})
+
+test('fence cancellation is explained in nine locales; resubmit is explicit and disabled while revalidating',async()=>{
+ const {reactive}=await import('vue')
+ for(const locale of Object.keys(jobCatalogs)){
+  const copy=jobCopy(locale) as any,s=createMockJobsService(),p=s.connect('one')
+  const readiness=reactive({interactive:'revalidating',background:'unavailable'})
+  Object.assign(p,{readiness,canResubmit:()=>true,resubmit:vi.fn(async()=>({jobId:'new-job'}))})
+  p.list=async()=>({revision:1,items:[{jobId:'old-job',revision:1,mode:'interactive',state:'canceled',safeReason:'fenced',completedUnits:0,drained:false,effectsUnknown:true}]})
+  const f=mount(p,locale);await settle()
+  expect(f.root.textContent).toContain(copy.revalidating)
+  expect(f.root.textContent).toContain(copy.fenceCanceled)
+  const button=[...f.root.querySelectorAll('button')].find(b=>b.textContent===copy.resubmit)!
+  expect(button).toBeTruthy();expect(button.disabled).toBe(true)
+  expect((p as any).resubmit).not.toHaveBeenCalled()
+  readiness.interactive='ready';await settle();expect(button.disabled).toBe(false)
+  button.focus();expect(document.activeElement).toBe(button)
+  button.click();button.click();await settle();expect((p as any).resubmit).toHaveBeenCalledTimes(1)
+  f.close()
+ }
+})
+
+
+test('an uncertain resubmission offers lookup only, while reopened history has no reusable plan',async()=>{
+ const copy=jobCopy('en'),s=createMockJobsService(),p=s.connect('one')
+ let state:'uncertain'|'submitted'|undefined
+ const resubmit=vi.fn(async()=>{state='uncertain';throw {code:'timeout'}})
+ const lookup=vi.fn(async()=>{state='submitted';return {jobId:'new-job'}})
+ Object.assign(p,{readiness:{interactive:'ready',background:'unavailable'},resubmissionState:()=>state,canResubmit:()=>state===undefined,resubmit,lookupResubmission:lookup})
+ p.list=async()=>({revision:1,items:[{jobId:'old-job',revision:1,mode:'interactive',state:'canceled',safeReason:'fenced',completedUnits:0,drained:false,effectsUnknown:true}]})
+ const f=mount(p);await settle();click(f.root,copy.resubmit);await settle()
+ expect(f.root.textContent).toContain(copy.resubmitUncertain)
+ expect([...f.root.querySelectorAll('button')].some(b=>b.textContent===copy.resubmit)).toBe(false)
+ click(f.root,copy.resubmitLookup);await settle();expect(resubmit).toHaveBeenCalledTimes(1);expect(lookup).toHaveBeenCalledTimes(1)
+ expect(f.root.textContent).toContain(copy.resubmitSubmitted);f.close()
+ const q=s.connect('two');q.list=p.list;Object.assign(q,{readiness:{interactive:'ready',background:'unavailable'}})
+ const g=mount(q);await settle();expect(g.root.textContent).toContain(copy.resubmitUnavailable)
+ expect([...g.root.querySelectorAll('button')].find(b=>b.textContent===copy.resubmit)?.disabled).toBe(true);g.close()
+})
+
+test('connected active jobs refresh at a bounded interval and stop at terminal/unmount',async()=>{
+ vi.useFakeTimers()
+ const p=createMockJobsService().connect('one')
+ const page=await p.list(new AbortController().signal)
+ let done=false
+ const list=vi.fn(async()=>({...page,items:page.items.map(j=>({...j,state:done?'succeeded':'running'}))}))
+ const provider={...p,mode:'connected',readiness:{interactive:'ready',background:'unavailable'},list} as JobsProvider
+ const f=mount(provider)
+ try{
+  await settle();expect(list).toHaveBeenCalledTimes(1)
+  done=true;await vi.advanceTimersByTimeAsync(2500);await settle();expect(list).toHaveBeenCalledTimes(2)
+  await vi.advanceTimersByTimeAsync(10000);expect(list).toHaveBeenCalledTimes(2)
+ }finally{f.close();vi.useRealTimers()}
+})

package/dist/templates/native-go-vue/frontend/test/m2-preview.html

@@ -0,0 +1,27 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><title>M2 local fixture</title><style>html,body{margin:0;height:100%}#root{height:100%}</style></head><body><div id="root"></div><script type="module">
+import {mount} from '../src/m2-main.ts'
+// Synthetic route responses for local browser QA only. No NAS or credentials.
+const id='a'.repeat(64),params=new URLSearchParams(location.search),selections=[],calls=[]
+const folder={name:'Home',path:'/home',isdir:true,additional:{size:0}}
+const note={name:'notes.txt',path:'/home/notes.txt',isdir:false,additional:{size:3}}
+window.fixture={calls,selections,error:'',user:'normal1',reopen:undefined}
+mount(document.querySelector('#root'),{
+ locale:params.get('locale')||'en',reopen(fn){window.fixture.reopen=fn;return ()=>{}},
+ async call(method,args={}){
+  calls.push({method,args})
+  if(method==='app.status')return {package:'M2 local fixture',version:'1',user:window.fixture.user,admin:false}
+  if(window.fixture.error)throw {code:window.fixture.error}
+  if(method==='nas.session.status')return {mode:'filestation-session',interactive:'session-required',background:'unavailable',validation:'local-only'}
+  if(method==='nas.discovery')return {files:args.folder?[]:null,shares:args.folder?undefined:[folder],total:args.folder?0:1,offset:0}
+  if(method==='nas.grants.list')return [...selections]
+  if(method==='nas.grants.confirm'){const s={grantId:id,folder:args.folder,writable:args.writable};selections.push(s);return s}
+  if(method==='nas.grants.revoke'){selections.splice(0);return {revoked:true}}
+  if(method==='nas.files.list')return {files:[note],total:1,offset:0}
+  if(method==='nas.files.stat')return note
+  if(method==='nas.files.read')return {data:'YWJj',bytes:3}
+  if(method==='nas.files.create')return {created:true}
+  if(method==='nas.files.write')return {written:true}
+  throw {code:'unknown_method'}
+ }
+})
+</script></body></html>

package/dist/templates/native-go-vue/frontend/test/m2-provider.test.ts

@@ -0,0 +1,87 @@
+import {afterEach,expect,test,vi} from 'vitest'
+import {createM2Provider} from '../src/nas/m2-provider'
+import {M2_MAX_BYTES} from '../src/nas/m2-contract'
+const id='a'.repeat(64), signal=()=>new AbortController().signal
+const entry={path:'/home/notes.txt',name:'notes.txt',isdir:false,additional:{size:3}}
+const selection={grantId:id,folder:'/home',writable:true,user:'private',uid:'1026',cookie:'secret'}
+afterEach(()=>vi.useRealTimers())
+test('session adapter uses ctx.call exact routes, projects display data and does not forge helper intents',async()=>{
+ const call=vi.fn(async(method:string)=>{
+  if(method==='nas.session.status')return {mode:'filestation-session',interactive:'session-required',background:'unavailable',validation:'local-only'}
+  if(method==='nas.discovery')return {files:null,shares:[{...entry,isdir:true}],total:101,offset:0}
+  if(method==='nas.grants.confirm')return selection
+  if(method==='nas.grants.list')return [selection]
+  if(method==='nas.files.list')return {files:[entry],total:1,offset:0}
+  if(method==='nas.files.stat')return entry
+  if(method==='nas.files.read')return {data:'AAH/',bytes:3}
+  if(method==='nas.files.create')return {created:true}
+  if(method==='nas.files.write')return {written:true}
+  return {revoked:true}
+ })
+ const p=createM2Provider({call:call as any})
+ expect((await p.status(signal())).interactive).toBe('session-required')
+ expect(await p.discovery(undefined,0,signal())).toMatchObject({nextOffset:1,entries:[{isDir:true}]})
+ expect(await p.confirm('/home',true,signal())).toEqual({grantId:id,folder:'/home',writable:true})
+ expect(JSON.stringify(await p.selections(signal()))).not.toMatch(/private|1026|cookie|secret/)
+ expect((await p.list(id,'',0,signal())).entries[0]).toEqual({name:'notes.txt',path:'/home/notes.txt',isDir:false,bytes:3})
+ expect((await p.stat(id,'notes.txt',signal())).bytes).toBe(3)
+ expect(await p.read(id,'notes.txt',signal())).toEqual(new Uint8Array([0,1,255]))
+ await p.create(id,'','\u5e74\u5ea6',signal());await p.upload(id,'\u5e74\u5ea6','file.bin',new Uint8Array([0,1,255]),signal());await p.revoke(id,signal())
+ expect(call).toHaveBeenCalledWith('nas.grants.confirm',{folder:'/home',writable:true})
+ expect(call).toHaveBeenCalledWith('nas.files.write',{grantId:id,relative:'\u5e74\u5ea6',name:'file.bin',data:'AAH/'})
+ expect(call.mock.calls.some(([m])=>/prepare|stream|publish|jobs/.test(m))).toBe(false)
+ p.dispose()
+})
+test('input bounds refuse traversal, WebAPI delimiters and oversized upload without transport',async()=>{
+ const call=vi.fn(),p=createM2Provider({call})
+ for(const relative of ['/absolute','../secret','a//b','a/./b','a\\b','a,b','a"b'])await expect(p.list(id,relative,0,signal())).rejects.toEqual({code:'invalid-request'})
+ for(const name of ['','..','a/b','a,b','a"b','a'.repeat(256)])await expect(p.create(id,'',name,signal())).rejects.toEqual({code:'invalid-request'})
+ await expect(p.discovery(undefined,-1,signal())).rejects.toEqual({code:'invalid-request'})
+ await expect(p.upload(id,'','ok',new Uint8Array(M2_MAX_BYTES+1),signal())).rejects.toEqual({code:'limit-exceeded'})
+ expect(call).not.toHaveBeenCalled();p.dispose()
+})
+test('safe server errors survive without diagnostics; mutation is never retried',async()=>{
+ for(const code of ['session_required','denied','not_found','conflict','commit-uncertain','invalid-request','unavailable']){
+  const call=vi.fn(async()=>{throw {code,message:'Cookie=sid /private'}}),p=createM2Provider({call})
+  await expect(p.create(id,'','new',signal())).rejects.toEqual({code})
+  expect(call).toHaveBeenCalledTimes(1);p.dispose()
+ }
+})
+test('malformed pages, selections, status and bytes refuse rather than invent connectivity',async()=>{
+ for(const [op,value] of [
+  ['discovery',{files:[{...entry,isdir:'yes'}],total:1,offset:0}],
+  ['discovery',{files:Array(101).fill(entry),total:101,offset:0}],
+  ['discovery',{files:[entry],total:1,offset:7}],
+  ['selections',[{...selection,writable:'yes'}]],['status',{mode:'connected',interactive:'ready'}],
+  ['read',{data:'AA==',bytes:3}],['read',{data:'@@',bytes:1}],['read',{data:'',bytes:M2_MAX_BYTES+1}],
+ ] as const){
+  const p=createM2Provider({call:vi.fn(async()=>value) as any})
+  const request=op==='discovery'?p.discovery(undefined,0,signal()):op==='selections'?p.selections(signal()):op==='status'?p.status(signal()):p.read(id,'file',signal())
+  await expect(request).rejects.toEqual({code:'unavailable'});p.dispose()
+ }
+})
+test('timeout or cancellation of a submitted mutation is uncertain; late callbacks cannot restore state',async()=>{
+ vi.useFakeTimers()
+ let resolve!:(value:unknown)=>void
+ const call=vi.fn(()=>new Promise(r=>resolve=r)),p=createM2Provider({call:call as any})
+ const mutation=p.upload(id,'','file',new Uint8Array(),signal())
+ const checked=expect(mutation).rejects.toEqual({code:'commit-uncertain'})
+ await vi.advanceTimersByTimeAsync(22000);await checked
+ expect(call).toHaveBeenCalledTimes(1)
+ resolve({written:true});await Promise.resolve()
+ const controller=new AbortController(),read=p.list(id,'',0,controller.signal)
+ const canceled=expect(read).rejects.toEqual({code:'canceled'});controller.abort();await canceled
+ const late=p.confirm('/home',false,signal()),disposed=expect(late).rejects.toEqual({code:'commit-uncertain'})
+ p.dispose();await disposed;resolve(selection)
+ await expect(p.selections(signal())).rejects.toEqual({code:'canceled'})
+})
+
+test('malformed mutation acknowledgments and unknown transport errors are uncertain, never retryable success',async()=>{
+ for(const operation of ['confirm','revoke','create','upload']as const){
+  const call=vi.fn(async()=>null),p=createM2Provider({call})
+  const request=operation==='confirm'?p.confirm('/home',false,signal()):operation==='revoke'?p.revoke(id,signal()):operation==='create'?p.create(id,'','new',signal()):p.upload(id,'','new',new Uint8Array(),signal())
+  await expect(request).rejects.toEqual({code:'commit-uncertain'});expect(call).toHaveBeenCalledTimes(1);p.dispose()
+ }
+ const p=createM2Provider({call:vi.fn(async()=>{throw {code:'transport_error'}})})
+ await expect(p.create(id,'','new',signal())).rejects.toEqual({code:'commit-uncertain'});p.dispose()
+})