@synopackageland/cli 0.4.0 → 0.4.1

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

@@ -0,0 +1,59 @@
+import type {InjectionKey} from 'vue'
+
+// S0 protocol-2 display projections, not root Grant/Intent authority records.
+// IDs index provider-owned mappings. No paths, credentials, UID or role claims
+// travel in picker/consent arguments. S1 discovery metadata is not a grant.
+export type ScopeKind = 'app-shared' | 'user-personal'
+export const readActions = ['nas.files.list', 'nas.files.stat', 'nas.files.read'] as const
+export type ReadAction = typeof readActions[number]
+export type SafeCode = 'unknown_method' | 'session_required' | 'auth_unavailable' | 'invalid-request' | 'incompatible' | 'unsupported' | 'replay' | 'stale' | 'expired' | 'denied' | 'unavailable' | 'suspended' | 'revoked' | 'fenced' | 'busy' | 'limit-exceeded' | 'canceled' | 'timeout' | 'partial' | 'commit-uncertain' | 'cleanup-required' | 'internal'
+export interface SafeError {code: SafeCode; operationId?: string}
+export interface DiscoveryAnchor {
+ ref: string
+ displayName: string
+ kind: ScopeKind
+ owner: {kind: 'local'; subjectRef: string; instanceRef: string}
+ localFilesystem: boolean
+}
+export interface PickerContext {contextId: string; scopeKind: ScopeKind; expiresAt: number}
+export interface FolderEntry {nodeId: string; displayName: string; targetKind: 'directory'; selectable: boolean}
+export interface FolderPage {entries: FolderEntry[]; nextCursor?: string}
+export interface ConsentSummary {
+ appName: string
+ scopeKind: ScopeKind
+ displayName: string
+ targetKind: 'directory'
+ actions: readonly ReadAction[]
+ persistent: true
+}
+export interface PreparedIntent {intentId: string; summaryDigest: string; expiresAt: number; summary: ConsentSummary}
+export interface GrantHandle {
+ grantId: string
+ revision: number
+ scopeKind: ScopeKind
+ displayName: string
+ targetKind: 'directory'
+ actions: readonly ReadAction[]
+}
+export interface GrantView extends GrantHandle {
+ effectiveState: 'active' | 'suspended' | 'revoked'
+ createdAt: number
+ canRevoke: boolean
+ // S0 R/Q receipt: undefined means Q has not been observed, never assume true.
+ drained?: boolean
+ cleanupRequired?: boolean
+}
+export interface GrantList {items: GrantView[]; canManageShared: boolean}
+export interface RevokeResult {grantId: string; grantRevision: number; revoked: boolean; drained: boolean}
+export interface NasProvider {
+ readonly mode: 'mock' | 'connected'
+ begin(kind: ScopeKind, signal: AbortSignal): Promise<PickerContext>
+ list(contextId: string, nodeId: string | undefined, cursor: string | undefined, signal: AbortSignal): Promise<FolderPage>
+ prepare(candidateId: string, signal: AbortSignal): Promise<PreparedIntent>
+ confirm(intentId: string, summaryDigest: string, signal: AbortSignal): Promise<GrantHandle>
+ cancel(contextId: string): Promise<void>
+ grants(signal: AbortSignal): Promise<GrantView[]>
+ settings(signal: AbortSignal): Promise<GrantList>
+ revoke(grantId: string, revision: number, signal: AbortSignal): Promise<RevokeResult>
+}
+export const NasProviderKey: InjectionKey<NasProvider> = Symbol('nas-provider')

package/templates/native-go-vue/frontend/src/nas/use-request.ts

