@lark-apaas/coding-template-nestjs-react-fullstack 0.1.27-alpha.20260824122815 → 0.1.27

package/template/scripts/workspace-client-runtime.mjs

@@ -1,466 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'node:fs';
-import http from 'node:http';
-import net from 'node:net';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-
-const projectRoot = path.resolve(
-  process.env.MIAODA_WORKSPACE_ROOT || process.cwd()
-);
-const workspaceReadyFile = path.resolve(
-  process.env.MIAODA_WORKSPACE_READY_FILE || '/tmp/event/WORKSPACE_READY'
-);
-const clientHost = process.env.CLIENT_DEV_HOST || '0.0.0.0';
-const clientPort = Number(process.env.CLIENT_DEV_PORT || 8080);
-const serverHost = process.env.SERVER_HOST || '0.0.0.0';
-const serverPort = Number(process.env.SERVER_PORT || 3000);
-const internalViteHost = process.env.MIAODA_VITE_INTERNAL_HOST || '127.0.0.1';
-const vite8RuntimeEnabled = process.env.MIAODA_VITE8_RUNTIME_ENABLED === 'true';
-const devBundleEnabled = process.env.MIAODA_VITE_DEV_BUNDLE_ENABLED === 'true';
-if (devBundleEnabled && !vite8RuntimeEnabled) {
-  throw new Error('MIAODA_VITE_DEV_BUNDLE_REQUIRES_VITE8');
-}
-const viteDepsCacheEnabled =
-  process.env.MIAODA_VITE_DEPS_CACHE_ENABLED || 'true';
-if (viteDepsCacheEnabled !== 'true' && viteDepsCacheEnabled !== 'false') {
-  throw new Error(
-    `MIAODA_VITE_DEPS_CACHE_ENABLED_INVALID: ${viteDepsCacheEnabled}`
-  );
-}
-const viteRuntimeConfig = path.join(
-  projectRoot,
-  'scripts',
-  'vite-runtime.config.mjs'
-);
-const viteEphemeralCacheDir =
-  process.env.MIAODA_VITE_EPHEMERAL_CACHE_DIR ||
-  '/tmp/miaoda-vite-deps-ephemeral';
-const bundledDevOutputFile = path.join(
-  projectRoot,
-  'dist',
-  'client',
-  'index.html'
-);
-const vite8Bin = path.resolve(
-  process.env.MIAODA_VITE8_BIN ||
-    '/opt/miaoda/preview-runtime/node_modules/vite/bin/vite.js'
-);
-// pair_ready 的就绪口径由 MIAODA_PAIR_READY_GATE 控制：
-//   'true'（默认）= 等 Vite + Nest 双就绪（'vite-and-nest'）；
-//   'false' = 只等 Vite 就绪（'vite'），对齐 legacy 预览链路的放行语义。
-// 关闭 gate 时 Nest 就绪仍被观测并照常发 nest_listen_ready 事件，
-// 保证不同口径下的阶段埋点可横向对比。
-const pairReadyGate =
-  (process.env.MIAODA_PAIR_READY_GATE || 'true') !== 'false';
-const readinessScope = pairReadyGate ? 'vite-and-nest' : 'vite';
-const nestStartMode = process.env.MIAODA_NEST_START_MODE || 'workspace';
-const runtimeStartedAtEpochMs = Date.now();
-const startedAt = process.hrtime.bigint();
-let stopping = false;
-let child;
-let proxyServer;
-let pairReady = false;
-
-function durationMs(since = startedAt) {
-  return Number(process.hrtime.bigint() - since) / 1_000_000;
-}
-
-function emit(phase, since, details = {}) {
-  const atEpochMs = Date.now();
-  const phaseDurationMs = Number(durationMs(since).toFixed(3));
-  process.stdout.write(
-    `${JSON.stringify({
-      event: 'miaoda_workspace_runtime_phase',
-      runtime: 'vite',
-      phase,
-      atEpochMs,
-      phaseStartedAtEpochMs: Number((atEpochMs - phaseDurationMs).toFixed(3)),
-      runtimeStartedAtEpochMs,
-      durationMs: phaseDurationMs,
-      ...details,
-    })}\n`
-  );
-}
-
-function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-function workspaceDependenciesReady() {
-  try {
-    return (
-      fs.statSync(workspaceReadyFile).isFile() &&
-      fs.statSync(path.join(projectRoot, 'node_modules')).isDirectory()
-    );
-  } catch {
-    return false;
-  }
-}
-
-function resolveVite8Runtime() {
-  if (!vite8RuntimeEnabled) return null;
-  if (!fs.existsSync(vite8Bin) || fs.lstatSync(vite8Bin).isSymbolicLink()) {
-    throw new Error(`MIAODA_VITE8_BIN_INVALID: ${vite8Bin}`);
-  }
-  const packageFile = path.resolve(vite8Bin, '..', '..', 'package.json');
-  const packageJson = JSON.parse(fs.readFileSync(packageFile, 'utf8'));
-  const version = String(packageJson.version || '');
-  if (!version.startsWith('8.')) {
-    throw new Error(`MIAODA_VITE8_VERSION_INVALID: ${version}`);
-  }
-  return { bin: vite8Bin, version };
-}
-
-async function waitForDependencies() {
-  const waitStartedAt = process.hrtime.bigint();
-  while (!stopping && !workspaceDependenciesReady()) await delay(100);
-  if (stopping) throw new Error('MIAODA_WORKSPACE_CLIENT_STOPPING');
-  emit('dependency_wait', waitStartedAt, { workspaceReadyFile });
-}
-
-function isBundledDevDocumentReady() {
-  try {
-    const html = fs.readFileSync(bundledDevOutputFile, 'utf8');
-    const forbiddenEntries = [
-      '/@vite/client',
-      '/@react-refresh',
-      '/client/src/index.tsx',
-      '/client/src/main.tsx',
-      '/src/index.tsx',
-      '/src/main.tsx',
-      '/@runtime.js',
-    ];
-    return (
-      html.includes('/assets/') &&
-      !forbiddenEntries.some(entry => html.includes(entry))
-    );
-  } catch {
-    return false;
-  }
-}
-
-async function waitForBundledDevDocument() {
-  const waitStartedAt = process.hrtime.bigint();
-  const deadline = Date.now() + 60_000;
-  while (!stopping && Date.now() < deadline) {
-    if (child && (child.exitCode !== null || child.signalCode !== null)) {
-      throw new Error('MIAODA_WORKSPACE_VITE_EXITED_BEFORE_BUNDLED_DEV_READY');
-    }
-    if (isBundledDevDocumentReady()) {
-      emit('bundled_dev_ready', waitStartedAt, {
-        outputFile: bundledDevOutputFile,
-      });
-      return;
-    }
-    await delay(50);
-  }
-  throw new Error('MIAODA_VITE_BUNDLED_DEV_READY_TIMEOUT');
-}
-
-function probeHost(host) {
-  if (!host || host === '0.0.0.0') return '127.0.0.1';
-  if (host === '::' || host === '[::]') return '::1';
-  return host.replace(/^\[|\]$/g, '');
-}
-
-async function reservePort() {
-  const configured = Number(process.env.MIAODA_VITE_INTERNAL_PORT || 0);
-  if (
-    Number.isSafeInteger(configured) &&
-    configured > 0 &&
-    configured <= 65_535
-  ) {
-    return configured;
-  }
-  return await new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.once('error', reject);
-    server.listen(0, internalViteHost, () => {
-      const address = server.address();
-      const port = address && typeof address !== 'string' ? address.port : 0;
-      server.close(error => (error ? reject(error) : resolve(port)));
-    });
-  });
-}
-
-async function waitForPort(host, port, phase) {
-  const listenStartedAt = process.hrtime.bigint();
-  const deadline = Date.now() + 60_000;
-  const targetHost = probeHost(host);
-  while (!stopping && Date.now() < deadline) {
-    if (child && (child.exitCode !== null || child.signalCode !== null)) {
-      throw new Error('MIAODA_WORKSPACE_VITE_EXITED_BEFORE_READY');
-    }
-    const connected = await new Promise(resolve => {
-      const socket = net.createConnection({ host: targetHost, port });
-      socket.once('connect', () => {
-        socket.destroy();
-        resolve(true);
-      });
-      socket.once('error', () => resolve(false));
-    });
-    if (connected) {
-      emit(phase, listenStartedAt, {
-        host,
-        port,
-      });
-      return;
-    }
-    await delay(100);
-  }
-  throw new Error(`MIAODA_WORKSPACE_SERVICE_READY_TIMEOUT: ${phase}`);
-}
-
-function rejectBeforePair(response) {
-  response.writeHead(503, {
-    'content-type': 'text/plain; charset=utf-8',
-    'cache-control': 'no-store',
-    'retry-after': '1',
-    connection: 'close',
-  });
-  response.end('preview services are starting');
-}
-
-function proxyHttp(request, response, internalVitePort) {
-  if (!pairReady) {
-    rejectBeforePair(response);
-    return;
-  }
-  const upstream = http.request(
-    {
-      host: internalViteHost,
-      port: internalVitePort,
-      method: request.method,
-      path: request.url,
-      headers: request.headers,
-    },
-    upstreamResponse => {
-      response.writeHead(
-        upstreamResponse.statusCode || 502,
-        upstreamResponse.statusMessage,
-        upstreamResponse.headers
-      );
-      upstreamResponse.pipe(response);
-    }
-  );
-  upstream.once('error', error => {
-    if (!response.headersSent) {
-      response.writeHead(502, {
-        'content-type': 'text/plain; charset=utf-8',
-        'cache-control': 'no-store',
-      });
-    }
-    response.end(`vite upstream unavailable: ${error.code || 'unknown'}`);
-  });
-  request.pipe(upstream);
-}
-
-function proxyUpgrade(request, socket, head, internalVitePort) {
-  if (!pairReady) {
-    socket.destroy();
-    return;
-  }
-  const upstream = net.createConnection(
-    { host: internalViteHost, port: internalVitePort },
-    () => {
-      const lines = [
-        `${request.method} ${request.url} HTTP/${request.httpVersion}`,
-      ];
-      for (let index = 0; index < request.rawHeaders.length; index += 2) {
-        lines.push(
-          `${request.rawHeaders[index]}: ${request.rawHeaders[index + 1]}`
-        );
-      }
-      upstream.write(`${lines.join('\r\n')}\r\n\r\n`);
-      if (head.length > 0) upstream.write(head);
-      socket.pipe(upstream).pipe(socket);
-    }
-  );
-  upstream.once('error', () => socket.destroy());
-  socket.once('error', () => upstream.destroy());
-}
-
-async function listenPublicProxy(internalVitePort) {
-  proxyServer = http.createServer((request, response) =>
-    proxyHttp(request, response, internalVitePort)
-  );
-  proxyServer.on('upgrade', (request, socket, head) =>
-    proxyUpgrade(request, socket, head, internalVitePort)
-  );
-  await new Promise((resolve, reject) => {
-    proxyServer.once('error', reject);
-    proxyServer.listen(clientPort, clientHost, resolve);
-  });
-  emit('public_gate_listen', startedAt, {
-    host: clientHost,
-    port: clientPort,
-    readinessScope,
-  });
-}
-
-function terminate(signal = 'SIGTERM') {
-  if (!child?.pid) return;
-  try {
-    process.kill(-child.pid, signal);
-  } catch {
-    try {
-      child.kill(signal);
-    } catch {}
-  }
-}
-
-async function close(signal) {
-  if (stopping) return;
-  stopping = true;
-  pairReady = false;
-  proxyServer?.close();
-  terminate(signal);
-  setTimeout(() => terminate('SIGKILL'), 1_000).unref();
-}
-
-for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
-  process.once(signal, () => void close(signal));
-}
-
-if (
-  !Number.isSafeInteger(clientPort) ||
-  clientPort <= 0 ||
-  clientPort > 65_535
-) {
-  throw new Error('MIAODA_WORKSPACE_VITE_PORT_INVALID');
-}
-if (
-  !Number.isSafeInteger(serverPort) ||
-  serverPort <= 0 ||
-  serverPort > 65_535
-) {
-  throw new Error('MIAODA_WORKSPACE_NEST_PORT_INVALID');
-}
-
-await waitForDependencies();
-const internalVitePort = await reservePort();
-await listenPublicProxy(internalVitePort);
-if (nestStartMode === 'bundle-handoff') {
-  await waitForPort(serverHost, serverPort, 'nest_precedes_vite');
-}
-const spawnStartedAt = process.hrtime.bigint();
-const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-const vite8Runtime = resolveVite8Runtime();
-if (
-  !fs.existsSync(viteRuntimeConfig) ||
-  fs.lstatSync(viteRuntimeConfig).isSymbolicLink()
-) {
-  throw new Error(`MIAODA_VITE_RUNTIME_CONFIG_INVALID: ${viteRuntimeConfig}`);
-}
-if (viteDepsCacheEnabled === 'false') {
-  fs.rmSync(viteEphemeralCacheDir, { recursive: true, force: true });
-}
-if (devBundleEnabled) {
-  fs.rmSync(bundledDevOutputFile, { force: true });
-}
-const viteCliArgs = [
-  '--config',
-  viteRuntimeConfig,
-  '--host',
-  internalViteHost,
-  '--port',
-  String(internalVitePort),
-  '--strictPort',
-];
-if (devBundleEnabled) {
-  viteCliArgs.push('--experimentalBundle');
-}
-const viteMaxOldSpaceSizeMb = devBundleEnabled ? 2048 : undefined;
-const viteNodeOptions = viteMaxOldSpaceSizeMb
-  ? [process.env.NODE_OPTIONS, `--max-old-space-size=${viteMaxOldSpaceSizeMb}`]
-      .filter(Boolean)
-      .join(' ')
-  : process.env.NODE_OPTIONS;
-const viteCommand = vite8Runtime ? process.execPath : npmCommand;
-const viteArgs = vite8Runtime
-  ? [vite8Runtime.bin, ...viteCliArgs]
-  : ['run', 'dev:client', '--', ...viteCliArgs];
-child = spawn(viteCommand, viteArgs, {
-  cwd: projectRoot,
-  detached: true,
-  stdio: 'inherit',
-  env: {
-    ...process.env,
-    NODE_OPTIONS: viteNodeOptions,
-    MIAODA_CACHE_BOOTSTRAP_ENABLED: 'false',
-    MIAODA_VITE8_RUNTIME_ENABLED: String(vite8RuntimeEnabled),
-    MIAODA_VITE_DEV_BUNDLE_ENABLED: String(devBundleEnabled),
-    MIAODA_VITE_DEPS_CACHE_ENABLED: viteDepsCacheEnabled,
-    MIAODA_VITE_EPHEMERAL_CACHE_DIR: viteEphemeralCacheDir,
-    MIAODA_VITE_INTERNAL_HOST: internalViteHost,
-    MIAODA_VITE_INTERNAL_PORT: String(internalVitePort),
-  },
-});
-emit('process_spawn', spawnStartedAt, {
-  pid: child.pid,
-  vite8RuntimeEnabled,
-  vite8Version: vite8Runtime?.version,
-  devBundleEnabled,
-  viteMaxOldSpaceSizeMb,
-  viteDepsCacheEnabled: viteDepsCacheEnabled === 'true',
-  viteRuntimeConfig,
-  viteEphemeralCacheDir:
-    viteDepsCacheEnabled === 'false' ? viteEphemeralCacheDir : undefined,
-  internalViteHost,
-  internalVitePort,
-});
-
-const exitPromise = new Promise((resolve, reject) => {
-  child.once('error', reject);
-  child.once('exit', (code, signal) => resolve({ code, signal }));
-});
-const viteListenWait = waitForPort(
-  internalViteHost,
-  internalVitePort,
-  'vite_listen_ready'
-);
-const viteRuntimeReadiness = [viteListenWait];
-if (devBundleEnabled) {
-  viteRuntimeReadiness.push(waitForBundledDevDocument());
-}
-let readinessWait = Promise.all(viteRuntimeReadiness);
-if (pairReadyGate) {
-  readinessWait = Promise.all([
-    ...viteRuntimeReadiness,
-    waitForPort(serverHost, serverPort, 'nest_listen_ready'),
-  ]);
-} else {
-  // Gate 关闭时 pair_ready 只跟随 Vite；Nest 就绪在后台继续观测，
-  // nest_listen_ready 事件照常发出，失败不阻断预览放行。
-  waitForPort(serverHost, serverPort, 'nest_listen_ready').catch(() => {});
-}
-await Promise.race([
-  readinessWait,
-  exitPromise.then(exit => {
-    throw new Error(
-      `MIAODA_WORKSPACE_VITE_EXITED_BEFORE_READY: code=${exit.code} signal=${exit.signal}`
-    );
-  }),
-]);
-pairReady = true;
-emit('pair_ready', startedAt, {
-  host: clientHost,
-  port: clientPort,
-  internalViteHost,
-  internalVitePort,
-  serverHost,
-  serverPort,
-  readinessScope,
-});
-emit('startup', startedAt, {
-  pid: child.pid,
-  port: clientPort,
-  readinessScope,
-});
-
-const exit = await exitPromise;
-const wasStopping = stopping;
-await close(exit.signal || 'SIGTERM');
-process.exit(exit.code ?? (wasStopping ? 0 : 1));