cabloy 5.1.204 → 5.1.206

package/scripts/testProcessGuardian.ts

@@ -0,0 +1,163 @@
+import type { ChildProcess } from 'node:child_process';
+
+import { spawn } from 'node:child_process';
+
+import type { TestProcessIdentity } from './testClaimProcesses.ts';
+
+import { sendTestClaimEvent } from '../vona/packages-vona/vona-core/src/lib/core/testClaim.ts';
+
+interface StartMessage {
+  type: 'start';
+  command: string;
+  args: string[];
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  processId?: string;
+  identity?: TestProcessIdentity;
+}
+
+if (process.platform === 'win32' || !process.send) {
+  throw new Error('Isolated test guardian requires a POSIX process group and parent IPC');
+}
+
+let child: ChildProcess | undefined;
+let stopping = false;
+let finishing = false;
+let finished = false;
+let failed = false;
+let childResult: { code: number | null; signal: NodeJS.Signals | null } | undefined;
+let forceTimer: NodeJS.Timeout | undefined;
+let launch: StartMessage | undefined;
+
+async function groupMembers(): Promise<number[]> {
+  const output = await new Promise<string>((resolvePromise, reject) => {
+    const inspector = spawn('ps', ['-A', '-o', 'pid=', '-o', 'pgid=', '-o', 'state='], {
+      detached: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    inspector.stdout?.on('data', data => {
+      stdout += data;
+    });
+    inspector.stderr?.on('data', data => {
+      stderr += data;
+    });
+    inspector.once('error', reject);
+    inspector.once('close', code => {
+      if (code === 0) resolvePromise(stdout);
+      else reject(new Error(`Cannot inspect isolated process group: ${stderr}`));
+    });
+  });
+  return output
+    .split('\n')
+    .map(line => line.trim().split(/\s+/))
+    .filter(
+      ([pid, pgid, state]) =>
+        pid &&
+        pgid &&
+        state &&
+        Number(pgid) === process.pid &&
+        Number(pid) !== process.pid &&
+        !state.startsWith('Z'),
+    )
+    .map(([pid]) => Number(pid));
+}
+
+function requestStop() {
+  if (stopping || finished) return;
+  stopping = true;
+  forceTimer = setTimeout(() => {
+    // The guardian remains its own group leader while issuing the last resort signal.
+    process.kill(-process.pid, 'SIGKILL');
+  }, 12_000);
+  try {
+    process.kill(-process.pid, 'SIGINT');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error;
+  }
+  if (!child) void drain();
+}
+
+async function drain() {
+  if (finishing || finished) return;
+  finishing = true;
+  try {
+    let deadline = Date.now() + (stopping ? 10_000 : 1_000);
+    while ((await groupMembers()).length > 0) {
+      if (Date.now() >= deadline) {
+        if (stopping) {
+          throw new Error('Isolated process group did not drain after shutdown');
+        }
+        requestStop();
+        deadline = Date.now() + 10_000;
+      }
+      await new Promise(resolvePromise => setTimeout(resolvePromise, 100));
+    }
+    if (forceTimer) clearTimeout(forceTimer);
+    if (launch?.processId && launch.identity) {
+      try {
+        await sendTestClaimEvent(launch.env, {
+          type: 'process',
+          process: {
+            id: launch.processId,
+            role: 'guardian',
+            stage: 'drained',
+            pid: launch.identity.pid,
+            pgid: launch.identity.pgid,
+            startTime: launch.identity.startTime,
+            host: launch.identity.host,
+          },
+        });
+      } catch {
+        failed = true;
+      }
+    }
+    finished = true;
+    process.send?.({ type: 'drained', result: childResult, failed }, error => {
+      if (error) process.exit(1);
+      else process.exit(0);
+    });
+  } catch (error) {
+    console.error(error);
+    requestStop();
+  }
+}
+
+function start(message: StartMessage) {
+  if (child || stopping) return;
+  launch = message;
+  try {
+    child = spawn(message.command, message.args, {
+      cwd: message.cwd,
+      env: message.env,
+      stdio: 'inherit',
+      detached: false,
+    });
+    child.once('error', error => {
+      failed = true;
+      console.error(error);
+    });
+    child.once('close', (code, signal) => {
+      childResult = { code, signal };
+      void drain();
+    });
+    if (stopping) child.kill('SIGINT');
+    process.send?.({ type: 'started' });
+  } catch (error) {
+    console.error(error);
+    failed = true;
+    childResult = { code: 1, signal: null };
+    void drain();
+  }
+}
+
+process.on('SIGINT', requestStop);
+process.on('SIGTERM', requestStop);
+process.on('disconnect', requestStop);
+process.on('message', message => {
+  if (!message || typeof message !== 'object') return;
+  if ('type' in message && message.type === 'stop') requestStop();
+  if ('type' in message && message.type === 'start') start(message as StartMessage);
+});
+process.send?.({ type: 'ready' });

package/scripts/upgrade.ts

@@ -549,17 +549,7 @@ function runInit(dryRun: boolean, version: string): void {
   exec('npm run init', { CABLOY_VERSION: version } as any);
 }
 
-// --- Step 5: Run init:test-data ---
-
-function runInitTestData(dryRun: boolean): void {
-  if (dryRun) {
-    log('  [dry-run] Run: npm run init:test-data');
-    return;
-  }
-  exec('npm run init:test-data');
-}
-
-// --- Step 6: Cleanup ---
+// --- Step 5: Cleanup ---
 
 function cleanup(dryRun?: boolean): void {
   if (existsSync(TEMP_DIR)) {
@@ -637,11 +627,6 @@ async function main(): Promise<void> {
     runInit(dryRun, latestPackageInfo.version);
     log('');
 
-    // 6. Run init:test-data
-    log('Running npm run init:test-data...');
-    runInitTestData(dryRun);
-    log('');
-
     if (dryRun) {
       log(`[dry-run] Current Cabloy version would become: ${latestPackageInfo.version}`);
     } else {

package/vona/oxfmt.config.ts

@@ -11,6 +11,8 @@ export default defineConfig(
       '**/.rollup.cache/**',
       '**/.metadata/index.ts',
       '.vona',
+      '.vona-test-*',
+      '.app-test-*',
       '.assets',
       'coverage',
       'docker-compose',

package/vona/oxlint.config.ts

@@ -43,6 +43,8 @@ export default defineConfig(
       '**/.rollup.cache/**',
       '**/.metadata/index.ts',
       '.vona',
+      '.vona-test-*',
+      '.app-test-*',
       '.claude',
       '.assets',
       'coverage',

package/vona/package.original.json

@@ -23,8 +23,8 @@
     "db:reset": "npm run prerun && npm run vona :bin:dbReset -- --flavor=normal",
     "dev": "npm run prerun && npm run vona :bin:dev -- --workers=2 --flavor=normal",
     "dev:one": "npm run prerun && npm run vona :bin:dev -- --workers=1 --flavor=normal",
-    "test": "npm run prerun && npm run vona :bin:test -- --flavor=normal",
-    "cov": "npm run prerun && npm run vona :bin:test -- --coverage --flavor=normal",
+    "test": "node ../scripts/runIsolatedTest.ts unit",
+    "cov": "node ../scripts/runIsolatedTest.ts unit --coverage",
     "tsc": "npm run prerun && npm run vona :bin:tsc",
     "build": "npm run prerun && npm run vona :bin:build -- --flavor=normal",
     "build:docker": "npm run prerun && npm run vona :bin:build -- --flavor=docker",

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

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

package/vona/packages-cli/cli/src/play.test.ts

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { test } from 'node:test';
+
+const script = `
+  import { playAttach } from './play.ts';
+  await playAttach('/nonexistent-vona-project', []);
+`;
+
+test('play attach accepts the timestamped test identity before locating its runtime', () => {
+  const result = spawnSync(process.execPath, ['--input-type=module', '-e', script], {
+    cwd: import.meta.dirname,
+    env: {
+      ...process.env,
+      META_MODE: 'test',
+      VONA_TEST_RUN_ID: '20261014010203-a1b2c3d4',
+    },
+    encoding: 'utf8',
+  });
+  assert.notEqual(result.status, 0);
+  assert.match(result.stderr, /dev server not running/);
+  assert.doesNotMatch(result.stderr, /VONA_TEST_RUN_ID requires/);
+});
+
+test('play attach rejects impossible UTC seconds', () => {
+  const result = spawnSync(process.execPath, ['--input-type=module', '-e', script], {
+    cwd: import.meta.dirname,
+    env: {
+      ...process.env,
+      META_MODE: 'test',
+      VONA_TEST_RUN_ID: '20260230010203-a1b2c3d4',
+    },
+    encoding: 'utf8',
+  });
+  assert.notEqual(result.status, 0);
+  assert.match(result.stderr, /VONA_TEST_RUN_ID requires/);
+});

package/vona/packages-cli/cli/src/play.ts

@@ -4,7 +4,29 @@ import path from 'node:path';
 import { loadJSONFile } from './utils.ts';
 
 export async function playAttach(projectPath: string, args: string[]) {
-  const runtimeFile = path.join(projectPath, '.app/runtime/-.json');
+  const runId = process.env.VONA_TEST_RUN_ID;
+  if (runId) {
+    const match = /^(\d{14})-[a-f0-9]{8}$/.exec(runId);
+    const timestamp = match?.[1];
+    const date = timestamp
+      ? new Date(
+          `${timestamp.slice(0, 4)}-${timestamp.slice(4, 6)}-${timestamp.slice(6, 8)}T${timestamp.slice(8, 10)}:${timestamp.slice(10, 12)}:${timestamp.slice(12, 14)}Z`,
+        )
+      : undefined;
+    if (
+      process.env.META_MODE !== 'test' ||
+      !timestamp ||
+      !date ||
+      Number.isNaN(date.getTime()) ||
+      date.toISOString().slice(0, 19).replace(/[-:T]/g, '') !== timestamp
+    ) {
+      throw new Error(
+        'VONA_TEST_RUN_ID requires test mode and a UTC timestamp plus eight hex digits',
+      );
+    }
+  }
+  const dataDir = runId ? `.app-test-${runId}` : '.app';
+  const runtimeFile = path.join(projectPath, dataDir, 'runtime/-.json');
   if (!fse.existsSync(runtimeFile)) throw new Error('dev server not running');
   // body
   const body = { args, projectPath };

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

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

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

@@ -5,6 +5,7 @@ import { BeanCliBase } from '@cabloy/cli';
 import fse from 'fs-extra';
 import path from 'node:path';
 import { rimraf } from 'rimraf';
+import { resolveVonaLocalPaths } from 'vona-core';
 
 import type { VonaBinConfigOptions } from './toolsBin/types.ts';
 
@@ -23,23 +24,27 @@ export class CliBinDbReset extends BeanCliBase {
     // super
     await super.execute();
     const projectPath = argv.projectPath;
-    // test
+    // recreate the development database
     await this._dbReset(projectPath);
   }
 
   async _dbReset(projectPath: string) {
     const { argv } = this.context;
-    const mode: VonaMetaMode = 'test';
+    const mode: VonaMetaMode = 'dev';
     const flavor: VonaMetaFlavor = argv.flavor || 'normal';
     const configMeta: VonaConfigMeta = { flavor, mode };
+    const paths = resolveVonaLocalPaths(projectPath, mode);
     const configOptions: VonaBinConfigOptions = {
       appDir: projectPath,
-      runtimeDir: '.vona',
+      runtimeDir: paths.generatedDir,
       workers: 1,
     };
-    const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
-    await this._run(projectPath, modulesMeta);
-    await rimraf(path.join(projectPath, '.vona'));
+    try {
+      const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
+      await this._run(projectPath, modulesMeta);
+    } finally {
+      await rimraf(paths.generatedRoot);
+    }
   }
 
   async _run(projectPath: string, _modulesMeta: Awaited<ReturnType<typeof glob>>) {
@@ -50,7 +55,11 @@ export class CliBinDbReset extends BeanCliBase {
     }
     // run
     let args: string[] = [];
-    args = args.concat([getImportEsm(), testFile, projectPath]);
+    args = args.concat([
+      getImportEsm(resolveVonaLocalPaths(projectPath, 'dev').generatedDir),
+      testFile,
+      projectPath,
+    ]);
     // args = args.concat(['--experimental-transform-types', getImportEsm(), testFile, projectPath]);
     await this.helper.spawnExe({
       cmd: 'node',

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

@@ -3,9 +3,9 @@ import type { VonaConfigMeta, VonaMetaFlavor, VonaMetaMode } from '@cabloy/modul
 
 import { BeanCliBase } from '@cabloy/cli';
 import { spawn } from 'node:child_process';
-import path from 'node:path';
 import nodemon from 'nodemon';
 import { rimraf } from 'rimraf';
+import { resolveVonaLocalPaths } from 'vona-core';
 
 import type { VonaBinConfigOptions } from './toolsBin/types.ts';
 
@@ -48,9 +48,10 @@ export class CliBinDev extends BeanCliBase {
     const workers = resolveTestWorkers(mode, argv.workers);
     const flavor: VonaMetaFlavor = argv.flavor || 'normal';
     const configMeta: VonaConfigMeta = { flavor, mode };
+    const paths = resolveVonaLocalPaths(projectPath, mode);
     const configOptions: VonaBinConfigOptions = {
       appDir: projectPath,
-      runtimeDir: '.vona',
+      runtimeDir: paths.generatedDir,
       workers,
     };
     try {
@@ -61,15 +62,20 @@ export class CliBinDev extends BeanCliBase {
         await this._run(projectPath, modulesMeta);
       }
     } finally {
-      await rimraf(path.join(projectPath, '.vona'));
+      if (!paths.runId) await rimraf(paths.generatedRoot);
     }
   }
 
   async _runTest(projectPath: string) {
-    const child = spawn(process.execPath, [getImportEsm(), '.vona/bootstrap.ts'], {
-      cwd: projectPath,
-      stdio: 'inherit',
-    });
+    const generatedDir = resolveVonaLocalPaths(projectPath, 'test').generatedDir;
+    const child = spawn(
+      process.execPath,
+      [getImportEsm(generatedDir), `${generatedDir}/bootstrap.ts`],
+      {
+        cwd: projectPath,
+        stdio: 'inherit',
+      },
+    );
     const forwardSignal = (signal: NodeJS.Signals) => child.kill(signal);
     const onInterrupt = () => forwardSignal('SIGINT');
     const onTerminate = () => forwardSignal('SIGTERM');

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

@@ -3,6 +3,7 @@ import type { VonaConfigMeta, VonaMetaFlavor, VonaMetaMode } from '@cabloy/modul
 import { BeanCliBase } from '@cabloy/cli';
 import fse from 'fs-extra';
 import path from 'node:path';
+import { resolveVonaLocalPaths } from 'vona-core';
 
 import type { VonaBinConfigOptions } from './toolsBin/types.ts';
 
@@ -49,7 +50,10 @@ export class CliBinPlay extends BeanCliBase {
   }
 
   async _runAttach(projectPath: string) {
-    const runtimeFile = path.join(projectPath, '.app/runtime/-.json');
+    const runtimeFile = path.join(
+      resolveVonaLocalPaths(projectPath, process.env.META_MODE ?? 'dev').runtimeRoot,
+      '-.json',
+    );
     if (!fse.existsSync(runtimeFile)) throw new Error('dev server not running');
     // args
     let args: string[] = [];

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

@@ -6,6 +6,7 @@ import { catchError } from '@cabloy/utils';
 import fse from 'fs-extra';
 import path from 'node:path';
 import { rimraf } from 'rimraf';
+import { resolveVonaLocalPaths } from 'vona-core';
 
 import type { VonaBinConfigOptions } from './toolsBin/types.ts';
 
@@ -34,17 +35,21 @@ export class CliBinTest extends BeanCliBase {
     const mode: VonaMetaMode = 'test';
     const flavor: VonaMetaFlavor = argv.flavor || 'normal';
     const configMeta: VonaConfigMeta = { flavor, mode };
+    const paths = resolveVonaLocalPaths(projectPath, mode);
     const configOptions: VonaBinConfigOptions = {
       appDir: projectPath,
-      runtimeDir: '.vona',
+      runtimeDir: paths.generatedDir,
       workers: 1,
     };
-    const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
-    await this._run(projectPath, modulesMeta);
-    if (argv.coverage && !argv.ci) {
-      await this._outputCoverageReportViewer(projectPath);
+    try {
+      const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
+      await this._run(projectPath, modulesMeta);
+      if (argv.coverage && !argv.ci) {
+        await this._outputCoverageReportViewer(projectPath);
+      }
+    } finally {
+      if (!paths.runId) await rimraf(paths.generatedRoot);
     }
-    await rimraf(path.join(projectPath, '.vona'));
   }
 
   async _run(projectPath: string, modulesMeta: Awaited<ReturnType<typeof glob>>) {
@@ -70,7 +75,7 @@ export class CliBinTest extends BeanCliBase {
       args.push('--import=why-is-node-running/include');
     }
     args = args.concat([
-      getImportEsm(),
+      getImportEsm(resolveVonaLocalPaths(projectPath, 'test').generatedDir),
       testFile,
       projectPath,
       (!!argv.coverage).toString(),

package/vona/packages-cli/cli-set-api/src/lib/bean/toolsBin/configUtils.ts

@@ -4,6 +4,7 @@ import * as dotenv from '@cabloy/dotenv';
 import { glob } from '@cabloy/module-glob';
 import os from 'node:os';
 import path from 'node:path';
+import { getTestAppName, resolveTestRunId, TEST_RUN_ID_ENV } from 'vona-core';
 
 import type { VonaBinConfigOptions } from './types.ts';
 
@@ -27,6 +28,10 @@ export function createConfigUtils(
   function __loadEnvs(): NodeJS.ProcessEnv {
     const meta = getEnvMeta(configMeta);
     const envDir = path.join(configOptions.appDir, 'env');
+    const runId = resolveTestRunId(meta.mode, process.env[TEST_RUN_ID_ENV]);
+    if (runId && process.env.VONA_DB_RESET !== undefined) {
+      throw new Error('Isolated test cannot run a development database reset');
+    }
     const envs = dotenv.loadEnvs(meta, envDir, '.env');
     const res = Object.assign(
       {
@@ -38,6 +43,20 @@ export function createConfigUtils(
         META_MODE: meta.mode,
       },
     );
+    if (runId) {
+      res[TEST_RUN_ID_ENV] = runId;
+      res.APP_NAME = getTestAppName(runId);
+      const port = Number(process.env.SERVER_LISTEN_PORT);
+      if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+        throw new Error('Isolated test requires an assigned SERVER_LISTEN_PORT');
+      }
+      res.SERVER_LISTEN_PORT = String(port);
+      res.SERVER_LISTEN_HOSTNAME = '127.0.0.1';
+      if (process.env.VONA_TEST_SERVER_ORIGIN === 'true') {
+        res.SERVER_SERVE_PROTOCOL = 'http';
+        res.SERVER_SERVE_HOST = `127.0.0.1:${port}`;
+      }
+    }
     if (configOptions.workers !== undefined) {
       res.SERVER_WORKERS = configOptions.workers.toString();
     }
@@ -49,8 +68,8 @@ export function createConfigUtils(
         res.SERVER_WORKERS = '1';
       }
     }
-    for (const key of ['NODE_ENV', 'SERVER_WORKERS', 'META_FLAVOR', 'META_MODE']) {
-      if ((res[key] as any) !== false) {
+    for (const key of ['NODE_ENV', 'SERVER_WORKERS', 'META_FLAVOR', 'META_MODE', TEST_RUN_ID_ENV]) {
+      if (res[key] !== undefined && (res[key] as any) !== false) {
         process.env[key] = res[key];
       }
     }

package/vona/packages-cli/cli-set-api/src/lib/bean/toolsBin/generateVonaMeta.ts

@@ -1,5 +1,7 @@
 import type { VonaConfigMeta } from '@cabloy/module-info';
 
+import { assertTestRunOwner, resolveVonaLocalPaths } from 'vona-core';
+
 import type { VonaBinConfigOptions } from './types.ts';
 
 import { createConfigUtils } from './configUtils.ts';
@@ -9,6 +11,14 @@ export async function generateVonaMeta(
   configMeta: VonaConfigMeta,
   configOptions: VonaBinConfigOptions,
 ) {
+  const paths = resolveVonaLocalPaths(configOptions.appDir, configMeta.mode);
+  if (paths.runId) {
+    if (configOptions.runtimeDir !== paths.generatedDir) {
+      throw new Error('Isolated test generated directory does not match its run ID');
+    }
+    assertTestRunOwner(paths.dataRoot, paths.runId);
+    assertTestRunOwner(paths.generatedRoot, paths.runId);
+  }
   // config utils
   const configUtils = createConfigUtils(configMeta, configOptions);
   // env