@lark-apaas/fullstack-cli 1.1.60 → 1.1.61-alpha.20260818172555

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

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+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 defaultViteWarmupFiles = [
+  './client/src/*.tsx',
+  './client/src/*.ts',
+  './client/src/**/*.css',
+].join(',');
+const viteWarmupFiles =
+  process.env.MIAODA_VITE_WARMUP_FILES ?? defaultViteWarmupFiles;
+const runtimeStartedAtEpochMs = Date.now();
+const startedAt = process.hrtime.bigint();
+let stopping = false;
+let child;
+
+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;
+  }
+}
+
+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 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 waitForPort() {
+  const listenStartedAt = process.hrtime.bigint();
+  const deadline = Date.now() + 60_000;
+  const host = probeHost(clientHost);
+  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, port: clientPort });
+      socket.once('connect', () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.once('error', () => resolve(false));
+    });
+    if (connected) {
+      // Public Vite readiness is intentionally independent from Nest. The
+      // Vite /dev/health endpoint still checks both processes before the
+      // control plane publishes the preview URL.
+      emit('listen_ready', listenStartedAt, {
+        host: clientHost,
+        port: clientPort,
+        readinessScope: 'vite-only',
+      });
+      return;
+    }
+    await delay(100);
+  }
+  throw new Error('MIAODA_WORKSPACE_VITE_READY_TIMEOUT');
+}
+
+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;
+  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');
+}
+
+await waitForDependencies();
+const spawnStartedAt = process.hrtime.bigint();
+const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+child = spawn(npmCommand, ['run', 'dev:client'], {
+  cwd: projectRoot,
+  detached: true,
+  stdio: 'inherit',
+  env: {
+    ...process.env,
+    MIAODA_CACHE_BOOTSTRAP_ENABLED: 'false',
+    MIAODA_VITE_WARMUP_FILES: viteWarmupFiles,
+  },
+});
+emit('process_spawn', spawnStartedAt, {
+  pid: child.pid,
+  warmupFiles: viteWarmupFiles,
+});
+
+const exitPromise = new Promise((resolve, reject) => {
+  child.once('error', reject);
+  child.once('exit', (code, signal) => resolve({ code, signal }));
+});
+await Promise.race([
+  waitForPort(),
+  exitPromise.then(exit => {
+    throw new Error(
+      `MIAODA_WORKSPACE_VITE_EXITED_BEFORE_READY: code=${exit.code} signal=${exit.signal}`
+    );
+  }),
+]);
+emit('startup', startedAt, {
+  pid: child.pid,
+  port: clientPort,
+  readinessScope: 'vite-only',
+});
+
+const exit = await exitPromise;
+process.exit(exit.code ?? (stopping ? 0 : 1));