cabloy 5.1.215 → 5.1.217

package/scripts/runIsolatedTest.test.ts

@@ -15,6 +15,7 @@ import { createServer } from 'node:http';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { test } from 'node:test';
+import { pathToFileURL } from 'node:url';
 
 import type { VonaApplication } from '../vona/packages-vona/vona-core/src/lib/core/application.ts';
 
@@ -32,10 +33,14 @@ import {
   createTestRunId,
   getUnitTestCommands,
   reserveTestRun,
+  resolveNpmCli,
   resolveCabloyEdition,
   ROOT_DIR,
   runIsolatedProcess,
   runIsolatedTest,
+  startOwnedProcess,
+  requestIsolatedVonaStop,
+  withIsolatedVona,
   verifyReadyProof,
   waitForReady,
   withIsolatedRun,
@@ -65,7 +70,11 @@ test('public test scripts delegate to the isolated runner without recursion', ()
 
   const commands = getUnitTestCommands(['--coverage', '--ci', 'src/test/example.test.ts']);
   assert.deepEqual(commands, [
-    { command: 'npm', args: ['run', 'prerun'], cwd: resolve(ROOT_DIR, 'vona') },
+    {
+      command: process.execPath,
+      args: [resolveNpmCli(), 'run', 'prerun'],
+      cwd: resolve(ROOT_DIR, 'vona'),
+    },
     {
       command: process.execPath,
       args: [
@@ -85,6 +94,72 @@ test('public test scripts delegate to the isolated runner without recursion', ()
   ]);
 });
 
+test('resolves the npm JavaScript entrypoint without a command shell', () => {
+  const root = mkdtempSync(join(realpathSync(tmpdir()), 'cabloy npm argv '));
+  try {
+    const cli = join(root, 'node_modules', 'npm', 'bin', 'npm-cli.js');
+    mkdirSync(join(root, 'node_modules', 'npm', 'bin'), { recursive: true });
+    writeFileSync(cli, '');
+    const executable = join(root, process.platform === 'win32' ? 'node.exe' : 'node');
+    assert.equal(resolveNpmCli({}, executable), realpathSync(cli));
+    assert.equal(resolveNpmCli({ npm_execpath: cli }, '/missing/node'), realpathSync(cli));
+    assert.throws(
+      () => resolveNpmCli({ npm_execpath: join(root, 'pnpm.cjs') }, join(root, 'missing', 'node')),
+      /Cannot resolve npm CLI/,
+    );
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test(
+  'public npm test entrypoint can be invoked from CMD and PowerShell',
+  {
+    skip: process.platform !== 'win32' ? 'Native Windows shells are required' : false,
+  },
+  () => {
+    const root = mkdtempSync(join(realpathSync(tmpdir()), 'cabloy shell entry '));
+    try {
+      writeFileSync(join(root, '__CABLOY_BASIC__'), '');
+      mkdirSync(join(root, 'vona'));
+      const entry = resolve(ROOT_DIR, 'scripts/runIsolatedTest.ts');
+      writeFileSync(
+        join(root, 'package.json'),
+        JSON.stringify({
+          private: true,
+          scripts: { test: `node "${entry}" unit` },
+        }),
+      );
+      for (const [command, args] of [
+        ['cmd.exe', ['/d', '/s', '/c', 'npm run test -- --ci']],
+        [
+          'pwsh.exe',
+          [
+            '-NoLogo',
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            'npm run test -- --ci; exit $LASTEXITCODE',
+          ],
+        ],
+      ] as const) {
+        const result = spawnSync(command, [...args], {
+          cwd: root,
+          env: { ...process.env, E2E_BASE_URL: 'https://example.invalid' },
+          encoding: 'utf8',
+          timeout: 30_000,
+        });
+        assert.equal(result.error, undefined);
+        assert.notEqual(result.status, 0);
+        assert.match(result.stderr, /E2E_BASE_URL is unsupported/);
+        assert.equal(existsSync(join(root, 'vona', '.vona-test-claim')), false);
+      }
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  },
+);
+
 test('accepts either Cabloy edition and rejects ambiguous or missing markers', () => {
   const root = mkdtempSync(join(tmpdir(), 'cabloy-run-edition-'));
   const basicMarker = join(root, '__CABLOY_BASIC__');
@@ -132,12 +207,12 @@ test('creates exclusive manifest claims and refuses stale or symlinked roots', a
     assert.equal(readFileSync(join(staleRoot, 'business-data'), 'utf8'), 'keep');
     assert.equal(existsSync(join(staleRoot, '.vona-test-owner')), false);
     const linkedRoot = join(vonaDir, `.vona-test-${id}`);
-    symlinkSync(staleRoot, linkedRoot);
+    symlinkSync(staleRoot, linkedRoot, process.platform === 'win32' ? 'junction' : 'dir');
     assert.throws(() => createOwned(linkedRoot, id), /already exists/);
     assert.equal(readFileSync(join(staleRoot, 'business-data'), 'utf8'), 'keep');
 
     const linked = join(root, 'linked');
-    symlinkSync(vonaDir, linked);
+    symlinkSync(vonaDir, linked, process.platform === 'win32' ? 'junction' : 'dir');
     await assert.rejects(reserveTestRun(linked, '20261014010204-d4e5f6a7'), /Unsafe/);
     assert.equal(
       existsSync(join(vonaDir, '.vona-test-claim', '20261014010204-d4e5f6a7.json')),
@@ -294,7 +369,7 @@ test('rejects external E2E targets before creating run directories', async () =>
 
 test('resolves distinct run paths and rejects invalid identity without touching dev paths', () => {
   const script = `
-    import { resolveVonaLocalPaths, getTestAppName } from ${JSON.stringify(isolationSource)};
+    import { resolveVonaLocalPaths, getTestAppName } from ${JSON.stringify(pathToFileURL(isolationSource).href)};
     const project = '/project/vona';
     const a = resolveVonaLocalPaths(project, 'test', '20261014010203-a1b2c3d4');
     const b = resolveVonaLocalPaths(project, 'test', '20261014010203-d4e5f6a7');
@@ -316,7 +391,7 @@ test('owner checks reject unowned paths and symlinked leaves', () => {
   const root = mkdtempSync(join(tmpdir(), 'cabloy-test-isolation-'));
   const id = '20261014010203-a1b2c3d4';
   const script = `
-    import { assertTestRunOwner } from ${JSON.stringify(isolationSource)};
+    import { assertTestRunOwner } from ${JSON.stringify(pathToFileURL(isolationSource).href)};
     const [unowned, linked] = process.argv.slice(1);
     try { assertTestRunOwner(unowned, ${JSON.stringify(id)}); process.exit(1); } catch {}
     try { assertTestRunOwner(linked, ${JSON.stringify(id)}); process.exit(2); } catch {}
@@ -328,7 +403,7 @@ test('owner checks reject unowned paths and symlinked leaves', () => {
     const unowned = join(root, 'unowned');
     mkdirSync(unowned);
     const linked = join(root, 'linked');
-    symlinkSync(owned, linked);
+    symlinkSync(owned, linked, process.platform === 'win32' ? 'junction' : 'dir');
     const result = spawnSync(
       process.execPath,
       ['--input-type=module', '-e', script, unowned, linked],
@@ -345,13 +420,13 @@ test('owner checks reject unowned paths and symlinked leaves', () => {
 });
 
 test('waits for descendants before reporting a successful child exit', async () => {
-  if (process.platform === 'win32') return;
   const root = mkdtempSync(join(tmpdir(), 'cabloy-process-group-'));
   const flag = join(root, 'descendant-finished');
   try {
     const script = `
       import { spawn } from 'node:child_process';
-      const child = spawn(process.execPath, ['-e', 'setTimeout(() => require("node:fs").writeFileSync(process.argv[1], "done"), 400) ', process.argv[1]], { stdio: 'ignore' });
+      // Avoid libuv's parent-owned kill-on-close Job on Windows; the outer Job still owns this child.
+      const child = spawn(process.execPath, ['-e', 'setTimeout(() => require("node:fs").writeFileSync(process.argv[1], "done"), 400)', process.argv[1]], { stdio: 'ignore', detached: process.platform === 'win32' });
       child.unref();
     `;
     await runIsolatedProcess(
@@ -367,13 +442,13 @@ test('waits for descendants before reporting a successful child exit', async ()
 });
 
 test('a guardian waits for an inherited-group descendant before success', async () => {
-  if (process.platform === 'win32') return;
   const root = mkdtempSync(join(resolve(ROOT_DIR, 'vona'), '.e2e-group-test-'));
   const flag = join(root, 'server-finished');
   try {
     const script = `
       import { spawn } from 'node:child_process';
-      const child = spawn(process.execPath, ['-e', 'setTimeout(() => require("node:fs").writeFileSync(process.argv[1], "done"), 400)', process.argv[1]], { stdio: 'ignore' });
+      // Preserve the inherited POSIX group, but avoid libuv's kill-on-close Job on Windows.
+      const child = spawn(process.execPath, ['-e', 'setTimeout(() => require("node:fs").writeFileSync(process.argv[1], "done"), 400)', process.argv[1]], { stdio: 'ignore', detached: process.platform === 'win32' });
       child.unref();
     `;
     await runIsolatedProcess(
@@ -408,7 +483,13 @@ test('managed guardians journal registration and drainage for successful and fai
     for (const item of claim.processes) {
       assert.equal(item.stage, 'drained');
       assert.equal(item.role, 'guardian');
-      assert.equal(item.pid, item.pgid);
+      if (process.platform === 'win32') {
+        assert.equal(item.containment, 'windows-job');
+        assert.equal(item.pgid, undefined);
+        assert.ok(item.jobId);
+      } else {
+        assert.equal(item.pid, item.pgid);
+      }
       assert.ok(item.host);
       assert.ok(item.startTime);
     }
@@ -419,20 +500,26 @@ test('managed guardians journal registration and drainage for successful and fai
 });
 
 test('does not report success when a child exits nonzero', async () => {
-  if (process.platform === 'win32') return;
   await assert.rejects(
     runIsolatedProcess(process.execPath, ['-e', 'process.exit(7)'], ROOT_DIR, { ...process.env }),
     /Isolated test exited: 7/,
   );
 });
 
-test('interrupts an owned group and waits for its graceful child shutdown', async () => {
-  if (process.platform === 'win32') return;
-  const root = mkdtempSync(join(resolve(ROOT_DIR, 'vona'), '.guardian-interrupt-test-'));
-  const readyFile = join(root, 'ready');
-  const stoppedFile = join(root, 'stopped');
-  try {
-    const script = `
+test(
+  'interrupts an owned group and waits for its graceful child shutdown',
+  {
+    skip:
+      process.platform === 'win32'
+        ? 'Windows cancellation terminates the Job; POSIX graceful signals are not supported'
+        : false,
+  },
+  async () => {
+    const root = mkdtempSync(join(resolve(ROOT_DIR, 'vona'), '.guardian-interrupt-test-'));
+    const readyFile = join(root, 'ready');
+    const stoppedFile = join(root, 'stopped');
+    try {
+      const script = `
       import { writeFileSync } from 'node:fs';
       writeFileSync(process.argv[1], 'ready');
       process.on('SIGINT', () => {
@@ -443,24 +530,25 @@ test('interrupts an owned group and waits for its graceful child shutdown', asyn
       });
       setInterval(() => {}, 1000);
     `;
-    const pending = runIsolatedProcess(
-      process.execPath,
-      ['--input-type=module', '-e', script, readyFile, stoppedFile],
-      ROOT_DIR,
-      { ...process.env },
-    );
-    const deadline = Date.now() + 5000;
-    while (!existsSync(readyFile) && Date.now() < deadline) {
-      await new Promise(resolvePromise => setTimeout(resolvePromise, 50));
+      const pending = runIsolatedProcess(
+        process.execPath,
+        ['--input-type=module', '-e', script, readyFile, stoppedFile],
+        ROOT_DIR,
+        { ...process.env },
+      );
+      const deadline = Date.now() + 5000;
+      while (!existsSync(readyFile) && Date.now() < deadline) {
+        await new Promise(resolvePromise => setTimeout(resolvePromise, 50));
+      }
+      assert.ok(existsSync(readyFile));
+      process.emit('SIGINT');
+      await assert.rejects(pending, /Isolated test exited/);
+      assert.ok(existsSync(stoppedFile));
+    } finally {
+      rmSync(root, { recursive: true, force: true });
     }
-    assert.ok(existsSync(readyFile));
-    process.emit('SIGINT');
-    await assert.rejects(pending, /Isolated test exited/);
-    assert.ok(existsSync(stoppedFile));
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
+  },
+);
 
 test('rejects merged paths, Redis prefixes, and database overrides before cleanup', () => {
   const root = mkdtempSync(join(resolve(ROOT_DIR, 'vona'), '.isolation-guard-test-'));
@@ -535,3 +623,282 @@ test('rejects merged paths, Redis prefixes, and database overrides before cleanu
     rmSync(root, { recursive: true, force: true });
   }
 });
+
+function shutdownFixture(
+  options: {
+    readyFailure?: boolean;
+    requestFailure?: boolean;
+    fallbackFailure?: boolean;
+    drainageFailure?: boolean;
+    earlyExit?: boolean;
+    hang?: boolean;
+    code?: number;
+  } = {},
+) {
+  const events: string[] = [];
+  let finish!: (result: import('./runIsolatedTest.ts').GuardianResult) => void;
+  const result = {
+    type: 'drained' as const,
+    failed: !!options.drainageFailure,
+    result: { code: options.code ?? 0, signal: null },
+  };
+  const waited = new Promise<import('./runIsolatedTest.ts').GuardianResult>(resolve => {
+    finish = resolve;
+  });
+  const server = {
+    wait: () => waited,
+    stop: async () => {
+      events.push('force-stop');
+      if (options.fallbackFailure) throw new Error('fallback failed');
+      finish(result);
+      return result;
+    },
+  };
+  const dependencies = {
+    platform: 'win32' as const,
+    shutdownTimeoutMs: 30,
+    start: async () => {
+      events.push('start');
+      return server;
+    },
+    ready: async () => {
+      events.push('ready');
+      if (options.earlyExit) {
+        finish(result);
+        await Promise.resolve();
+      }
+      if (options.readyFailure) throw new Error('readiness failed');
+    },
+    requestStop: async () => {
+      events.push('cooperative-stop');
+      if (options.requestFailure) throw new Error('authorization failed');
+      if (!options.hang) finish(result);
+    },
+  };
+  return { dependencies, events, server };
+}
+
+test('Windows verified-readiness teardown requests cooperative shutdown then waits without force-stop', async () => {
+  const f = shutdownFixture();
+  const before = process.listenerCount('SIGINT');
+  assert.equal(
+    await withIsolatedVona(
+      1234,
+      { VONA_TEST_RUN_ID: '20261014010203-a1b2c3d4' },
+      async () => {
+        f.events.push('callback');
+        return 'done';
+      },
+      f.dependencies,
+    ),
+    'done',
+  );
+  assert.deepEqual(f.events, ['start', 'ready', 'callback', 'cooperative-stop']);
+  assert.equal(process.listenerCount('SIGINT'), before);
+});
+
+for (const options of [
+  { requestFailure: true },
+  { hang: true },
+  { drainageFailure: true },
+  { code: 1 },
+]) {
+  test(`Windows cooperative failure always force-stops and fails (${JSON.stringify(options)})`, async () => {
+    const f = shutdownFixture(options);
+    await assert.rejects(withIsolatedVona(1234, {}, async () => {}, f.dependencies));
+    assert.deepEqual(f.events, ['start', 'ready', 'cooperative-stop', 'force-stop']);
+  });
+}
+
+test('Windows readiness failure or early exit never requests cooperative shutdown', async () => {
+  for (const options of [{ readyFailure: true }, { earlyExit: true }]) {
+    const f = shutdownFixture(options);
+    await assert.rejects(withIsolatedVona(1234, {}, async () => {}, f.dependencies));
+    assert.deepEqual(f.events, ['start', 'ready', 'force-stop']);
+  }
+});
+
+test('Windows interruption is failure and uses force-stop, not authenticated normal shutdown', async () => {
+  const f = shutdownFixture();
+  await assert.rejects(
+    withIsolatedVona(
+      1234,
+      {},
+      async () => {
+        process.emit('SIGINT');
+      },
+      f.dependencies,
+    ),
+    /interrupted/,
+  );
+  assert.equal(f.events.includes('cooperative-stop'), false);
+  assert.ok(f.events.includes('force-stop'));
+});
+
+test('callback, cooperative shutdown and fallback errors all survive', async () => {
+  const f = shutdownFixture({ requestFailure: true, fallbackFailure: true });
+  await assert.rejects(
+    withIsolatedVona(
+      1234,
+      {},
+      async () => {
+        throw new Error('callback failed');
+      },
+      f.dependencies,
+    ),
+    (error: unknown) => {
+      assert.ok(error instanceof AggregateError);
+      assert.equal(error.errors[0].message, 'callback failed');
+      assert.ok(error.errors[1] instanceof AggregateError);
+      assert.deepEqual(
+        error.errors[1].errors.map((e: Error) => e.message),
+        ['authorization failed', 'fallback failed'],
+      );
+      return true;
+    },
+  );
+});
+
+test('callback error survives a clean Windows cooperative shutdown', async () => {
+  const f = shutdownFixture();
+  await assert.rejects(
+    withIsolatedVona(
+      1234,
+      {},
+      async () => {
+        throw new Error('callback failed');
+      },
+      f.dependencies,
+    ),
+    /callback failed/,
+  );
+  assert.deepEqual(f.events, ['start', 'ready', 'cooperative-stop']);
+});
+
+test('POSIX teardown preserves the existing stop path', async () => {
+  const f = shutdownFixture();
+  await withIsolatedVona(1234, {}, async () => {}, { ...f.dependencies, platform: 'darwin' });
+  assert.deepEqual(f.events, ['start', 'ready', 'force-stop']);
+});
+
+test('shutdown HTTP request uses distinct nonce-bound domains and rejects invalid acknowledgments or redirects', async () => {
+  const key = 'a'.repeat(64);
+  const runId = '20261014010203-a1b2c3d4';
+  let mode = 'ok';
+  let requests = 0;
+  const listener = createServer((req, res) => {
+    requests++;
+    assert.equal(req.method, 'POST');
+    assert.equal(req.url, '/health/test-stop');
+    const nonce = req.headers['x-vona-test-stop-nonce'];
+    assert.match(String(nonce), /^[a-f0-9]{32}$/);
+    const payload = `${runId}\nPOST\n/health/test-stop\n${nonce}`;
+    const sign = (value: string) => createHmac('sha256', key).update(value).digest('hex');
+    assert.equal(
+      req.headers['x-vona-test-stop-authorization'],
+      sign(`vona-test-stop-request-v1\n${payload}`),
+    );
+    assert.equal(JSON.stringify(req.headers).includes(key), false);
+    if (mode === 'timeout') return;
+    if (mode === 'redirect') {
+      res.writeHead(307, { location: '/health/test-stop' });
+      res.end();
+      return;
+    }
+    const proof =
+      mode === 'ready-proof' ? sign(String(nonce)) : sign(`vona-test-stop-ack-v1\n${payload}`);
+    res.writeHead(mode === 'refuse' ? 403 : 200, {
+      'x-vona-test-stop-proof': mode === 'bad-proof' ? 'f'.repeat(64) : proof,
+    });
+    res.end(JSON.stringify({ status: mode === 'bad-body' ? 'ok' : 'stopping' }));
+  });
+  await new Promise<void>(resolve => listener.listen(0, '127.0.0.1', resolve));
+  const address = listener.address();
+  assert.ok(address && typeof address !== 'string');
+  try {
+    await requestIsolatedVonaStop(address.port, runId, key);
+    for (mode of ['bad-proof', 'ready-proof', 'refuse', 'bad-body', 'redirect', 'timeout']) {
+      const before = requests;
+      await assert.rejects(requestIsolatedVonaStop(address.port, runId, key, 40));
+      assert.equal(requests, before + 1);
+    }
+  } finally {
+    listener.closeAllConnections();
+    await new Promise<void>((resolve, reject) =>
+      listener.close(error => (error ? reject(error) : resolve())),
+    );
+  }
+});
+
+test(
+  'cooperative worker exit retains native guardian full drainage proof (Windows Job on Windows)',
+  { timeout: 30_000 },
+  async () => {
+    const root = mkdtempSync(join(realpathSync(tmpdir()), 'cabloy cooperative worker '));
+    const marker = join(root, 'closed');
+    const descendant = join(root, 'descendant');
+    const port = await allocateTestPort();
+    const workerUrl = new URL(
+      '../vona/packages-vona/vona-core/src/lib/framework/processWorker.ts',
+      import.meta.url,
+    ).href;
+    const source = `
+    import { createServer } from 'node:http';
+    import { createHmac } from 'node:crypto';
+    import { spawn } from 'node:child_process';
+    import { writeFileSync } from 'node:fs';
+    import { registerHooks } from 'node:module';
+    const workerUrl = ${JSON.stringify(workerUrl)};
+    globalThis.closeMock = async () => {
+      await new Promise(resolve => setTimeout(resolve, 50));
+      writeFileSync(${JSON.stringify(marker)}, 'closed');
+    };
+    registerHooks({ resolve(specifier, context, nextResolve) {
+      if (context.parentURL === workerUrl) {
+        const source = {
+          '@cabloy/utils': 'export async function catchError(fn) { try { return [await fn()]; } catch (error) { return [undefined, error]; } } export function catchErrorSync(fn) { try { return [fn()]; } catch (error) { return [undefined, error]; } }',
+          './useApp.ts': 'export const closeApp = globalThis.closeMock; export function useApp() {}',
+        }[specifier];
+        if (source) return { url: 'data:text/javascript,' + encodeURIComponent(source), shortCircuit: true };
+      }
+      return nextResolve(specifier, context);
+    } });
+    const { closeProcessWorker } = await import(workerUrl);
+    const sign = payload => createHmac('sha256', process.env.VONA_TEST_READY_KEY).update(payload).digest('hex');
+    const listener = createServer((req, res) => {
+      if (req.url === '/health/ready') {
+        res.writeHead(200, { 'x-vona-test-proof': sign(String(req.headers['x-vona-test-challenge'])) });
+        res.end(JSON.stringify({ status: 'ok' }));
+        return;
+      }
+      const payload = process.env.VONA_TEST_RUN_ID + '\\nPOST\\n/health/test-stop\\n' + req.headers['x-vona-test-stop-nonce'];
+      if (req.method !== 'POST' || req.url !== '/health/test-stop' || req.headers['x-vona-test-stop-authorization'] !== sign('vona-test-stop-request-v1\\n' + payload)) {
+        res.writeHead(403); res.end(); return;
+      }
+      const child = spawn(process.execPath, ['-e', 'setTimeout(() => require("node:fs").writeFileSync(process.argv[1], "done"), 300)', ${JSON.stringify(descendant)}], { stdio: 'ignore', detached: process.platform === 'win32' });
+      child.unref();
+      res.writeHead(200, { 'x-vona-test-stop-proof': sign('vona-test-stop-ack-v1\\n' + payload) });
+      res.once('finish', () => void closeProcessWorker());
+      res.end(JSON.stringify({ status: 'stopping' }));
+    });
+    listener.listen(${port}, '127.0.0.1');
+  `;
+    try {
+      await withIsolatedVona(
+        port,
+        { ...process.env, META_MODE: 'test', VONA_TEST_RUN_ID: '20261014010203-a1b2c3d4' },
+        async () => {},
+        {
+          platform: 'win32',
+          start: (_command, _args, cwd, env) =>
+            startOwnedProcess(process.execPath, ['--input-type=module', '-e', source], cwd, env),
+          ready: waitForReady,
+        },
+      );
+      assert.equal(readFileSync(marker, 'utf8'), 'closed');
+      assert.equal(readFileSync(descendant, 'utf8'), 'done');
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  },
+);