@@ -0,0 +1,27 @@
+import {onBeforeUnmount, ref} from 'vue'
+
+// One admission at a time per component, bounded metadata requests, and no late
+// responses after close/unmount. An abort is not a server rollback/Q receipt.
+export function useNasRequest() {
+ const busy=ref(false), error=ref<unknown>()
+ let generation=0, disposed=false, controller:AbortController|undefined
+ function cancel() {generation++;controller?.abort();controller=undefined;busy.value=false;error.value=undefined}
+ async function run<T>(operation:(signal:AbortSignal,current:()=>boolean)=>Promise<T>):Promise<T|undefined> {
+  if(busy.value || disposed) return
+  const version=++generation, active=new AbortController();controller=active;busy.value=true;error.value=undefined
+  const current=()=>!disposed && generation===version
+  let timer:ReturnType<typeof setTimeout>|undefined
+  let onAbort:()=>void=()=>{}
+  try {
+   const stop=new Promise<never>((_,reject)=> {
+    onAbort=()=>reject({code:'canceled'});active.signal.addEventListener('abort',onAbort,{once:true})
+    timer=setTimeout(()=>{reject({code:'timeout'});active.abort()},5000)
+   })
+   const value=await Promise.race([operation(active.signal,current),stop])
+   return current()?value:undefined
+  } catch(e) {if(current()) error.value=e;return undefined}
+  finally {clearTimeout(timer);active.signal.removeEventListener('abort',onAbort);if(current()){busy.value=false;controller=undefined}}
+ }
+ onBeforeUnmount(()=>{disposed=true;cancel()})
+ return {busy,error,run,cancel}
+}

package/templates/native-go-vue/frontend/src/style.css

@@ -12,3 +12,20 @@
 [data-ui-app] .integration-actions {display: flex; flex-wrap: wrap; gap: 8px; margin-top: 16px;}
 [data-ui-app] .integration-field {display: grid; gap: 6px; margin: 12px 0;}
 [data-ui-app] .integration-notice {color: var(--ui-text);}
+[data-ui-app] .nas-summary {display: grid; grid-template-columns: minmax(6ch, max-content) minmax(0, 1fr); gap: var(--ui-space-2, 8px) var(--ui-space-4, 16px);}
+[data-ui-app] .nas-summary dd {margin: 0; overflow-wrap: anywhere;}
+[data-ui-app] .nas-breadcrumb {display: flex; flex-wrap: wrap; gap: var(--ui-space-2, 8px); margin-block: var(--ui-space-3, 12px);}
+[data-ui-app] .nas-browser {display: grid; grid-template-columns: minmax(0, 1fr); gap: var(--ui-space-3, 12px);}
+[data-ui-app] .nas-tree {display: none;}
+[data-ui-app] .nas-folder-list {min-width: 0; overflow: auto;}
+[data-ui-app] .nas-folder-name {white-space: normal; overflow-wrap: anywhere; text-align: start;}
+[data-ui-app] .nas-folder-action {white-space: normal; max-width: 100%;}
+[data-ui-app] .nas-picker {max-height: 55vh; overflow: auto; overflow-wrap: anywhere;}
+[data-ui-app] .nas-grants {list-style: none; padding: 0;}
+[data-ui-app] .nas-grants > li {padding-block: var(--ui-space-4, 16px); border-bottom: 1px solid var(--ui-border);}
+[data-ui-app] .nas-grant-heading {display: flex; align-items: start; justify-content: space-between; gap: var(--ui-space-3, 12px);}
+[data-ui-app] .nas-grant-heading strong {overflow-wrap: anywhere;}
+@media (min-width: 960px) {
+ [data-ui-app] .nas-browser {grid-template-columns: minmax(8ch, 1fr) minmax(0, 3fr);}
+ [data-ui-app] .nas-tree {display: block; overflow: auto;}
+}

package/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,8 +22,8 @@ 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')
@@ -146,3 +147,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/templates/native-go-vue/frontend/test/nas-provider.test.ts

