cabloy 5.1.216 → 5.1.218

package/scripts/testClaimCleanup.ts

@@ -1,8 +1,5 @@
 import { spawn } from 'node:child_process';
-import { randomBytes } from 'node:crypto';
-import { constants } from 'node:fs';
-import { lstat, open, readdir, rm, unlink } from 'node:fs/promises';
-import os from 'node:os';
+import { lstat, readdir, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -18,6 +15,11 @@ import {
   TEST_CLAIM_DIRECTORY,
   writeTestClaim,
 } from '../vona/packages-vona/vona-core/src/lib/core/testClaim.ts';
+import {
+  acquireTestClaimCleanupLock,
+  assertTestClaimPrivateDirectory,
+  deleteTestClaimFile,
+} from '../vona/packages-vona/vona-core/src/lib/core/testClaimFilesystem.ts';
 import { assertTestRunOwner } from '../vona/packages-vona/vona-core/src/lib/core/testIsolation.ts';
 
 export interface TestClaimCleanupSession {
@@ -52,24 +54,6 @@ export function parseTestClaimTtlSeconds(
   return Number(value);
 }
 
-async function assertSharedDirectory(directory: string, missingAllowed = true) {
-  assertTestClaimSafePath(directory, missingAllowed);
-  let stat;
-  try {
-    stat = await lstat(directory);
-  } catch (error) {
-    if (missingAllowed && (error as NodeJS.ErrnoException).code === 'ENOENT') return false;
-    throw error;
-  }
-  if (
-    !stat.isDirectory() ||
-    (stat.mode & 0o077) !== 0 ||
-    (process.getuid && stat.uid !== process.getuid())
-  ) {
-    throw new Error('Unsafe shared test claim directory');
-  }
-  return true;
-}
 async function exists(file: string) {
   try {
     await lstat(file);
@@ -84,7 +68,9 @@ async function validateLocalRoots(claim: TestClaimManifest) {
     assertTestClaimSafePath(local.path);
     if (!(await exists(local.path))) continue;
     if (local.stage === 'released') throw new Error('Released local test resource reappeared');
-    const marker = await lstat(path.join(local.path, '.vona-test-owner'));
+    const markerPath = path.join(local.path, '.vona-test-owner');
+    assertTestClaimSafePath(markerPath, false);
+    const marker = await lstat(markerPath);
     if (marker.isSymbolicLink() || !marker.isFile() || marker.nlink !== 1)
       throw new Error('Unsafe test owner marker');
     assertTestRunOwner(local.path, claim.runId);
@@ -97,7 +83,7 @@ export async function cleanTestClaim(
 ): Promise<TestClaimCleanupResult> {
   claimPath = path.resolve(claimPath);
   // An unsafe shared namespace is fatal to the invocation, not a skippable claim.
-  await assertSharedDirectory(path.dirname(claimPath), false);
+  await assertTestClaimPrivateDirectory(path.dirname(claimPath), false);
   const warn = options.warn ?? (() => {});
   const skip = (reason: string): TestClaimCleanupResult => {
     warn(`Retained test claim ${path.basename(claimPath)}: ${reason}`);
@@ -114,25 +100,15 @@ export async function cleanTestClaim(
   const lockPath = `${claimPath}.cleanup.lock`;
   let lock;
   try {
-    assertTestClaimSafePath(lockPath);
-    lock = await open(
-      lockPath,
-      constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW,
-      0o600,
-    );
+    lock = await acquireTestClaimCleanupLock(lockPath);
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === 'EEXIST')
       return skip('cleanup lock present; inspect manually, age never permits takeover');
     return skip('cannot acquire safe cleanup lock');
   }
-  const token = randomBytes(24).toString('hex');
   let session: TestClaimCleanupSession | undefined;
   let sequenceStarted = false;
   try {
-    await lock.writeFile(
-      `${JSON.stringify({ pid: process.pid, hostname: os.hostname(), startTime: String(Date.now() - process.uptime() * 1000), token })}\n`,
-    );
-    await lock.sync();
     // Re-read after locking; the runner must have closed its single inventory broker.
     claim = await loadTestClaim(claimPath);
     await validateLocalRoots(claim);
@@ -194,7 +170,7 @@ export async function cleanTestClaim(
     await writeTestClaim(claimPath, claim);
     // Validate once more before releasing the inventory, always last.
     await loadTestClaim(claimPath);
-    await unlink(claimPath);
+    await deleteTestClaimFile(claimPath);
     return { status: 'cleaned' };
   } catch {
     const reason = sequenceStarted
@@ -204,16 +180,9 @@ export async function cleanTestClaim(
     return { status: sequenceStarted ? 'failed' : 'skipped', reason };
   } finally {
     if (session) await session.close().catch(() => {});
-    await lock.close();
     // Do not remove a replacement lock. No automatic orphan-lock takeover.
     try {
-      const handle = await open(lockPath, constants.O_RDONLY | constants.O_NOFOLLOW);
-      try {
-        const value = JSON.parse(await handle.readFile('utf8'));
-        if (value.token === token) await unlink(lockPath);
-      } finally {
-        await handle.close();
-      }
+      await lock.release();
     } catch {
       warn(`Retained cleanup lock ${path.basename(lockPath)}: manual inspection required`);
     }
@@ -240,7 +209,7 @@ export async function reapExpiredTestClaims(
     if (legacyRun && !(await exists(path.join(directory, `${legacyRun[1]}.json`))))
       warn(`Legacy inventory-less test root retained: ${item.name}`);
   }
-  if (!(await assertSharedDirectory(directory))) return [];
+  if (!(await assertTestClaimPrivateDirectory(directory))) return [];
   const results: TestClaimCleanupResult[] = [];
   for (const name of await readdir(directory)) {
     if (name.endsWith('.cleanup.lock')) {

package/scripts/testClaimProcesses.test.ts

@@ -96,11 +96,90 @@ test('inactivity fails closed for active, reused, pending and uninspectable proc
   );
 });
 
+test('Windows job inactivity requires durable drainage and absence of the exact owner PID', async () => {
+  const owner = { pid: 100, startTime: 'owner-start', host: hostname() };
+  const registered = {
+    id: 'guardian',
+    role: 'guardian',
+    stage: 'registered' as const,
+    containment: 'windows-job' as const,
+    jobId: '69a52c48-6bc4-46ce-9655-b0379117ad61',
+    pid: 200,
+    startTime: '134000000000000000',
+    host: hostname(),
+  };
+  assert.equal(
+    (await isTestClaimInactive({ owner, processes: [registered] }, false, async () => [])).inactive,
+    false,
+  );
+  const drained = { ...registered, stage: 'drained' as const };
+  assert.equal(
+    (await isTestClaimInactive({ owner, processes: [drained] }, false, async () => [])).inactive,
+    true,
+  );
+  for (const [pid, reason] of [
+    [owner.pid, 'claim owner PID is still present'],
+    [drained.pid, 'registered Windows job owner is still present'],
+  ] as const) {
+    let inspections = 0;
+    const inactivity = await isTestClaimInactive(
+      { owner, processes: [drained] },
+      false,
+      async () => {
+        inspections++;
+        return [
+          {
+            pid,
+            startTime: 'different-created-time',
+            host: hostname(),
+            state: 'running',
+            args: '',
+          },
+        ];
+      },
+    );
+    assert.deepEqual(inactivity, { inactive: false, reason });
+    assert.equal(inspections, 1);
+  }
+  assert.equal(
+    (
+      await isTestClaimInactive(
+        { owner, processes: [{ ...drained, jobId: undefined }] },
+        false,
+        async () => [],
+      )
+    ).inactive,
+    false,
+  );
+  assert.equal(
+    (
+      await isTestClaimInactive(
+        { owner, processes: [{ ...drained, pgid: 200 }] },
+        false,
+        async () => [],
+      )
+    ).inactive,
+    false,
+  );
+  await assert.rejects(
+    isTestClaimInactive({ owner, processes: [drained] }, false, async () => {
+      throw new Error('native inspection unavailable');
+    }),
+    /native inspection unavailable/,
+  );
+});
+
 test('identifies the current process without publishing environment values', async () => {
   const identity = await inspectTestProcess(process.pid);
   assert.equal(identity.pid, process.pid);
-  assert.ok(identity.pgid > 0);
   assert.ok(identity.startTime);
   assert.ok(identity.host);
-  await assert.rejects(waitForTestProcessGroupExit(identity.pgid, 0), /did not drain/);
+  if (process.platform === 'win32') {
+    assert.equal(identity.pgid, undefined);
+    assert.match(identity.startTime, /^[1-9]\d+$/);
+    await assert.rejects(waitForTestProcessGroupExit(process.pid, 0), /unsupported/);
+  } else {
+    assert.ok(identity.pgid! > 0);
+    await assert.rejects(waitForTestProcessGroupExit(identity.pgid!, 0), /did not drain/);
+  }
 });

package/scripts/testClaimProcesses.ts

@@ -2,11 +2,16 @@ import { execFile } from 'node:child_process';
 import { hostname } from 'node:os';
 import { promisify } from 'node:util';
 
+import {
+  inspectWindowsProcess,
+  inspectWindowsProcesses,
+} from '../vona/packages-vona/vona-core/src/lib/core/testProcessWindowsNative.ts';
+
 const execFileAsync = promisify(execFile);
 
 export interface TestProcessIdentity {
   pid: number;
-  pgid: number;
+  pgid?: number;
   startTime: string;
   host: string;
 }
@@ -39,7 +44,7 @@ export function parseTestProcesses(output: string): TestProcessSnapshot[] {
 
 export async function inspectTestProcesses(): Promise<TestProcessSnapshot[]> {
   if (process.platform === 'win32') {
-    throw new Error('Isolated test process inspection requires POSIX');
+    throw new Error('Windows process inspection requires explicit owned PIDs');
   }
   const { stdout } = await execFileAsync(
     'ps',
@@ -50,6 +55,11 @@ export async function inspectTestProcesses(): Promise<TestProcessSnapshot[]> {
 }
 
 export async function inspectTestProcess(pid: number): Promise<TestProcessSnapshot> {
+  if (process.platform === 'win32') {
+    const item = await inspectWindowsProcess(pid);
+    if (!item) throw new Error('Cannot identify isolated test process');
+    return item;
+  }
   const item = (await inspectTestProcesses()).find(
     item => item.pid === pid && !item.state.startsWith('Z'),
   );
@@ -63,6 +73,8 @@ export interface TestClaimProcessRecord {
   stage: 'pending' | 'registered' | 'drained';
   pid?: number;
   pgid?: number;
+  containment?: 'windows-job';
+  jobId?: string;
   startTime?: string;
   host?: string;
   profilePath?: string;
@@ -74,12 +86,27 @@ export async function isTestClaimInactive(
     processes: TestClaimProcessRecord[];
   },
   allowCurrentOwner = false,
-  inspect: () => Promise<TestProcessSnapshot[]> = inspectTestProcesses,
+  inspect?: () => Promise<TestProcessSnapshot[]>,
 ): Promise<{ inactive: boolean; reason?: string }> {
   if (claim.owner.host !== hostname()) {
     return { inactive: false, reason: 'claim belongs to another or unidentified host' };
   }
-  const processes = (await inspect()).filter(item => !item.state.startsWith('Z'));
+  if (
+    !inspect &&
+    process.platform === 'win32' &&
+    claim.processes.some(item => item.containment !== 'windows-job')
+  ) {
+    return { inactive: false, reason: 'POSIX process ownership cannot be inspected on Windows' };
+  }
+  const snapshots = inspect
+    ? await inspect()
+    : process.platform === 'win32'
+      ? await inspectWindowsProcesses([
+          claim.owner.pid,
+          ...claim.processes.flatMap(item => (item.pid ? [item.pid] : [])),
+        ])
+      : await inspectTestProcesses();
+  const processes = snapshots.filter(item => !item.state.startsWith('Z'));
   const owner = processes.find(item => item.pid === claim.owner.pid);
   if (
     owner &&
@@ -91,17 +118,24 @@ export async function isTestClaimInactive(
     if (registered.stage === 'pending') {
       return { inactive: false, reason: 'process launch registration is incomplete' };
     }
-    if (
-      !registered.pid ||
-      !registered.pgid ||
-      !registered.startTime ||
-      registered.host !== hostname()
-    ) {
+    if (!registered.pid || !registered.startTime || registered.host !== hostname()) {
       return {
         inactive: false,
         reason: 'process identity is incomplete or belongs to another host',
       };
     }
+    if (registered.containment === 'windows-job') {
+      if (!registered.jobId || registered.pgid !== undefined || registered.stage !== 'drained') {
+        return { inactive: false, reason: 'Windows job drainage is unproven' };
+      }
+      if (processes.some(item => item.pid === registered.pid)) {
+        return { inactive: false, reason: 'registered Windows job owner is still present' };
+      }
+      continue;
+    }
+    if (!registered.pgid || registered.jobId !== undefined) {
+      return { inactive: false, reason: 'POSIX process group identity is incomplete' };
+    }
     if (processes.some(item => item.pid === registered.pid || item.pgid === registered.pgid)) {
       return { inactive: false, reason: 'registered process or group is still present' };
     }
@@ -116,6 +150,8 @@ export async function isTestClaimInactive(
 }
 
 export async function waitForTestProcessGroupExit(pgid: number, timeoutMs = 10_000) {
+  if (process.platform === 'win32')
+    throw new Error('POSIX browser process groups are unsupported on Windows');
   if (!Number.isSafeInteger(pgid) || pgid <= 0) throw new Error('Invalid isolated process group');
   const deadline = Date.now() + timeoutMs;
   while (true) {