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

package/templates/scripts/server-startup-runtime.mjs

@@ -0,0 +1,496 @@
+#!/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';
+import { fileURLToPath } from 'node:url';
+
+const projectRoot = path.resolve(
+  process.env.MIAODA_WORKSPACE_ROOT || process.cwd()
+);
+
+// The bundle orchestrator may be started directly by the image before the
+// project npm task exists. Load the same project .env contract as dev.js so the
+// later source service receives identical application configuration.
+const projectEnvFile = path.join(projectRoot, '.env');
+if (fs.existsSync(projectEnvFile)) {
+  for (const line of fs.readFileSync(projectEnvFile, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const separator = trimmed.indexOf('=');
+    if (separator < 1) continue;
+    const key = trimmed.slice(0, separator).trim();
+    const value = trimmed.slice(separator + 1).trim();
+    if (!(key in process.env)) process.env[key] = value;
+  }
+}
+const scriptsRoot = path.dirname(fileURLToPath(import.meta.url));
+const workspaceReadyFile = path.resolve(
+  process.env.MIAODA_WORKSPACE_READY_FILE || '/tmp/event/WORKSPACE_READY'
+);
+const bundleFallbackFile = path.resolve(
+  process.env.MIAODA_NEST_BUNDLE_FALLBACK_FILE ||
+    '/tmp/event/MIAODA_NEST_BUNDLE_FALLBACK'
+);
+const serverHost = process.env.SERVER_HOST || '0.0.0.0';
+const serverPort = Number(process.env.SERVER_PORT || 3000);
+const requestedMode = process.env.MIAODA_NEST_START_MODE || 'workspace';
+const supportedModes = new Set([
+  'bundle-handoff',
+  'workspace',
+  'dist',
+  'ts-node',
+]);
+const runtimeStartedAtEpochMs = Date.now();
+const startedAt = process.hrtime.bigint();
+let stopping = false;
+let serviceChild;
+let compilerChild;
+let sourceWatcher;
+let restartTimer;
+let compiling = false;
+let compileQueued = false;
+let restartingService = false;
+
+if (!supportedModes.has(requestedMode)) {
+  throw new Error(`MIAODA_NEST_START_MODE_INVALID: ${requestedMode}`);
+}
+if (
+  !Number.isSafeInteger(serverPort) ||
+  serverPort <= 0 ||
+  serverPort > 65_535
+) {
+  throw new Error('MIAODA_NEST_SERVER_PORT_INVALID');
+}
+
+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: 'nest',
+      mode: requestedMode,
+      phase,
+      atEpochMs,
+      phaseStartedAtEpochMs: Number((atEpochMs - phaseDurationMs).toFixed(3)),
+      runtimeStartedAtEpochMs,
+      durationMs: phaseDurationMs,
+      ...details,
+    })}\n`
+  );
+}
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function markBundleFallback(reason) {
+  fs.mkdirSync(path.dirname(bundleFallbackFile), { recursive: true });
+  const temporaryFile = `${bundleFallbackFile}.${process.pid}.tmp`;
+  fs.writeFileSync(
+    temporaryFile,
+    `${JSON.stringify({ schemaVersion: 1, reason, at: new Date().toISOString() })}\n`,
+    { mode: 0o600 }
+  );
+  fs.renameSync(temporaryFile, bundleFallbackFile);
+}
+
+function childRunning(child) {
+  return Boolean(
+    child?.pid && child.exitCode === null && child.signalCode === null
+  );
+}
+
+function terminate(child, signal = 'SIGTERM') {
+  if (!child?.pid) return;
+  try {
+    process.kill(-child.pid, signal);
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {}
+  }
+}
+
+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_NEST_STARTUP_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(child = serviceChild) {
+  const listenStartedAt = process.hrtime.bigint();
+  const deadline = Date.now() + 60_000;
+  const host = probeHost(serverHost);
+  while (!stopping && Date.now() < deadline) {
+    if (child && !childRunning(child)) {
+      throw new Error('MIAODA_NEST_PROCESS_EXITED_BEFORE_READY');
+    }
+    const connected = await new Promise(resolve => {
+      const socket = net.createConnection({ host, port: serverPort });
+      socket.once('connect', () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.once('error', () => resolve(false));
+    });
+    if (connected) {
+      emit('listen_ready', listenStartedAt, {
+        host: serverHost,
+        port: serverPort,
+      });
+      return;
+    }
+    await delay(100);
+  }
+  throw new Error('MIAODA_NEST_READY_TIMEOUT');
+}
+
+function spawnInherited(command, args, extraEnv = {}) {
+  return spawn(command, args, {
+    cwd: projectRoot,
+    detached: true,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      ...extraEnv,
+      MIAODA_CACHE_BOOTSTRAP_ENABLED: 'false',
+    },
+  });
+}
+
+async function runCommand(command, args, phase) {
+  const phaseStartedAt = process.hrtime.bigint();
+  compilerChild = spawnInherited(command, args);
+  const result = await new Promise((resolve, reject) => {
+    compilerChild.once('error', reject);
+    compilerChild.once('exit', (code, signal) => resolve({ code, signal }));
+  });
+  compilerChild = undefined;
+  emit(phase, phaseStartedAt, result);
+  if (result.code !== 0) {
+    throw new Error(
+      `MIAODA_NEST_COMMAND_FAILED: ${command} ${args.join(' ')} code=${result.code} signal=${result.signal}`
+    );
+  }
+}
+
+function resolveProjectModule(relativePath) {
+  const resolved = path.join(projectRoot, 'node_modules', relativePath);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`MIAODA_NEST_TOOL_MISSING: ${relativePath}`);
+  }
+  return resolved;
+}
+
+async function initializeActionPlugins() {
+  const cli = [
+    process.env.MIAODA_FULLSTACK_CLI_BIN,
+    path.join(
+      projectRoot,
+      'node_modules',
+      '@lark-apaas',
+      'fullstack-cli',
+      'bin',
+      'cli.js'
+    ),
+    '/usr/lib/node_modules/@lark-apaas/fullstack-cli/bin/cli.js',
+  ].find(candidate => candidate && fs.existsSync(candidate));
+  if (!cli) {
+    throw new Error('MIAODA_ACTION_PLUGIN_CLI_MISSING');
+  }
+  try {
+    await runCommand(
+      process.execPath,
+      [cli, 'action-plugin', 'init'],
+      'action_plugin_init'
+    );
+  } catch (error) {
+    // Match the original dev.js contract: plugin discovery failure is visible
+    // in logs but does not replace the Nest process with a platform failure.
+    process.stderr.write(
+      `${JSON.stringify({
+        event: 'miaoda_action_plugin_init_failed',
+        continueStartup: true,
+        error: error instanceof Error ? error.message : String(error),
+      })}\n`
+    );
+  }
+}
+
+function spawnWorkspaceService() {
+  const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  return spawnInherited(npmCommand, ['run', 'dev:server']);
+}
+
+function spawnDistService() {
+  return spawnInherited(
+    process.execPath,
+    [
+      '-r',
+      resolveProjectModule('tsconfig-paths/register.js'),
+      path.join(projectRoot, 'dist', 'server', 'main.js'),
+    ],
+    {
+      // Keep direct runtime modes aligned with `npm run dev:server`.
+      NODE_ENV: 'development',
+      // TypeScript preserves path aliases in emitted JavaScript. Point the
+      // existing tsconfig-paths resolver at dist so @server/* and @shared/*
+      // resolve to compiled files instead of the TypeScript source tree.
+      TS_NODE_PROJECT: path.join(projectRoot, 'tsconfig.node.json'),
+      TS_NODE_BASEURL: path.join(projectRoot, 'dist'),
+    }
+  );
+}
+
+function spawnTsNodeService() {
+  const sourceEntry = path.join(projectRoot, 'server', 'main.ts');
+  return spawnInherited(
+    process.execPath,
+    [
+      '-r',
+      resolveProjectModule('ts-node/register/transpile-only.js'),
+      '-r',
+      resolveProjectModule('tsconfig-paths/register.js'),
+      '-e',
+      `require(${JSON.stringify(sourceEntry)})`,
+    ],
+    {
+      // `npm run dev:server` sets this in package.json. The direct ts-node
+      // path must preserve the same Nest module graph and development behavior.
+      NODE_ENV: 'development',
+      TS_NODE_PROJECT: path.join(projectRoot, 'tsconfig.node.json'),
+      TS_NODE_TRANSPILE_ONLY: 'true',
+      // A restored workspace can contain stale JavaScript next to TypeScript
+      // sources. Prefer the TypeScript file so a watcher restart always runs
+      // the source the user just edited instead of the old emitted file.
+      TS_NODE_PREFER_TS_EXTS: 'true',
+    }
+  );
+}
+
+function watchSource(onChange) {
+  const watchers = [];
+  for (const relative of ['server', 'shared']) {
+    const directory = path.join(projectRoot, relative);
+    if (!fs.existsSync(directory)) continue;
+    watchers.push(
+      fs.watch(directory, { recursive: true }, (_event, filename) => {
+        if (!filename || !/\.(?:[cm]?[jt]sx?|json)$/.test(filename)) return;
+        clearTimeout(restartTimer);
+        restartTimer = setTimeout(onChange, 120);
+      })
+    );
+  }
+  sourceWatcher = { close: () => watchers.forEach(watcher => watcher.close()) };
+}
+
+async function restartService(spawnService) {
+  if (stopping || restartingService) return;
+  restartingService = true;
+  const oldChild = serviceChild;
+  try {
+    terminate(oldChild);
+    if (oldChild && childRunning(oldChild)) {
+      await Promise.race([
+        new Promise(resolve => oldChild.once('exit', resolve)),
+        delay(1_000),
+      ]);
+      terminate(oldChild, 'SIGKILL');
+    }
+    if (!stopping) serviceChild = spawnService();
+  } finally {
+    restartingService = false;
+  }
+}
+
+async function waitForServiceLifetime() {
+  while (!stopping) {
+    const observedChild = serviceChild;
+    if (!observedChild) return { code: 1, signal: null };
+    const exit = await new Promise((resolve, reject) => {
+      observedChild.once('error', reject);
+      observedChild.once('exit', (code, signal) => resolve({ code, signal }));
+    });
+    while (restartingService && !stopping) await delay(10);
+    if (serviceChild !== observedChild) continue;
+    return exit;
+  }
+  return { code: 0, signal: null };
+}
+
+async function compileDist() {
+  const tsc = resolveProjectModule('typescript/bin/tsc');
+  await runCommand(
+    process.execPath,
+    [tsc, '--project', 'tsconfig.node.json', '--incremental'],
+    'typescript_compile'
+  );
+}
+
+function queueDistRebuild() {
+  if (compiling) {
+    compileQueued = true;
+    return;
+  }
+  compiling = true;
+  void (async () => {
+    try {
+      await compileDist();
+      await restartService(spawnDistService);
+      emit('source_restart', process.hrtime.bigint(), {
+        reason: 'dist-rebuilt',
+      });
+    } catch (error) {
+      process.stderr.write(
+        `${JSON.stringify({
+          event: 'miaoda_nest_dist_rebuild_failed',
+          error: error instanceof Error ? error.message : String(error),
+        })}\n`
+      );
+    } finally {
+      compiling = false;
+      if (compileQueued) {
+        compileQueued = false;
+        queueDistRebuild();
+      }
+    }
+  })();
+}
+
+async function runDependencyBackedMode(mode) {
+  await waitForDependencies();
+  await initializeActionPlugins();
+  if (mode === 'workspace') {
+    const spawnStartedAt = process.hrtime.bigint();
+    serviceChild = spawnWorkspaceService();
+    emit('process_spawn', spawnStartedAt, { pid: serviceChild.pid });
+  } else if (mode === 'dist') {
+    await compileDist();
+    const spawnStartedAt = process.hrtime.bigint();
+    serviceChild = spawnDistService();
+    emit('process_spawn', spawnStartedAt, {
+      pid: serviceChild.pid,
+      nodeEnv: 'development',
+      entry: 'dist/server/main.js',
+    });
+    watchSource(queueDistRebuild);
+  } else {
+    const spawnStartedAt = process.hrtime.bigint();
+    serviceChild = spawnTsNodeService();
+    emit('process_spawn', spawnStartedAt, {
+      pid: serviceChild.pid,
+      nodeEnv: 'development',
+      entry: 'server/main.ts',
+      transpileOnly: true,
+      preferTsExtensions: true,
+    });
+    watchSource(() => void restartService(spawnTsNodeService));
+  }
+  await waitForPort();
+  emit('startup', startedAt, { pid: serviceChild.pid, port: serverPort });
+  return waitForServiceLifetime();
+}
+
+async function runBundleHandoff() {
+  // Once dependencies exist, never put the stale bundle back in front during
+  // a supervisor retry. This preserves the original Preview failure/retry UI
+  // when the complete workspace service fails after the transition window.
+  if (workspaceDependenciesReady()) {
+    emit('bundle_skipped', process.hrtime.bigint(), {
+      reason: 'workspace-dependencies-ready',
+    });
+    return runDependencyBackedMode('workspace');
+  }
+  const runtime = path.join(scriptsRoot, 'server-cache-runtime.mjs');
+  if (!fs.existsSync(runtime)) {
+    markBundleFallback('runtime-missing');
+    process.stderr.write(
+      `${JSON.stringify({
+        event: 'miaoda_nest_bundle_unavailable',
+        reason: 'runtime-missing',
+      })}\n`
+    );
+    return runDependencyBackedMode('workspace');
+  }
+  const spawnStartedAt = process.hrtime.bigint();
+  serviceChild = spawnInherited(process.execPath, [runtime]);
+  emit('process_spawn', spawnStartedAt, {
+    pid: serviceChild.pid,
+    childRuntime: 'server-cache-runtime',
+  });
+  const exitPromise = new Promise((resolve, reject) => {
+    serviceChild.once('error', reject);
+    serviceChild.once('exit', (code, signal) => resolve({ code, signal }));
+  });
+  try {
+    await Promise.race([
+      waitForPort(),
+      exitPromise.then(exit => {
+        throw new Error(
+          `MIAODA_NEST_BUNDLE_EXITED_BEFORE_READY: code=${exit.code} signal=${exit.signal}`
+        );
+      }),
+    ]);
+    emit('startup', startedAt, { pid: serviceChild.pid, port: serverPort });
+    return exitPromise;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    markBundleFallback(reason);
+    process.stderr.write(
+      `${JSON.stringify({
+        event: 'miaoda_nest_bundle_fallback',
+        reason,
+      })}\n`
+    );
+    terminate(serviceChild);
+    return runDependencyBackedMode('workspace');
+  }
+}
+
+async function close(signal) {
+  if (stopping) return;
+  stopping = true;
+  clearTimeout(restartTimer);
+  sourceWatcher?.close();
+  terminate(compilerChild, signal);
+  terminate(serviceChild, signal);
+  setTimeout(() => {
+    terminate(compilerChild, 'SIGKILL');
+    terminate(serviceChild, 'SIGKILL');
+  }, 1_000).unref();
+}
+
+for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+  process.once(signal, () => void close(signal));
+}
+
+const exit =
+  requestedMode === 'bundle-handoff'
+    ? await runBundleHandoff()
+    : await runDependencyBackedMode(requestedMode);
+process.exit(exit?.code ?? (stopping ? 0 : 1));