@@ -0,0 +1,81 @@
+import {expect, test} from 'vitest'
+import {createMockNasService} from '../src/nas/mock-provider'
+
+const signal = () => new AbortController().signal
+async function selection(provider: ReturnType<ReturnType<typeof createMockNasService>['connect']>) {
+ const context = await provider.begin('user-personal', signal())
+ const page = await provider.list(context.contextId, undefined, undefined, signal())
+ return {context, candidate: page.entries[0]!}
+}
+
+test('two ordinary subjects cannot exchange contexts, candidates, intents or personal grants', async () => {
+ const service = createMockNasService(), a = service.connect('normal1'), b = service.connect('normal2')
+ const picked = await selection(a)
+ await expect(b.list(picked.context.contextId, undefined, undefined, signal())).rejects.toEqual({code:'denied'})
+ await expect(b.prepare(picked.candidate.nodeId, signal())).rejects.toEqual({code:'denied'})
+ const intent = await a.prepare(picked.candidate.nodeId, signal())
+ await expect(b.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'denied'})
+ const grant = await a.confirm(intent.intentId, intent.summaryDigest, signal())
+ expect(await b.grants(signal())).toEqual([])
+ await expect(b.revoke(grant.grantId, grant.revision, signal())).rejects.toEqual({code:'denied'})
+ expect(grant.actions).toEqual(['nas.files.list','nas.files.stat','nas.files.read'])
+ expect(JSON.stringify(grant)).not.toMatch(/\/volume|uid|sessionRef/)
+})
+
+test('intent expires at 30 seconds; candidate expires at 60; cancel never creates a grant', async () => {
+ let now = 1000
+ const service = createMockNasService({now:() => now}), a = service.connect('normal1')
+ const picked = await selection(a), intent = await a.prepare(picked.candidate.nodeId, signal())
+ now += 30_000
+ await expect(a.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'expired'})
+ now += 30_000
+ await expect(a.prepare(picked.candidate.nodeId, signal())).rejects.toEqual({code:'expired'})
+ const next = await selection(a), cancelIntent = await a.prepare(next.candidate.nodeId, signal())
+ await a.cancel(next.context.contextId)
+ await expect(a.confirm(cancelIntent.intentId, cancelIntent.summaryDigest, signal())).rejects.toEqual({code:'canceled'})
+ expect(await a.grants(signal())).toEqual([])
+})
+
+test('summary mismatch, replay, abort, role and session changes refuse; reconfirm gets a new ID', async () => {
+ const service = createMockNasService(), admin = service.connect('admin'), a = service.connect('normal1')
+ await expect(a.begin('app-shared', signal())).rejects.toEqual({code:'denied'})
+ const picked = await selection(a), intent = await a.prepare(picked.candidate.nodeId, signal())
+ await expect(a.confirm(intent.intentId, '0'.repeat(64), signal())).rejects.toEqual({code:'stale'})
+ const grant = await a.confirm(intent.intentId, intent.summaryDigest, signal())
+ await expect(a.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'replay'})
+ await a.revoke(grant.grantId, grant.revision, signal())
+ const second = await a.prepare(picked.candidate.nodeId, signal())
+ expect((await a.confirm(second.intentId, second.summaryDigest, signal())).grantId).not.toBe(grant.grantId)
+ const aborted = new AbortController(); aborted.abort()
+ await expect(a.begin('user-personal', aborted.signal)).rejects.toEqual({code:'canceled'})
+ const context = await admin.begin('app-shared', signal()), page = await admin.list(context.contextId, undefined, undefined, signal())
+ const shared = await admin.prepare(page.entries[0]!.nodeId, signal())
+ service.setAdmin('admin', false)
+ await expect(admin.confirm(shared.intentId, shared.summaryDigest, signal())).rejects.toEqual({code:'denied'})
+ service.invalidate('normal1')
+ await expect(a.list(picked.context.contextId, undefined, undefined, signal())).rejects.toEqual({code:'stale'})
+})
+
+test('shared grant discovery is visible without becoming revoke authority; R and Q stay separate', async () => {
+ const service = createMockNasService({drained:false}), admin = service.connect('admin'), a = service.connect('normal1')
+ const ctx = await admin.begin('app-shared', signal()), page = await admin.list(ctx.contextId, undefined, undefined, signal())
+ const intent = await admin.prepare(page.entries[0]!.nodeId, signal()), grant = await admin.confirm(intent.intentId, intent.summaryDigest, signal())
+ expect((await a.grants(signal()))[0]?.grantId).toBe(grant.grantId)
+ await expect(a.revoke(grant.grantId, grant.revision, signal())).rejects.toEqual({code:'denied'})
+ expect(await admin.revoke(grant.grantId, grant.revision, signal())).toMatchObject({revoked:true,drained:false})
+})
+
+test('pagination binds cursor to actor/context/node and revision CAS rejects stale revoke',async()=> {
+ const service=createMockNasService({pageSize:1}), a=service.connect('normal1'), b=service.connect('normal2')
+ const {context,candidate}=await selection(a)
+ const page=await a.list(context.contextId,undefined,undefined,signal())
+ expect(page.entries).toHaveLength(1);expect(page.nextCursor).toBeTruthy()
+ expect((await a.list(context.contextId,undefined,page.nextCursor,signal())).entries[0]!.displayName).toBe('Empty folder')
+ await expect(a.list(context.contextId,candidate.nodeId,page.nextCursor,signal())).rejects.toEqual({code:'denied'})
+ await expect(b.list(context.contextId,undefined,page.nextCursor,signal())).rejects.toEqual({code:'denied'})
+ const intent=await a.prepare(candidate.nodeId,signal()), grant=await a.confirm(intent.intentId,intent.summaryDigest,signal())
+ await expect(a.revoke(grant.grantId,grant.revision+1,signal())).rejects.toEqual({code:'stale'})
+ service.newEpoch()
+ expect((await a.grants(signal()))[0]!.effectiveState).toBe('suspended')
+ await expect(a.prepare(candidate.nodeId,signal())).rejects.toEqual({code:'stale'})
+})

