cabloy 5.1.216 → 5.1.218

package/scripts/testProcessGuardianWindows.ts

@@ -0,0 +1,155 @@
+import { randomUUID } from 'node:crypto';
+
+import type { GuardianResult, OwnedProcess } from './runIsolatedTest.ts';
+
+import {
+  hasTestClaimTransport,
+  registerTestClaimWindowsJobVerifier,
+  sendTestClaimEvent,
+  TEST_CLAIM_WINDOWS_GUARDIAN_ENV,
+} from '../vona/packages-vona/vona-core/src/lib/core/testClaim.ts';
+import {
+  createWindowsNativeJob,
+  inspectWindowsProcess,
+} from '../vona/packages-vona/vona-core/src/lib/core/testProcessWindowsNative.ts';
+
+/** Windows test containment. The external PS7 helper alone owns the native Job. */
+export async function startWindowsOwnedProcess(
+  command: string,
+  args: string[],
+  cwd: string,
+  env: NodeJS.ProcessEnv,
+  nativeOutput?: Parameters<typeof createWindowsNativeJob>[1],
+): Promise<OwnedProcess> {
+  if (process.platform !== 'win32')
+    throw new Error('Windows owned processes require native Windows and PowerShell 7 (pwsh)');
+  const registration = {
+    id: randomUUID(),
+    role: 'guardian',
+    stage: 'pending' as const,
+    containment: 'windows-job' as const,
+    jobId: randomUUID(),
+  };
+  // Write-ahead ACK must precede even spawning the native owner. Registration failures
+  // deliberately leave pending records; absence of a helper is not drainage evidence.
+  await sendTestClaimEvent(env, { type: 'process', process: registration });
+  const childEnv = { ...env };
+  for (const key of Object.keys(childEnv)) {
+    if (key.toUpperCase() === TEST_CLAIM_WINDOWS_GUARDIAN_ENV) delete childEnv[key];
+  }
+  childEnv[TEST_CLAIM_WINDOWS_GUARDIAN_ENV] = registration.id;
+  const native = await createWindowsNativeJob(
+    {
+      jobId: registration.jobId,
+      command,
+      args,
+      cwd,
+      env: childEnv,
+    },
+    nativeOutput,
+  );
+  let removeVerifier: (() => void) | undefined;
+  let stopping = false;
+  const interrupt = () => {
+    stopping = true;
+    native.stop();
+  };
+  process.on('SIGINT', interrupt);
+  process.on('SIGTERM', interrupt);
+  const deadline = setTimeout(interrupt, 30_000);
+  try {
+    const identity = await native.ready;
+    const inspected = await inspectWindowsProcess(identity.pid);
+    if (
+      !inspected ||
+      inspected.startTime !== identity.startTime ||
+      inspected.host !== identity.host
+    ) {
+      throw new Error('Windows native helper identity changed before durable registration');
+    }
+    const registered = {
+      ...registration,
+      stage: 'registered' as const,
+      pid: identity.pid,
+      startTime: identity.startTime,
+      host: identity.host,
+    };
+    await sendTestClaimEvent(env, { type: 'process', process: registered });
+    if (hasTestClaimTransport(env)) {
+      removeVerifier = await registerTestClaimWindowsJobVerifier(env, registered, async target => {
+        if (stopping || target.host !== identity.host) return false;
+        return await native.contains(target);
+      });
+    }
+    if (stopping) throw new Error('Windows isolated process startup interrupted');
+    // Only a successful durable registered ACK can authorize native CreateProcessW.
+    native.authorize();
+    await native.started;
+    if (stopping) throw new Error('Windows isolated process startup interrupted');
+    const completed = native
+      .wait()
+      .then(async (result): Promise<GuardianResult> => {
+        // wait() already verified BOTH native active0/root-exit proof and successful
+        // helper process exit. Helper crashes never reach this claim transition.
+        await sendTestClaimEvent(env, {
+          type: 'process',
+          process: {
+            ...registration,
+            stage: 'drained',
+            pid: identity.pid,
+            startTime: identity.startTime,
+            host: identity.host,
+          },
+        });
+        return { ...result, failed: result.failed || stopping };
+      })
+      .finally(() => removeVerifier?.());
+    void completed.catch(() => {});
+    return {
+      wait: () => completed,
+      stop: async () => {
+        stopping = true;
+        native.stop();
+        const timeout = new Promise<never>((_, reject) => {
+          const timer = setTimeout(
+            () => reject(new Error('Windows isolated Job did not prove shutdown in time')),
+            25_000,
+          );
+          timer.unref();
+          void completed.finally(() => clearTimeout(timer)).catch(() => {});
+        });
+        const result = await Promise.race([completed, timeout]);
+        return { ...result, failed: true };
+      },
+    };
+  } catch (error) {
+    removeVerifier?.();
+    native.stop();
+    try {
+      await Promise.race([
+        native.wait(),
+        new Promise<never>((_, reject) => {
+          const timer = setTimeout(
+            () => reject(new Error('Windows isolated helper did not finish after startup failure')),
+            25_000,
+          );
+          timer.unref();
+          void native
+            .wait()
+            .finally(() => clearTimeout(timer))
+            .catch(() => {});
+        }),
+      ]);
+    } catch (shutdownError) {
+      throw new AggregateError(
+        [error, shutdownError],
+        'Windows isolated process startup failed; claim retained',
+      );
+    }
+    throw error;
+  } finally {
+    clearTimeout(deadline);
+    process.off('SIGINT', interrupt);
+    process.off('SIGTERM', interrupt);
+  }
+}

