cabloy 5.1.216 → 5.1.218

package/scripts/runIsolatedTest.ts

@@ -3,8 +3,9 @@ import type { ChildProcess } from 'node:child_process';
 import { spawn } from 'node:child_process';
 import { createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { realpathSync } from 'node:fs';
 import { createServer } from 'node:net';
-import { dirname, resolve } from 'node:path';
+import { basename, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import {
@@ -19,6 +20,7 @@ import {
   reapExpiredTestClaims,
 } from './testClaimCleanup.ts';
 import { inspectTestProcess, isTestClaimInactive } from './testClaimProcesses.ts';
+import { startWindowsOwnedProcess } from './testProcessGuardianWindows.ts';
 
 export const ROOT_DIR = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const OWNER_FILE = '.vona-test-owner';
@@ -92,9 +94,7 @@ export async function startOwnedProcess(
   cwd: string,
   env: NodeJS.ProcessEnv,
 ): Promise<OwnedProcess> {
-  if (process.platform === 'win32') {
-    throw new Error('Isolated test process-tree cleanup requires POSIX process groups');
-  }
+  if (process.platform === 'win32') return startWindowsOwnedProcess(command, args, cwd, env);
   const processId = randomUUID();
   const managed = hasTestClaimTransport(env);
   const registration = { id: processId, role: 'guardian', stage: 'pending' as const };
@@ -255,11 +255,85 @@ export function getIsolatedVonaCommand(port: number, env: NodeJS.ProcessEnv, rea
   };
 }
 
+interface IsolatedVonaDependencies {
+  start: typeof startOwnedProcess;
+  ready: typeof waitForReady;
+  platform?: NodeJS.Platform;
+  requestStop?: typeof requestIsolatedVonaStop;
+  shutdownTimeoutMs?: number;
+}
+
+export async function requestIsolatedVonaStop(
+  port: number,
+  runId: string | undefined,
+  key: string,
+  timeoutMs = 1500,
+) {
+  if (!runId || !/^\d{14}-[a-f0-9]{8}$/.test(runId) || !/^[a-f0-9]{64}$/.test(key)) {
+    throw new Error('Invalid isolated Vona shutdown identity');
+  }
+  const nonce = randomBytes(16).toString('hex');
+  const payload = `${runId}\nPOST\n/health/test-stop\n${nonce}`;
+  const response = await fetch(`http://127.0.0.1:${port}/health/test-stop`, {
+    method: 'POST',
+    redirect: 'error',
+    signal: AbortSignal.timeout(timeoutMs),
+    headers: {
+      'x-vona-test-stop-nonce': nonce,
+      'x-vona-test-stop-authorization': createHmac('sha256', key)
+        .update(`vona-test-stop-request-v1\n${payload}`)
+        .digest('hex'),
+    },
+  });
+  const proof = response.headers.get('x-vona-test-stop-proof');
+  const expected = createHmac('sha256', key).update(`vona-test-stop-ack-v1\n${payload}`).digest();
+  if (
+    response.status !== 200 ||
+    !proof ||
+    !/^[a-f0-9]{64}$/.test(proof) ||
+    !timingSafeEqual(expected, Buffer.from(proof, 'hex')) ||
+    ((await response.json()) as { status?: string }).status !== 'stopping'
+  ) {
+    throw new Error('Isolated Vona shutdown refused or acknowledgment proof was invalid');
+  }
+}
+
+async function stopVonaCooperatively(
+  port: number,
+  env: NodeJS.ProcessEnv,
+  readyKey: string,
+  server: OwnedProcess,
+  dependencies: IsolatedVonaDependencies,
+) {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      (async () => {
+        await (dependencies.requestStop ?? requestIsolatedVonaStop)(
+          port,
+          env.VONA_TEST_RUN_ID,
+          readyKey,
+        );
+        return await server.wait();
+      })(),
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(
+          () =>
+            reject(new Error('Isolated Vona cooperative shutdown did not prove drainage in time')),
+          dependencies.shutdownTimeoutMs ?? 20_000,
+        );
+      }),
+    ]);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
 export async function withIsolatedVona<T>(
   port: number,
   env: NodeJS.ProcessEnv,
   callback: () => Promise<T>,
-  dependencies = { start: startOwnedProcess, ready: waitForReady },
+  dependencies: IsolatedVonaDependencies = { start: startOwnedProcess, ready: waitForReady },
 ): Promise<T> {
   const readyKey = randomBytes(32).toString('hex');
   const command = getIsolatedVonaCommand(port, env, readyKey);
@@ -284,8 +358,43 @@ export async function withIsolatedVona<T>(
   let operationError: Error | undefined;
   let shutdownError: Error | undefined;
   let result: T | undefined;
+  let ready = false;
+  const windows = (dependencies.platform ?? process.platform) === 'win32';
+  const shutdown = async () => {
+    const cooperative = windows && ready && !interrupted && !exitedEarly;
+    try {
+      const stopped = cooperative
+        ? await stopVonaCooperatively(port, env, readyKey, server, dependencies)
+        : await server.stop();
+      if (
+        stopped.failed ||
+        interrupted ||
+        exitedEarly ||
+        stopped.result?.code !== 0 ||
+        (windows && !!stopped.result?.signal)
+      ) {
+        throw new Error(
+          'Isolated Vona server did not stop cleanly, exited early, or run was interrupted',
+        );
+      }
+    } catch (error) {
+      // Force-stop remains a failed-run fallback, never successful Windows teardown.
+      if (cooperative) {
+        try {
+          await server.stop();
+        } catch (fallbackError) {
+          throw new AggregateError(
+            [error, fallbackError],
+            'Isolated Vona cooperative shutdown and failure-stop failed',
+          );
+        }
+      }
+      throw error;
+    }
+  };
   try {
     await dependencies.ready(port, server, readyKey);
+    ready = true;
     if (interrupted) throw new Error('Isolated Vona run interrupted');
     result = await callback();
   } catch (error) {
@@ -293,12 +402,7 @@ export async function withIsolatedVona<T>(
   } finally {
     stopping = true;
     try {
-      const stopped = await server.stop();
-      if (stopped.failed || interrupted || exitedEarly || stopped.result?.code !== 0) {
-        shutdownError = new Error(
-          'Isolated Vona server did not stop cleanly, exited early, or run was interrupted',
-        );
-      }
+      await shutdown();
     } catch (error) {
       shutdownError = toError(error);
     } finally {
@@ -384,10 +488,27 @@ export async function waitForReady(
   throw new Error('Isolated Vona server did not become ready with a valid ownership proof');
 }
 
+export function resolveNpmCli(
+  env: NodeJS.ProcessEnv = process.env,
+  execPath = process.execPath,
+): string {
+  const candidates = [
+    env.npm_execpath,
+    resolve(dirname(execPath), 'node_modules/npm/bin/npm-cli.js'),
+    resolve(dirname(execPath), '../lib/node_modules/npm/bin/npm-cli.js'),
+  ];
+  for (const candidate of candidates) {
+    if (!candidate || !existsSync(candidate)) continue;
+    const file = realpathSync(candidate);
+    if (basename(file) === 'npm-cli.js' && basename(dirname(dirname(file))) === 'npm') return file;
+  }
+  throw new Error('Cannot resolve npm CLI; run through npm or install npm beside Node.js');
+}
+
 export function getUnitTestCommands(args: string[]) {
   const vonaDir = resolve(ROOT_DIR, 'vona');
   return [
-    { command: 'npm', args: ['run', 'prerun'], cwd: vonaDir },
+    { command: process.execPath, args: [resolveNpmCli(), 'run', 'prerun'], cwd: vonaDir },
     {
       command: process.execPath,
       args: [
@@ -468,6 +589,12 @@ export async function withIsolatedRun<T>(
       SERVER_SERVE_HOST: undefined,
       TMPDIR: resolve(dataRoot, 'tmp'),
     };
+    if (process.platform === 'win32') {
+      for (const key of Object.keys(env)) {
+        if (['TEMP', 'TMP', 'TMPDIR'].includes(key.toUpperCase())) delete env[key];
+      }
+      env.TEMP = env.TMP = env.TMPDIR = resolve(dataRoot, 'tmp');
+    }
     await broker.update({ type: 'status', status: 'running' });
     result = await callback({
       runId,

package/scripts/testBrowserGuardianWindows.test.ts

@@ -0,0 +1,327 @@
+import type { ChildProcess } from 'node:child_process';
+
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { loadTestClaim } from '../vona/packages-vona/vona-core/src/lib/core/testClaim.ts';
+import {
+  inspectWindowsProcess,
+  inspectWindowsProcesses,
+} from '../vona/packages-vona/vona-core/src/lib/core/testProcessWindowsNative.ts';
+import { isTestClaimInactive } from './testClaimProcesses.ts';
+
+const rootDir = dirname(dirname(fileURLToPath(import.meta.url)));
+const require = createRequire(import.meta.url);
+const nativeOptions = {
+  skip:
+    process.platform !== 'win32'
+      ? 'Requires native Windows, PowerShell 7 and installed Playwright Chromium'
+      : false,
+  timeout: 180_000,
+};
+const moduleUrl = (name: string) => new URL(name, import.meta.url).href;
+const claimUrl = moduleUrl('../vona/packages-vona/vona-core/src/lib/core/testClaim.ts');
+const nativeUrl = moduleUrl(
+  '../vona/packages-vona/vona-core/src/lib/core/testProcessWindowsNative.ts',
+);
+const guardianUrl = moduleUrl('./testProcessGuardianWindows.ts');
+const managedUrl = moduleUrl('../repo-e2e/scripts/managedTest.ts');
+
+async function until<T>(
+  check: () => T | undefined | Promise<T | undefined>,
+  timeout = 60_000,
+): Promise<T> {
+  const deadline = Date.now() + timeout;
+  for (;;) {
+    const value = await check();
+    if (value !== undefined) return value;
+    if (Date.now() >= deadline) throw new Error('Windows Chromium containment fixture timed out');
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+}
+function json<T>(file: string): T | undefined {
+  try {
+    return JSON.parse(readFileSync(file, 'utf8')) as T;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT' || error instanceof SyntaxError)
+      return undefined;
+    throw error;
+  }
+}
+async function exited(
+  identities: { pid: number; startTime: string }[],
+  inspect = inspectWindowsProcesses,
+) {
+  return await until(async () => {
+    const snapshots = await inspect(identities.map(item => item.pid));
+    return identities.every(
+      identity =>
+        !snapshots.some(item => item.pid === identity.pid && item.startTime === identity.startTime),
+    )
+      ? snapshots
+      : undefined;
+  }, 30_000);
+}
+test('exit observation accepts PID reuse but returns the occupied snapshot for cleanup checks', async () => {
+  const identities = [{ pid: 100, startTime: '134000000000000000' }];
+  const snapshots = [
+    {
+      pid: 100,
+      startTime: '134000000000000001',
+      host: 'test-host',
+      state: 'running' as const,
+      args: '',
+    },
+  ];
+  let inspections = 0;
+  const observed = await exited(identities, async pids => {
+    assert.deepEqual(pids, [100]);
+    inspections++;
+    return inspections === 1 ? [{ ...snapshots[0], ...identities[0] }] : snapshots;
+  });
+  assert.equal(observed, snapshots);
+  assert.equal(inspections, 2);
+});
+
+function closePromise(child: ChildProcess) {
+  return new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve, reject) => {
+    child.once('error', reject);
+    child.once('close', (code, signal) => resolve({ code, signal }));
+  });
+}
+
+for (const mode of ['normal', 'cancel', 'controller-death', 'helper-death'] as const) {
+  test(
+    `real Playwright worker/Chromium inherited private Job: ${mode}`,
+    nativeOptions,
+    async () => {
+      // Deliberately resolve the public package/CLI. Missing browser binaries are a Windows gate failure, not a skip.
+      const playwrightUrl = pathToFileURL(require.resolve('@playwright/test')).href;
+      const playwrightCli = require.resolve('@playwright/test/cli');
+      const root = mkdtempSync(join(realpathSync(tmpdir()), 'cabloy chromium job 空格 '));
+      const project = join(root, 'vona');
+      mkdirSync(project);
+      const runId = `20261018010203-${randomUUID().replaceAll('-', '').slice(0, 8)}`;
+      const dataRoot = join(project, `.app-test-${runId}`);
+      const temporaryRoot = join(dataRoot, 'tmp');
+      mkdirSync(temporaryRoot, { recursive: true });
+      writeFileSync(join(dataRoot, '.vona-test-owner'), `${runId}\n`);
+      const configPath = join(root, 'playwright.config.mjs');
+      const specPath = join(root, 'contained.spec.mjs');
+      const controllerPath = join(root, 'controller.mjs');
+      const browserPath = join(root, 'browser.json');
+      const releasePath = join(root, 'release');
+      const pageReadyPath = join(root, 'page-ready');
+      const resultPath = join(root, 'result.json');
+      const claimPath = join(project, '.vona-test-claim', `${runId}.json`);
+      writeFileSync(
+        configPath,
+        `export default {testDir:${JSON.stringify(root)},testMatch:'contained.spec.mjs',workers:1,retries:0,timeout:120000,reporter:'line',outputDir:${JSON.stringify(join(dataRoot, 'test-results'))}};`,
+      );
+      writeFileSync(
+        specPath,
+        `
+      import playwrightTest from ${JSON.stringify(playwrightUrl)};
+      import {existsSync, writeFileSync} from 'node:fs';
+      import {useManagedBrowser} from ${JSON.stringify(managedUrl)};
+      import {assertTestClaimWindowsJob, sendTestClaimEvent} from ${JSON.stringify(claimUrl)};
+      import {inspectTestProcess, waitForTestProcessGroupExit} from ${JSON.stringify(moduleUrl('./testClaimProcesses.ts'))};
+      const {test:base,expect}=playwrightTest;
+      const test=base.extend({browser:[async({playwright},use)=>{
+        let child;
+        const chromium={launchServer:async options=>{const server=await playwright.chromium.launchServer(options);child=server.process();return server;},
+          connect:(...args)=>playwright.chromium.connect(...args)};
+        await useManagedBrowser({browserType:chromium,launchOptions:{},headless:true,channel:undefined},async browser=>{
+          const worker=await inspectTestProcess(process.pid), browserIdentity=await inspectTestProcess(child.pid);
+          await assertTestClaimWindowsJob(process.env,worker);
+          await assertTestClaimWindowsJob(process.env,browserIdentity);
+          const session=await browser.newBrowserCDPSession();
+          const rows=await session.send('SystemInfo.getProcessInfo');
+          const identities=[];
+          for(const row of rows.processInfo){
+            const identity=await inspectTestProcess(row.id);
+            await assertTestClaimWindowsJob(process.env,identity);
+            identities.push(identity);
+          }
+          await session.detach();
+          writeFileSync(${JSON.stringify(browserPath)},JSON.stringify({worker,browser:browserIdentity,processes:identities,locator:process.env.VONA_TEST_WINDOWS_GUARDIAN_ID}));
+          await use(browser);
+        },{env:process.env,projectPath:${JSON.stringify(project)},sendEvent:sendTestClaimEvent,inspectProcess:inspectTestProcess,waitForGroupExit:waitForTestProcessGroupExit});
+      },{scope:'worker',timeout:0}]});
+      test('actual Chromium worker membership',async({page})=>{
+        await page.setContent('<title>contained Chromium</title><h1>private Job</h1>');
+        await expect(page).toHaveTitle('contained Chromium');
+        writeFileSync(${JSON.stringify(pageReadyPath)},'ready');
+        while(!existsSync(${JSON.stringify(releasePath)})) await new Promise(resolve=>setTimeout(resolve,50));
+      });
+    `,
+      );
+      writeFileSync(
+        controllerPath,
+        `
+      import {writeFileSync} from 'node:fs';
+      import {PassThrough} from 'node:stream';
+      import {createTestClaim,startTestClaimBroker} from ${JSON.stringify(claimUrl)};
+      import {inspectWindowsProcess} from ${JSON.stringify(nativeUrl)};
+      import {startWindowsOwnedProcess} from ${JSON.stringify(guardianUrl)};
+      let guardian,helper,broker;let stopping=false;let diagnostics='';
+      process.on('message',message=>{
+        if(message==='stop'){stopping=true;if(guardian)void guardian.stop().catch(()=>{});}
+        if(message==='kill-helper'){if(!helper)throw Error('No live helper');helper.kill('SIGKILL');}
+      });
+      const stdout=new PassThrough(),stderr=new PassThrough();
+      stdout.on('data',value=>{diagnostics=(diagnostics+value).slice(-32768)});
+      stderr.on('data',value=>{diagnostics=(diagnostics+value).slice(-32768)});
+      try {
+        const owner=await inspectWindowsProcess(process.pid);
+        await createTestClaim(${JSON.stringify(project)},${JSON.stringify(runId)},'e2e',{pid:owner.pid,startTime:owner.startTime,host:owner.host});
+        broker=await startTestClaimBroker(${JSON.stringify(claimPath)});
+        const env={...process.env,...broker.env,META_MODE:'test',VONA_TEST_RUN_ID:${JSON.stringify(runId)}};
+        for(const key of Object.keys(env))if(['TEMP','TMP','TMPDIR','VONA_TEST_WINDOWS_GUARDIAN_ID'].includes(key.toUpperCase()))delete env[key];
+        Object.assign(env,{TEMP:${JSON.stringify(temporaryRoot)},TMP:${JSON.stringify(temporaryRoot)},TMPDIR:${JSON.stringify(temporaryRoot)},vona_test_windows_guardian_id:'inherited-spoof'});
+        guardian=await startWindowsOwnedProcess(process.execPath,[${JSON.stringify(playwrightCli)},'test','--config',${JSON.stringify(configPath)}],${JSON.stringify(rootDir)},env,{stdout,stderr,onHelperSpawn:value=>{helper=value}});
+        if(stopping)void guardian.stop().catch(()=>{});
+        const result=await guardian.wait();
+        writeFileSync(${JSON.stringify(resultPath)},JSON.stringify({result,diagnostics}));
+      } catch(error) {
+        writeFileSync(${JSON.stringify(resultPath)},JSON.stringify({error:String(error),diagnostics}));
+      } finally {await broker?.close();process.disconnect();}
+    `,
+      );
+      const sentinel = spawn(process.execPath, ['-e', 'setInterval(()=>{},1000)'], {
+        stdio: 'ignore',
+      });
+      const sentinelClosed = closePromise(sentinel);
+      const controller = spawn(process.execPath, [controllerPath], {
+        cwd: rootDir,
+        stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+      });
+      const controllerClosed = closePromise(controller);
+      let diagnostics = '';
+      controller.stdout!.on('data', value => {
+        diagnostics += value.toString();
+      });
+      controller.stderr!.on('data', value => {
+        diagnostics += value.toString();
+      });
+      try {
+        const sentinelIdentity = await inspectWindowsProcess(sentinel.pid!);
+        assert.ok(sentinelIdentity);
+        const record = await until(() => {
+          const value = json<{
+            worker: { pid: number; startTime: string };
+            browser: { pid: number; startTime: string };
+            processes: { pid: number; startTime: string }[];
+            locator: string;
+          }>(browserPath);
+          if (value && existsSync(pageReadyPath)) return value;
+          const result = json<{ error?: string; diagnostics: string }>(resultPath);
+          if (result || controller.exitCode !== null) {
+            throw new Error(
+              `Chromium did not reach membership gate: ${JSON.stringify(result)} ${diagnostics}`,
+            );
+          }
+          return undefined;
+        }, 90_000);
+        const manifest = await loadTestClaim(claimPath);
+        assert.equal(manifest.kind, 'e2e');
+        assert.equal(manifest.version, 1);
+        assert.equal(manifest.processes.length, 1);
+        const registered = manifest.processes[0];
+        assert.equal(registered.stage, 'registered');
+        assert.equal(registered.containment, 'windows-job');
+        assert.equal(record.locator, registered.id);
+        assert.notEqual(record.locator, 'inherited-spoof');
+        assert.notEqual(record.worker.pid, record.browser.pid);
+        assert.ok(record.processes.some(item => item.pid === record.browser.pid));
+        const ownedIdentities = [record.worker, record.browser, ...record.processes];
+        if (mode === 'normal') writeFileSync(releasePath, 'close');
+        else if (mode === 'cancel') controller.send('stop');
+        else if (mode === 'controller-death') controller.kill('SIGKILL');
+        else controller.send('kill-helper');
+        await Promise.race([
+          controllerClosed,
+          new Promise<never>((_, reject) => {
+            const timer = setTimeout(
+              () => reject(new Error(`Controller shutdown timed out: ${diagnostics}`)),
+              40_000,
+            );
+            timer.unref();
+            void controllerClosed.finally(() => clearTimeout(timer)).catch(() => {});
+          }),
+        ]);
+        // Compare exact identities: a later native inspector can reuse an exited PID itself.
+        const snapshots = await exited([
+          ...ownedIdentities,
+          { pid: registered.pid!, startTime: registered.startTime! },
+          manifest.owner,
+        ]);
+        assert.deepEqual(await inspectWindowsProcess(sentinel.pid!), sentinelIdentity);
+        const retained = await loadTestClaim(claimPath);
+        assert.equal(retained.processes.length, 1); // No per-browser intents/registration/drainage on Windows.
+        if (mode === 'normal' || mode === 'cancel') {
+          const completed = json<{
+            result?: { failed: boolean; result: { code: number } };
+            error?: string;
+            diagnostics: string;
+          }>(resultPath);
+          assert.ok(completed?.result, JSON.stringify(completed));
+          assert.equal(completed.result.failed, mode !== 'normal', completed.diagnostics);
+          if (mode === 'normal')
+            assert.equal(completed.result.result.code, 0, completed.diagnostics);
+          assert.equal(retained.processes[0].stage, 'drained');
+          // Cleanup deliberately blocks reused PIDs too. Evaluate the same native snapshot
+          // used above, not a second inspector that can change PID occupancy between checks.
+          const inactivity = await isTestClaimInactive(retained, false, async () => snapshots);
+          const occupied = snapshots.some(item =>
+            [retained.owner.pid, retained.processes[0].pid].includes(item.pid),
+          );
+          assert.deepEqual(
+            inactivity,
+            occupied
+              ? {
+                  inactive: false,
+                  reason: snapshots.some(item => item.pid === retained.owner.pid)
+                    ? 'claim owner PID is still present'
+                    : 'registered Windows job owner is still present',
+                }
+              : { inactive: true },
+            JSON.stringify({ snapshots, owner: retained.owner, guardian: retained.processes[0] }),
+          );
+        } else {
+          assert.equal(retained.processes[0].stage, 'registered');
+          assert.equal((await isTestClaimInactive(retained)).inactive, false);
+          if (mode === 'helper-death') {
+            assert.match(
+              json<{ error: string }>(resultPath)!.error,
+              /without proving Job shutdown/,
+            );
+          }
+        }
+      } finally {
+        if (controller.exitCode === null && controller.signalCode === null)
+          controller.kill('SIGKILL');
+        await controllerClosed.catch(() => {});
+        sentinel.kill();
+        await sentinelClosed;
+        // Retention assertions precede removal of this test's own temporary fixture.
+        if (existsSync(root)) rmSync(root, { recursive: true, force: true });
+      }
+    },
+  );
+}

package/scripts/testClaimCleanup.test.ts

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
 import {
   chmod,
   lstat,
@@ -22,6 +23,7 @@ import {
   loadTestClaim,
   writeTestClaim,
 } from '../vona/packages-vona/vona-core/src/lib/core/testClaim.ts';
+import { createTestClaimFile } from '../vona/packages-vona/vona-core/src/lib/core/testClaimFilesystem.ts';
 import {
   getTestAppName,
   getDatabaseTestPrefix,
@@ -204,7 +206,11 @@ test('live, missing inspector, drifted config, malformed manifest and unmarked r
       if (reason === 'unmarked') await rm(path.join(f.manifest.locals[0].path, '.vona-test-owner'));
       if (reason === 'symlink') {
         await rm(f.manifest.locals[0].path, { recursive: true });
-        await symlink(path.join(f.project, '.app'), f.manifest.locals[0].path);
+        await symlink(
+          path.join(f.project, '.app'),
+          f.manifest.locals[0].path,
+          process.platform === 'win32' ? 'junction' : 'dir',
+        );
       }
       const result = await cleanTestClaim(f.claimPath, {
         isInactive: reason === 'inspector' ? undefined : async () => reason !== 'live',
@@ -250,10 +256,9 @@ test('exclusive cleaners skip contenders; orphaned old lock is never taken over'
   }
   const second = await fixture();
   try {
-    await writeFile(
+    await createTestClaimFile(
       `${second.claimPath}.cleanup.lock`,
       JSON.stringify({ pid: 999999, startTime: 'ancient', token: 'orphan' }),
-      { mode: 0o600 },
     );
     const result = await reapExpiredTestClaims(second.project, {
       now: Date.parse(second.manifest.createdAt) + 10000,
@@ -271,12 +276,23 @@ test('exclusive cleaners skip contenders; orphaned old lock is never taken over'
 test('unsafe shared directories fail invocation; legacy directories warn and remain', async () => {
   const f = await fixture();
   try {
-    await chmod(path.dirname(f.claimPath), 0o777);
-    await assert.rejects(
-      reapExpiredTestClaims(f.project, { isInactive: inactive }),
-      /Unsafe shared/,
-    );
-    await chmod(path.dirname(f.claimPath), 0o700);
+    if (process.platform === 'win32') {
+      execFileSync('icacls.exe', [path.dirname(f.claimPath), '/grant', '*S-1-1-0:(R)'], {
+        windowsHide: true,
+        stdio: 'pipe',
+      });
+    } else {
+      await chmod(path.dirname(f.claimPath), 0o777);
+    }
+    await assert.rejects(reapExpiredTestClaims(f.project, { isInactive: inactive }), /Unsafe/);
+    if (process.platform === 'win32') {
+      execFileSync('icacls.exe', [path.dirname(f.claimPath), '/remove:g', '*S-1-1-0'], {
+        windowsHide: true,
+        stdio: 'pipe',
+      });
+    } else {
+      await chmod(path.dirname(f.claimPath), 0o700);
+    }
     const legacy = path.join(f.project, `.vona-test-claim-${runId}`);
     await mkdir(legacy);
     const warnings: string[] = [];