package/templates/native-go-vue/frontend/test/nas-request.test.ts

@@ -0,0 +1,21 @@
+// @vitest-environment jsdom
+import {expect,test,vi} from 'vitest'
+import {createApp,defineComponent} from 'vue'
+import {useNasRequest} from '../src/nas/use-request'
+
+test('unresponsive discovery times out in five seconds, aborts, and ignores late metadata',async()=> {
+ vi.useFakeTimers()
+ let request!:ReturnType<typeof useNasRequest>
+ const root=document.createElement('div')
+ const app=createApp(defineComponent({setup(){request=useNasRequest();return ()=>null}}));app.mount(root)
+ try {
+  let resolve!:(s:string)=>void, signal!:AbortSignal
+  const pending=request.run(s=>{signal=s;return new Promise<string>(r=>resolve=r)})
+  await vi.advanceTimersByTimeAsync(5000)
+  expect(await pending).toBeUndefined()
+  expect(request.busy.value).toBe(false);expect(signal.aborted).toBe(true)
+  expect(request.error.value).toEqual({code:'timeout'})
+  resolve('late private metadata');await Promise.resolve()
+  expect(request.error.value).toEqual({code:'timeout'})
+ } finally {app.unmount();vi.useRealTimers()}
+})

package/templates/native-go-vue/frontend/test/nas-ui.test.ts