package/vona/packages-cli/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli",
-  "version": "1.1.164",
+  "version": "1.1.165",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli",
   "keywords": [

package/vona/packages-cli/cli-set-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli-set-api",
-  "version": "1.1.162",
+  "version": "1.1.163",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [

package/vona/packages-cli/cli-set-api/src/lib/bean/cli.bin.build.ts

@@ -298,7 +298,10 @@ export class CliBinBuild extends BeanCliBase {
       );
     }
     const inputOptions: RollupOptions = {
-      input: path.join(projectPath, '.vona/bootstrap.ts'),
+      input: {
+        bootstrap: path.join(projectPath, '.vona/bootstrap.ts'),
+        app: path.join(projectPath, '.vona/app.ts'),
+      },
       plugins,
       external: Object.keys(externals),
       onLog: (level: LogLevel, log: RollupLog, defaultHandler: LogOrStringHandler) => {

package/vona/packages-cli/cli-set-api/test/binBuildEntries.test.ts

@@ -0,0 +1,159 @@
+import compileTemplate from 'lodash/template.js';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+
+const buildUrl = new URL('../src/lib/bean/cli.bin.build.ts', import.meta.url).href;
+const rollupUrl = import.meta.resolve('rollup');
+
+// Exercise the real _rollup and Rollup writer, isolating CLI setup and heavyweight plugins.
+// Template collaborators are virtual modules: no application, environment files, or listeners.
+const source = `
+  import assert from 'node:assert/strict';
+  import { realpathSync } from 'node:fs';
+  import { registerHooks } from 'node:module';
+  import { join } from 'node:path';
+  import { pathToFileURL } from 'node:url';
+  import { rollup as realRollup } from ${JSON.stringify(rollupUrl)};
+  const buildUrl = ${JSON.stringify(buildUrl)};
+  const projectPath = realpathSync(process.argv[1]);
+  const outDir = join(projectPath, 'dist/normal');
+  const modules = {
+    './env.ts': 'export default { fixture: "env" };',
+    './modules-meta.ts': 'export default { fixture: "modulesMeta" };',
+    './config.ts': 'export default { fixture: "config" };',
+    '../src/backend/config/locales.ts': 'export default { en: { fixture: "locale" } };',
+    '../src/backend/config/monkey.ts': 'export class AppMonkey {}',
+  };
+  globalThis.fixturePlugin = {
+    name: 'fixture-collaborators',
+    resolveId(id) {
+      if (Object.hasOwn(modules, id)) return '\\0fixture:' + id;
+    },
+    load(id) {
+      if (id.startsWith('\\0fixture:')) return modules[id.slice('\\0fixture:'.length)];
+    },
+  };
+  let builds = 0;
+  globalThis.rollupMock = async options => {
+    builds++;
+    assert.deepEqual(options.input, {
+      bootstrap: join(projectPath, '.vona/bootstrap.ts'),
+      app: join(projectPath, '.vona/app.ts'),
+    });
+    return realRollup(options);
+  };
+  const mocks = {
+    '@cabloy/cli': 'export class BeanCliBase {}',
+    'rollup': 'export const rollup = globalThis.rollupMock;',
+    '@rollup/plugin-node-resolve': 'export default () => globalThis.fixturePlugin;',
+    '../utils.ts':
+      'export function generateConfigDefine() { return {}; }' +
+      'export function getAbsolutePathOfModule(id) { return id; }' +
+      'export function getOutDir() { throw new Error("Unexpected output lookup"); }' +
+      'export function getOutReleasesDir() { throw new Error("Unexpected release lookup"); }',
+    './toolsBin/generateVonaMeta.ts':
+      'export function generateVonaMeta() { throw new Error("Unexpected app generation"); }',
+  };
+  const calls = globalThis.calls = [];
+  const createdApp = globalThis.createdApp = { fixture: 'createdApp' };
+  const bootstrapResult = globalThis.bootstrapResult = Promise.resolve({ fixture: 'bootstrap' });
+  registerHooks({
+    resolve(specifier, context, nextResolve) {
+      let mock;
+      if (context.parentURL === buildUrl) {
+        mock = mocks[specifier];
+        if (!mock && specifier.startsWith('@rollup/plugin-')) {
+          mock = 'export default () => ({ name: "fixture-noop" });';
+        }
+      }
+      if (specifier === 'vona' && context.parentURL?.startsWith(pathToFileURL(outDir + '/').href)) {
+        mock =
+          'export async function createApp(options) {' +
+          '  globalThis.calls.push(["createApp", options]); return globalThis.createdApp;' +
+          '}' +
+          'export function bootstrap(options) {' +
+          '  globalThis.calls.push(["bootstrap", options]); return globalThis.bootstrapResult;' +
+          '}';
+      }
+      if (mock) return { url: 'data:text/javascript,' + encodeURIComponent(mock), shortCircuit: true };
+      return nextResolve(specifier, context);
+    },
+  });
+  const { CliBinBuild } = await import(buildUrl);
+  const cli = Object.create(CliBinBuild.prototype);
+  await cli._rollup(projectPath, {}, {
+    modules: {
+      fixture: {
+        package: {
+          dependencies: { vona: '0.0.0-fixture' },
+          vonaModule: { bundle: { externals: ['vona'] } },
+        },
+      },
+    },
+  }, outDir);
+  assert.equal(builds, 1, 'must run the real _rollup input configuration');
+  assert.deepEqual(calls, [], 'building must not execute either entry');
+
+  const app = await import(pathToFileURL(join(outDir, 'app.js')).href);
+  assert.equal(typeof app.createSingleApp, 'function');
+  assert.deepEqual(calls, [], 'importing app.js must neither create nor bootstrap an app');
+  assert.equal(await app.createSingleApp(), createdApp);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0][0], 'createApp');
+  const options = calls[0][1];
+  assert.deepEqual(Object.keys(options).sort(), ['AppMonkey', 'config', 'env', 'locales', 'modulesMeta']);
+  assert.deepEqual(options.env, { fixture: 'env' });
+  assert.equal(options.AppMonkey.name, 'AppMonkey');
+  assert.deepEqual((await options.modulesMeta()).default, { fixture: 'modulesMeta' });
+  assert.deepEqual((await options.config()).default, { fixture: 'config' });
+  assert.deepEqual((await options.locales()).default, { en: { fixture: 'locale' } });
+
+  const bootstrap = await import(pathToFileURL(join(outDir, 'bootstrap.js')).href);
+  assert.equal(calls.length, 2, 'importing bootstrap.js must eagerly bootstrap once');
+  assert.equal(calls[1][0], 'bootstrap');
+  assert.equal(bootstrap.appBootstrap, bootstrapResult);
+  const bootstrapOptions = calls[1][1];
+  assert.deepEqual(Object.keys(bootstrapOptions).sort(), Object.keys(options).sort());
+  assert.equal(bootstrapOptions.env, options.env);
+  assert.equal(bootstrapOptions.AppMonkey, options.AppMonkey);
+  for (const key of ['modulesMeta', 'config', 'locales']) {
+    assert.equal(await bootstrapOptions[key](), await options[key](), key + ' must load the same module');
+  }
+`;
+
+test('production build emits a lazy app factory alongside the eager bootstrap entry', () => {
+  const projectPath = mkdtempSync(join(tmpdir(), 'vona-bin-build-entries-'));
+  try {
+    mkdirSync(join(projectPath, '.vona'));
+    writeFileSync(join(projectPath, 'package.json'), JSON.stringify({ type: 'module' }));
+    for (const entry of ['app', 'bootstrap']) {
+      const template = readFileSync(
+        new URL(`../templates/app/${entry}.ejs`, import.meta.url),
+        'utf8',
+      );
+      writeFileSync(
+        join(projectPath, '.vona', `${entry}.ts`),
+        compileTemplate(template)({ appMonkey: true }),
+      );
+    }
+    const result = spawnSync(
+      process.execPath,
+      ['--input-type=module', '--eval', source, projectPath],
+      {
+        cwd: projectPath,
+        encoding: 'utf8',
+        timeout: 15_000,
+        env: { ...process.env, BUILD_MINIFY: 'false', BUILD_SOURCEMAP: 'false' },
+      },
+    );
+    assert.ifError(result.error);
+    assert.equal(result.signal, null, result.stderr);
+    assert.equal(result.status, 0, result.stderr);
+  } finally {
+    rmSync(projectPath, { recursive: true, force: true });
+  }
+});

package/vona/packages-vona/vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona",
-  "version": "5.1.109",
+  "version": "5.1.110",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "Vona is an intuitive, elegant and powerful Node.js framework for rapidly developing enterprise applications of any size",
   "keywords": [

package/vona/packages-vona/vona-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-core",
-  "version": "5.1.46",
+  "version": "5.1.47",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona",
   "keywords": [