Harden Windows DLP enforcement and Electron runtime packaging

tests/agent-session-ownership.test.mjs

@@ -0,0 +1,14 @@
+import test from 'node:test';import assert from 'node:assert/strict';import {createRequire} from 'node:module';const require=createRequire(import.meta.url),{createAgentSessionOwnership}=require('../apps/browser/agent-session-ownership.cjs');
+const owner={deviceId:'00000000-0000-4000-8000-000000000001',principalId:'agent-one',generation:1};
+function fixture(){const created=[],installed=[],disposed=[],quarantined=[],live=new Map();let background=false;const deps={createSession:async(partition,options)=>{const session={partition,options,cookies:new Map()};created.push(session);return session;},installGuards:async(session,who,guard)=>{installed.push({session,who,guard});},isLive:(who,options)=>live.get(who.principalId)!==false&&(!options.background||background),quarantineSession:s=>quarantined.push(s),disposeSession:async s=>disposed.push(s)};return {created,installed,disposed,quarantined,live,deps,allowBackground:()=>background=true,make:()=>createAgentSessionOwnership(deps)};}
+test('native partitions and cookies are isolated immutable owners and installed before use',async()=>{const f=fixture(),r=f.make(),a=await r.acquire(owner),b=await r.acquire({...owner,principalId:'agent-two'});assert.notEqual(a,b);assert.notEqual(a.partition,b.partition);assert.equal(a.partition.startsWith('persist:'),false);assert.deepEqual(a.options,{cache:false});a.cookies.set('session','A');assert.equal(b.cookies.has('session'),false);assert.equal(f.installed.length,2);assert.equal(Object.isFrozen(r.getOwner(a)),true);assert.deepEqual(r.getOwner(a),owner);assert.equal(await r.acquire(owner),a);await r.close();});
+test('guard installation must finish before native session is acquired',async()=>{const f=fixture();let finish;f.deps.installGuards=()=>new Promise(resolve=>finish=resolve);const r=f.make();let released=false;const promise=r.acquire(owner).then(s=>{released=true;return s;});await new Promise(resolve=>setImmediate(resolve));assert.equal(released,false);finish();await promise;assert.equal(released,true);await r.close();});
+test('worker background requests require separate live authority and copied guard options',async()=>{const f=fixture(),r=f.make(),session=await r.acquire(owner);assert.throws(()=>r.guard(session,{url:'https://example.com/',background:true}));f.allowBackground();const options={url:'https://example.com/',background:true},guard=r.guard(session,options);options.background=false;f.live.set(owner.principalId,false);assert.throws(guard.assertCurrent);await r.close();});
+test('revoked generation never reuses partition or cookie state, newer generation gets fresh native session',async()=>{const f=fixture(),r=f.make(),old=await r.acquire(owner),guard=r.guard(old);old.cookies.set('login','private');await r.revoke(owner);assert.throws(guard.assertCurrent);await assert.rejects(r.acquire(owner));const next=await r.acquire({...owner,generation:2});assert.notEqual(next.partition,old.partition);assert.equal(next.cookies.size,0);assert.deepEqual(f.quarantined,[old]);assert.ok(f.disposed.includes(old));await r.close();});
+test('revocation during guard install quarantines and never releases partially installed session',async()=>{const f=fixture();let finish;f.deps.installGuards=()=>new Promise(resolve=>finish=resolve);const r=f.make(),acquire=r.acquire(owner);await new Promise(resolve=>setImmediate(resolve));const revoke=r.revoke(owner);finish();await assert.rejects(acquire);await revoke;assert.equal(f.disposed.length,1);await assert.rejects(r.acquire(owner));await r.close();});
+test('native session object cannot be retagged or borrowed from another principal',async()=>{const f=fixture(),shared={};f.deps.createSession=async()=>shared;const r=f.make();await r.acquire(owner);await assert.rejects(r.acquire({...owner,principalId:'other'}));assert.deepEqual(r.getOwner(shared),owner);await r.close();});
+test('failed install, aborted acquisition and capacity preserve fail-closed ownership',async()=>{const f=fixture();f.deps.installGuards=async()=>{throw Error('Guards incomplete');};const r=f.make();await assert.rejects(r.acquire(owner));assert.equal(f.disposed.length,1);await assert.rejects(r.acquire(owner));await r.close();const g=fixture();g.deps.maxSessions=1;const s=g.make();await s.acquire(owner);await assert.rejects(s.acquire({...owner,principalId:'other'}));await assert.rejects(s.acquire({...owner,principalId:'third'},{signal:AbortSignal.abort()}));await s.close();});
+test('failed native cleanup retains capacity and disposal flag until explicit retry succeeds',async()=>{const f=fixture();f.deps.maxSessions=1;let failCleanup=true,calls=0;f.deps.disposeSession=async s=>{calls++;if(failCleanup)throw Error('Native cleanup failed');f.disposed.push(s);};const r=f.make(),native=await r.acquire(owner);await assert.rejects(r.revoke(owner));const rows=r.enumerateEntries();assert.equal(rows.length,1);assert.equal(rows[0].active,false);assert.equal(rows[0].disposed,false);assert.equal(rows[0].session,native);await assert.rejects(r.acquire({...owner,generation:2}));failCleanup=false;const result=await r.sweep();assert.equal(result[0].status,'fulfilled');assert.equal(r.enumerateEntries().length,0);assert.equal(calls,2);await r.acquire({...owner,generation:2});await r.close();});
+test('policy sweep invalidates live guards synchronously and readonly inventory never exposes mutable owner',async()=>{const f=fixture(),r=f.make(),native=await r.acquire(owner),guard=r.guard(native);const entries=r.enumerateEntries(),sessions=r.liveSessions();assert.equal(Object.isFrozen(entries),true);assert.equal(Object.isFrozen(entries[0]),true);assert.equal(Object.isFrozen(entries[0].owner),true);assert.equal(Object.isFrozen(sessions),true);assert.deepEqual(sessions,[native]);f.live.set(owner.principalId,false);const sweeping=r.sweep();assert.throws(guard.assertCurrent);assert.equal(r.liveSessions().length,0);await sweeping;assert.equal(r.enumerateEntries().length,0);await r.close();});
+test('network release guard refuses requests before guard installation completes',async()=>{const f=fixture();let deniedEarly=false;f.deps.installGuards=async(_session,_owner,guard)=>{assert.doesNotThrow(()=>guard({phase:'install'}));assert.throws(()=>guard({phase:'network'}));deniedEarly=true;};const r=f.make(),native=await r.acquire(owner);assert.equal(deniedEarly,true);r.guard(native).assertCurrent();await r.close();});
+test('repeated close retries failed cleanup without reopening revoked sessions',async()=>{const f=fixture();let failCleanup=true;f.deps.disposeSession=async()=>{if(failCleanup)throw Error('Failure');};const r=f.make();await r.acquire(owner);await r.close();assert.equal(r.enumerateEntries().length,1);assert.equal(r.enumerateEntries()[0].disposed,false);failCleanup=false;await r.close();assert.equal(r.enumerateEntries().length,0);await assert.rejects(r.acquire({...owner,generation:2}));});