@@ -0,0 +1,261 @@
+// @vitest-environment jsdom
+import {expect, test, vi} from 'vitest'
+import {nextTick} from 'vue'
+import {mount} from '../src/main'
+import {createMockNasService} from '../src/nas/mock-provider'
+import {catalogs, nasCopy, format, errorCopy} from '../src/nas/i18n'
+import type {NasProvider} from '../src/nas/provider'
+import type {Context} from '../src/context'
+
+async function settle() {for(let i=0;i<20;i++){await Promise.resolve();await nextTick()}await new Promise(r=>setTimeout(r,25))}
+function click(root:HTMLElement, text:string) {const b=[...root.querySelectorAll('button')].find(b=>b.textContent?.trim()===text || b.getAttribute('aria-label')===text);expect(b,text).toBeTruthy();b!.click()}
+function fixture(nas:NasProvider | undefined, user='normal1', locale='en') {
+ const root=document.createElement('div');document.body.append(root)
+ const reopen:Array<()=>void>=[]
+ const ctx={locale,reopen(fn:()=>void){reopen.push(fn)},call:vi.fn(async(method:string)=> {
+  if(method==='app.status') return {package:'SamePackage',version:'1',user,admin:user==='admin'}
+  if(method==='integration.status') return {state:'not-enabled',reason:'not-requested',packageRunning:'unknown',scheduler:'not-probed'}
+  throw {code:'unknown_method'}
+ })} as Context
+ const app=mount(root,ctx,{nasProvider:nas})
+ return {root,app,ctx,reopen}
+}
+function cleanup(...fixtures:ReturnType<typeof fixture>[]) {for(const f of fixtures){f.app.unmount();f.root.remove()}}
+
+test('managed account pilot stays visibly off with maintenance and approval restrictions',async()=> {
+ const f=fixture(createMockNasService().connect('admin'),'admin')
+ try {
+  await settle()
+  expect(f.root.textContent).toContain('Managed account pilot: off')
+  expect(f.root.textContent).toContain('Account changes or unverified identity revoke access')
+  expect(f.root.textContent).toContain('Enabling this pilot is unavailable in this build')
+  expect([...f.root.querySelectorAll('button')].some(b=>b.textContent?.includes('Enable managed'))).toBe(false)
+ } finally {cleanup(f)}
+})
+
+test('nine complete catalogs resolve DSM locale aliases with English fallback',()=> {
+ expect(Object.keys(catalogs)).toEqual(['en','zh-TW','zh-CN','ja','ko','de','fr','es','it'])
+ for(const catalog of Object.values(catalogs)) {
+  expect(Object.keys(catalog).sort()).toEqual(Object.keys(catalogs.en).sort())
+  expect(Object.values(catalog).every(s=>typeof s==='string' && s.trim().length>0)).toBe(true)
+  for(const key of Object.keys(catalogs.en) as Array<keyof typeof catalogs.en>) {
+   expect(catalog[key].match(/\{\w+\}/g) ?? []).toEqual(catalogs.en[key].match(/\{\w+\}/g) ?? [])
+  }
+ }
+ expect(nasCopy('cht')).toEqual(catalogs['zh-TW'])
+ expect(nasCopy('zh_CN')).toEqual(catalogs['zh-CN'])
+ expect(nasCopy('unknown')).toEqual(catalogs.en)
+})
+
+test('account changes discard the bound provider UI and its pending candidate context',async()=> {
+ const provider=createMockNasService().connect('normal1'), cancel=vi.spyOn(provider,'cancel'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle()
+  f.ctx.call=vi.fn(async(method:string)=>method==='app.status'?{package:'SamePackage',version:'1',user:'normal2',admin:false}:{state:'not-enabled',reason:'not-requested',packageRunning:'unknown',scheduler:'not-probed'})
+  f.reopen.forEach(fn=>fn());await settle()
+  expect(f.root.textContent).toContain('normal2')
+  expect(f.root.querySelector('[role="dialog"]')).toBeNull()
+  expect(f.root.textContent).not.toContain('Choose my folder')
+  expect(cancel).toHaveBeenCalled()
+ } finally {cleanup(f)}
+})
+
+test('all nine locale UIs localize dialog controls and allow keyboard review without mouse-only actions',async()=> {
+ for(const locale of Object.keys(catalogs)) {
+  const copy=nasCopy(locale), f=fixture(createMockNasService().connect('normal1'),'normal1',locale)
+  try {
+   await settle();click(f.root,copy.choosePersonal);await settle()
+   const selected=[...f.root.querySelectorAll('button')].find(b=>b.getAttribute('aria-label')===format(copy.select,'Projects'))!
+   selected.focus();expect(document.activeElement).toBe(selected)
+   // Native Button remains a keyboard-activatable button (browser verifies Enter).
+   expect(selected.tagName).toBe('BUTTON');selected.click();await settle()
+   click(f.root,copy.review);await settle();expect(f.root.textContent).toContain(copy.persistent)
+   expect(f.root.querySelector(`button[aria-label="${copy.close}"]`)).toBeTruthy()
+   click(f.root,copy.cancel);await settle()
+  } finally {cleanup(f)}
+ }
+})
+
+test('home unavailable is recoverable and native diagnostics are never rendered',async()=> {
+ const provider=createMockNasService({homeAvailable:false}).connect('normal1'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle()
+  expect(f.root.textContent).toContain('Required native identity or permission proof is unavailable')
+  provider.begin=async()=>{throw {code:'unknown',message:'/volume1/private-secret stderr'}}
+  click(f.root,'Retry');await settle()
+  expect(f.root.textContent).toContain('The request failed')
+  expect(f.root.textContent).not.toMatch(/private-secret|stderr/)
+ } finally {cleanup(f)}
+})
+
+test('picker browse, separate selection/summary, cancel, empty and confirm use injected provider only',async()=> {
+ const service=createMockNasService(), provider=service.connect('normal1'), cancel=vi.spyOn(provider,'cancel'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle()
+  expect(f.root.textContent).toContain('Mock preview')
+  expect(f.root.querySelector('[role="dialog"]')).toBeTruthy()
+  click(f.root,'Select Projects');await settle()
+  expect(f.root.textContent).not.toContain('Persistent access')
+  click(f.root,'Review access');await settle()
+  expect(f.root.textContent).toContain('Persistent access')
+  click(f.root,'Cancel');await settle()
+  expect(cancel).toHaveBeenCalled()
+  expect(await provider.grants(new AbortController().signal)).toEqual([])
+  click(f.root,'Choose my folder');await settle();click(f.root,'Open Empty folder');await settle()
+  expect(f.root.textContent).toContain('This folder is empty')
+  click(f.root,'Back');await settle();click(f.root,'Select Projects');await settle();click(f.root,'Review access');await settle();click(f.root,'Confirm access');await settle()
+  expect(f.root.querySelector('[role="dialog"]')).toBeNull()
+  expect(f.root.textContent).toContain('Active')
+ } finally {cleanup(f)}
+})
+
+test('two same-package apps retain local modality, unique ARIA IDs and cancellation isolation',async()=> {
+ const service=createMockNasService(), a=fixture(service.connect('normal1')), b=fixture(service.connect('normal2'))
+ const body=document.body.getAttribute('style')
+ try {
+  await settle();click(a.root,'Choose my folder');click(b.root,'Choose my folder');await settle()
+  const ids=[...document.querySelectorAll('[id]')].map(n=>n.id).filter(Boolean)
+  expect(new Set(ids).size).toBe(ids.length)
+  for(const f of [a,b]) {
+   const dialog=f.root.querySelector('[role="dialog"]')!
+   expect(dialog.hasAttribute('aria-modal')).toBe(false)
+   for(const name of ['aria-labelledby','aria-describedby']) expect(f.root.querySelector(`[id="${dialog.getAttribute(name)}"]`)).toBeTruthy()
+  }
+  expect(getComputedStyle(b.root).pointerEvents).not.toBe('none')
+  click(a.root,'Cancel');await settle()
+  expect(a.root.querySelector('[role="dialog"]')).toBeNull()
+  expect(b.root.querySelector('[role="dialog"]')).toBeTruthy()
+  expect(document.body.getAttribute('style')).toBe(body)
+ } finally {cleanup(a,b)}
+})
+
+test('intent expiry is actionable; revoked but not drained never claims transfers stopped',async()=> {
+ let now=1000
+ const service=createMockNasService({now:()=>now,drained:false}), provider=service.connect('normal1'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle();click(f.root,'Select Projects');await settle();click(f.root,'Review access');await settle()
+  now+=30_000;click(f.root,'Confirm access');await settle()
+  expect(f.root.textContent).toContain('expired')
+  expect(await provider.grants(new AbortController().signal)).toEqual([])
+  click(f.root,'Cancel');await settle();click(f.root,'Choose my folder');await settle();click(f.root,'Select Projects');await settle();click(f.root,'Review access');await settle();click(f.root,'Confirm access');await settle()
+  click(f.root,'Revoke');await settle()
+  expect(f.root.textContent).toContain('already sent or written')
+  click(f.root,'Confirm revoke');await settle()
+  expect(f.root.textContent).toContain('Revoked; stopping transfers')
+ } finally {cleanup(f)}
+})
+
+test('unmount aborts late browse and cancels its context without creating a grant',async()=> {
+ const provider=createMockNasService().connect('normal1'), base=provider.list.bind(provider)
+ let resolve!:()=>void, requestSignal!:AbortSignal
+ provider.list=async(...args)=>{requestSignal=args[3];await new Promise<void>(r=>resolve=r);return base(...args)}
+ const cancel=vi.spyOn(provider,'cancel'), f=fixture(provider)
+ await settle();click(f.root,'Choose my folder');await settle();f.app.unmount()
+ expect(requestSignal.aborted).toBe(true);expect(cancel).toHaveBeenCalled()
+ resolve();await settle();expect(f.root.childElementCount).toBe(0);f.root.remove()
+})
+
+test('late begin after close is canceled and rapid double review consumes one intent',async()=> {
+ const provider=createMockNasService().connect('normal1'), begin=provider.begin.bind(provider)
+ let release!:()=>void
+ provider.begin=async(kind,signal)=>{await new Promise<void>(r=>release=r);return begin(kind,new AbortController().signal)}
+ const cancel=vi.spyOn(provider,'cancel'), prepare=vi.spyOn(provider,'prepare'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle();click(f.root,'Cancel');await settle()
+  release();await settle();expect(cancel).toHaveBeenCalled();expect(f.root.querySelector('[role="dialog"]')).toBeNull()
+  provider.begin=begin
+  click(f.root,'Choose my folder');await settle();click(f.root,'Select Projects');await settle()
+  click(f.root,'Review access');click(f.root,'Review access');await settle()
+  expect(prepare).toHaveBeenCalledTimes(1)
+ } finally {cleanup(f)}
+})
+
+test('long folder names stay text, and revoked without Q uses pending cleanup copy',async()=> {
+ const name='<img src=x onerror=alert(1)> '+ '\u5e74\u5ea6\u5831\u544a'.repeat(20)
+ const provider=createMockNasService({personalFolders:[name]}).connect('normal1'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle()
+  expect(f.root.textContent).toContain(name);expect(f.root.querySelector('img')).toBeNull()
+  click(f.root,'Cancel');await settle()
+  provider.settings=async()=>({canManageShared:false,items:[{grantId:'fixture',revision:2,scopeKind:'user-personal',displayName:name,targetKind:'directory',actions:['nas.files.read'],effectiveState:'revoked',createdAt:1000,canRevoke:true,cleanupRequired:true}]})
+  click(f.root,'Refresh access');await settle()
+  expect(f.root.textContent).toContain('Revoked; cleanup needs verification')
+  expect(f.root.textContent).toContain('Read files')
+  expect(f.root.textContent).not.toContain('List folders')
+ } finally {cleanup(f)}
+})
+
+
+test('S8 production defaults display unavailable for normal/admin even when lifecycle is ready',async()=> {
+ for(const user of ['normal1','admin']) for(const locale of Object.keys(catalogs)) {
+  const f=fixture(undefined,user,locale),copy=nasCopy(locale)
+  try {
+   f.ctx.call=vi.fn(async(method:string)=> {
+    if(method==='app.status') return {package:'SamePackage',version:'1',user,admin:user==='admin'}
+    if(method==='integration.status') return {state:'ready',packageRunning:'running',scheduler:'ready'}
+    if(method==='personal.list') return {items:[]}
+    throw {code:'unknown_method'}
+   })
+   f.reopen.forEach(fn=>fn());await settle()
+   expect(f.root.textContent).toContain(copy.unavailableMessage)
+   expect(f.root.textContent).toContain(copy.pilotUnavailable)
+   expect(f.root.textContent).toContain(copy.noUnlock)
+   expect(f.root.textContent).not.toContain(copy.choosePersonal)
+   expect(f.root.textContent).not.toContain(copy.chooseShared)
+   expect(f.root.textContent).not.toContain(copy.emptyGrant)
+   expect(f.ctx.call.mock.calls.some(([method])=>method.startsWith('nas.'))).toBe(false)
+  } finally {cleanup(f)}
+ }
+})
+
+test('S8 unavailable connected providers are ignored; only development mocks have a picker',async()=> {
+ const connected=createMockNasService().connect('normal1')
+ Object.defineProperty(connected,'mode',{value:'connected'})
+ const settings=vi.spyOn(connected,'settings'),f=fixture(connected)
+ try {
+  await settle()
+  expect(f.root.textContent).toContain(nasCopy('en').unavailableMessage)
+  expect(f.root.textContent).not.toContain('Choose my folder')
+  expect(settings).not.toHaveBeenCalled()
+ } finally {cleanup(f)}
+})
+
+
+test('S8 safe error codes distinguish missing proof, denial, missing method and app authentication',()=> {
+ for(const copy of Object.values(catalogs)) {
+  for(const [code,key] of [['unavailable','errorNativeProof'],['denied','errorDenied'],['unknown_method','errorUnknownMethod'],['unsupported','errorUnsupported'],['session_required','errorSession'],['auth_unavailable','errorAuthentication']] as const) {
+   expect(errorCopy({code,message:'/volume1/private cookie=sid'},copy)).toBe(copy[key])
+   expect(errorCopy({code,message:'/volume1/private cookie=sid'},copy)).not.toMatch(/volume1|cookie=sid/)
+  }
+  expect(new Set(['unavailable','denied','unknown_method','unsupported'].map(code=>errorCopy({code},copy))).size).toBe(4)
+ }
+})
+
+
+test('S8 app request failures use localized safe-code copy without native diagnostics',async()=> {
+ for(const code of ['denied','unknown_method','unavailable','unsupported','session_required','auth_unavailable']) {
+  const f=fixture(undefined,'normal1','cht')
+  try {
+   await settle()
+   f.ctx.call=vi.fn(async()=>{throw {code,message:'/volume1/private cookie=sid'}})
+   f.reopen.forEach(fn=>fn());await settle()
+   expect(f.root.querySelector('[role="alert"]')?.textContent).toBe(errorCopy({code},nasCopy('cht')))
+   expect(f.root.textContent).not.toMatch(/volume1|cookie=sid/)
+  } finally {cleanup(f)}
+ }
+})
+
+ test('S1R risk and reauthorization are disclosed in nine unavailable UIs without data actions',async()=> {
+  for(const locale of Object.keys(catalogs)) {
+   const copy=nasCopy(locale) as any, f=fixture(undefined,'normal1',locale)
+   try {
+    await settle()
+    for(const key of ['relaxedRisk','relaxedReauthorize','relaxedPermissions']) {
+     expect(copy[key],`${locale}:${key}`).toBeTypeOf('string')
+     expect(f.root.textContent).toContain(copy[key])
+    }
+    expect(f.root.textContent).not.toContain(copy.choosePersonal)
+    expect(f.ctx.call.mock.calls.some(([method])=>method.startsWith('nas.'))).toBe(false)
+   } finally {cleanup(f)}
+  }
+ })

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

@@ -1 +1 @@
-{"compilerOptions":{"target":"ES2022","module":"ESNext","moduleResolution":"Bundler","strict":true,"lib":["ES2022","DOM"],"skipLibCheck":true,"types":["vite/client"]},"include":["src/**/*.ts","src/**/*.vue","vite.config.ts"]}
+{"compilerOptions":{"target":"ES2022","module":"ESNext","moduleResolution":"Bundler","resolveJsonModule":true,"strict":true,"lib":["ES2022","DOM"],"skipLibCheck":true,"types":["vite/client"]},"include":["src/**/*.ts","src/**/*.vue","vite.config.ts"]}

package/templates/native-go-vue/frontend/vite.config.ts

@@ -1,8 +1,10 @@
 import { defineConfig } from 'vite'
 import vue from '@vitejs/plugin-vue'
-export default defineConfig({
-  plugins: [vue()],
+// @ts-expect-error The shared notice tool is a plain Node module.
+import { writeThirdPartyNotices } from './third-party-notices.mjs'
+export default defineConfig(({command}) => ({
+  plugins: [vue(), {name: 'dependency-notices', closeBundle() {writeThirdPartyNotices('.', 'dist/LICENSES', {ui: true})}}],
   // Library mode must replace Vue dependency env guards for the DSM browser.
-  define: {'process.env.NODE_ENV': JSON.stringify('production')},
+  define: command === 'build' ? {'process.env.NODE_ENV': JSON.stringify('production')} : {},
   build: {lib: {entry: 'src/main.ts', formats: ['iife'], name: 'DsmVueApp', fileName: () => 'app.js'}, cssCodeSplit: false, rollupOptions: {output: {assetFileNames: 'app.[ext]'}}},
-})
+}))