@lark-apaas/fullstack-cli 1.1.59-alpha.20260719124023 → 1.1.59-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.59-alpha.20260719124023",
+  "version": "1.1.59-alpha.3",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",
@@ -34,15 +34,12 @@
     "@lark-apaas/http-client": "^0.1.7",
     "@lydell/node-pty": "1.1.0",
     "@vercel/nft": "^0.30.3",
-    "acorn": "^8.16.0",
-    "acorn-walk": "^8.3.5",
     "commander": "^13.0.0",
     "debug": "^4.4.3",
     "dotenv": "^16.0.0",
     "drizzle-kit": "0.31.5",
     "drizzle-orm": "0.44.6",
     "es-toolkit": "^1.44.0",
-    "esbuild": "^0.27.0",
     "inflection": "^3.0.2",
     "pinyin-pro": "^3.27.0",
     "postgres": "^3.4.3",

package/templates/scripts/dev.js

@@ -6,13 +6,10 @@ const path = require('path');
 const { spawn, execFileSync, execSync } = require('child_process');
 const readline = require('readline');
 const {
-  applyPreviewArtifactHostOverrides,
   buildListeningPortLookupArgs,
-  createDeferredTypecheckGate,
   createPreviewPhaseReporter,
   normalizeTcpPort,
   parseTscWatchSummary,
-  resolvePreviewArtifactPorts,
   resolvePreviewServerCommand,
   waitForTcpReady,
 } = require('./preview-startup-timing.cjs');
@@ -42,34 +39,17 @@ loadEnv();
 
 // ── Configuration ─────────────────────────────────────────────────────────────
 const LOG_DIR = process.env.LOG_DIR || 'logs';
-const MAX_RESTART_COUNT =
-  process.env.MAX_RESTART_COUNT != null && process.env.MAX_RESTART_COUNT !== ''
-    ? parseInt(process.env.MAX_RESTART_COUNT, 10)
-    : Infinity;
+const MAX_RESTART_COUNT = process.env.MAX_RESTART_COUNT != null && process.env.MAX_RESTART_COUNT !== ''
+  ? parseInt(process.env.MAX_RESTART_COUNT, 10)
+  : Infinity;
 const RESTART_DELAY = parseInt(process.env.RESTART_DELAY, 10) || 2;
 const MAX_DELAY = 8;
-const configuredServerPort = normalizeTcpPort(
-  process.env.SERVER_PORT,
-  3000,
-  'SERVER_PORT'
-);
-const configuredClientDevPort = normalizeTcpPort(
+const SERVER_PORT = normalizeTcpPort(process.env.SERVER_PORT, 3000, 'SERVER_PORT');
+const CLIENT_DEV_PORT = normalizeTcpPort(
   process.env.CLIENT_DEV_PORT,
   8080,
   'CLIENT_DEV_PORT'
 );
-const previewArtifactPorts = resolvePreviewArtifactPorts({
-  marker_file:
-    process.env.PREVIEW_ARTIFACT_RUNTIME_MARKER ||
-    '/tmp/preview-artifact/runtime.json',
-  server_port: configuredServerPort,
-  client_port: configuredClientDevPort,
-});
-applyPreviewArtifactHostOverrides(previewArtifactPorts, process.env);
-const SERVER_PORT = previewArtifactPorts.server_port;
-const CLIENT_DEV_PORT = previewArtifactPorts.client_port;
-process.env.SERVER_PORT = String(SERVER_PORT);
-process.env.CLIENT_DEV_PORT = String(CLIENT_DEV_PORT);
 
 fs.mkdirSync(LOG_DIR, { recursive: true });
 
@@ -82,16 +62,11 @@ const devLogFd = fs.openSync(devLogPath, 'a');
 function timestamp() {
   const now = new Date();
   return (
-    now.getFullYear() +
-    '-' +
-    String(now.getMonth() + 1).padStart(2, '0') +
-    '-' +
-    String(now.getDate()).padStart(2, '0') +
-    ' ' +
-    String(now.getHours()).padStart(2, '0') +
-    ':' +
-    String(now.getMinutes()).padStart(2, '0') +
-    ':' +
+    now.getFullYear() + '-' +
+    String(now.getMonth() + 1).padStart(2, '0') + '-' +
+    String(now.getDate()).padStart(2, '0') + ' ' +
+    String(now.getHours()).padStart(2, '0') + ':' +
+    String(now.getMinutes()).padStart(2, '0') + ':' +
     String(now.getSeconds()).padStart(2, '0')
   );
 }
@@ -105,37 +80,25 @@ const STDOUT_MAX_INFLIGHT = 1000;
 function writeOutput(msg) {
   // File first and synchronously — read-logs reads this file; it must never be gated
   // by the terminal consumer.
-  try {
-    fs.writeSync(devStdLogFd, msg);
-  } catch {}
+  try { fs.writeSync(devStdLogFd, msg); } catch {}
   // stdout mirror via async fs.write: if process.stdout is a pty/pipe whose consumer
   // stalls, the block happens on the libuv threadpool, NOT the event loop — so the
   // synchronous log-FILE writes above (and subsequent readline callbacks) keep running.
   // Drop overflow when too many writes are already pending (best-effort mirror).
-  if (_stdoutInFlight >= STDOUT_MAX_INFLIGHT) {
-    return;
-  }
+  if (_stdoutInFlight >= STDOUT_MAX_INFLIGHT) { return; }
   _stdoutInFlight++;
-  try {
-    fs.write(1, msg, () => {
-      _stdoutInFlight--;
-    });
-  } catch {
-    _stdoutInFlight--;
-  }
+  try { fs.write(1, msg, () => { _stdoutInFlight--; }); } catch { _stdoutInFlight--; }
 }
 
 const previewPhaseReporter = createPreviewPhaseReporter({
-  write: line => writeOutput(`${line}\n`),
+  write: (line) => writeOutput(`${line}\n`),
 });
 
 /** Structured event log → terminal + dev.std.log + dev.log */
 function logEvent(level, name, message) {
   const msg = `[${timestamp()}] [${level}] [${name}] ${message}\n`;
   writeOutput(msg);
-  try {
-    fs.writeSync(devLogFd, msg);
-  } catch {}
+  try { fs.writeSync(devLogFd, msg); } catch {}
 }
 
 // ── Process group management ──────────────────────────────────────────────────
@@ -186,22 +149,14 @@ let stopping = false;
 const managedProcesses = []; // { name, pid, child }
 
 function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 /**
  * Start and supervise a process with auto-restart and log piping.
  * Returns a promise that resolves when the process loop ends.
  */
-function startProcess({
-  name,
-  command,
-  args,
-  cleanupPort,
-  phaseDetail = {},
-  onReady,
-  onOutputLine,
-}) {
+function startProcess({ name, command, args, cleanupPort, phaseDetail = {}, onReady }) {
   const logFilePath = path.join(LOG_DIR, `${name}.std.log`);
   const logFd = fs.openSync(logFilePath, 'a');
 
@@ -220,8 +175,8 @@ function startProcess({
         portCleanup.error
           ? `Port ${cleanupPort} preflight failed: ${portCleanup.error}`
           : stalePids.length > 0
-            ? `Killed stale processes on port ${cleanupPort} before first spawn: ${stalePids.join(' ')}`
-            : `Port ${cleanupPort} is clear before first spawn`
+          ? `Killed stale processes on port ${cleanupPort} before first spawn: ${stalePids.join(' ')}`
+          : `Port ${cleanupPort} is clear before first spawn`
       );
       previewPhaseReporter.emit(
         name === 'server' ? 'backend_port_preflight' : 'client_port_preflight',
@@ -249,11 +204,7 @@ function startProcess({
 
       const startTime = Date.now();
       const attempt = restartCount + 1;
-      logEvent(
-        'INFO',
-        name,
-        `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`
-      );
+      logEvent('INFO', name, `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`);
       const processPhase =
         name === 'server'
           ? 'backend_process_spawn'
@@ -307,13 +258,9 @@ function startProcess({
 
       // Pipe stdout and stderr through readline for timestamped logging
       let typecheckSummaryReported = false;
-      const pipeLines = stream => {
-        const rl = readline.createInterface({
-          input: stream,
-          crlfDelay: Infinity,
-        });
-        rl.on('line', line => {
-          if (onOutputLine) onOutputLine(line);
+      const pipeLines = (stream) => {
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+        rl.on('line', (line) => {
           if (name === 'server-typecheck' && !typecheckSummaryReported) {
             const summary = parseTscWatchSummary(line);
             if (summary) {
@@ -331,9 +278,7 @@ function startProcess({
             }
           }
           const msg = `[${timestamp()}] [${name}] ${line}\n`;
-          try {
-            fs.writeSync(logFd, msg);
-          } catch {}
+          try { fs.writeSync(logFd, msg); } catch {}
           writeOutput(msg);
         });
       };
@@ -344,8 +289,8 @@ function startProcess({
       // NOTE: must use 'exit', not 'close'. With shell:true, grandchild processes
       // (e.g. nest's server) inherit stdout pipes. 'close' won't fire until ALL
       // pipe holders exit, causing dev.js to hang when npm/nest dies but server survives.
-      const exitCode = await new Promise(resolve => {
-        child.on('exit', code => resolve(code ?? 1));
+      const exitCode = await new Promise((resolve) => {
+        child.on('exit', (code) => resolve(code ?? 1));
         child.on('error', () => resolve(1));
       });
 
@@ -370,11 +315,7 @@ function startProcess({
           );
         }
         if (orphans.length > 0) {
-          logEvent(
-            'WARN',
-            name,
-            `Killed orphan processes on port ${cleanupPort}: ${orphans.join(' ')}`
-          );
+          logEvent('WARN', name, `Killed orphan processes on port ${cleanupPort}: ${orphans.join(' ')}`);
           await sleep(500);
         }
       }
@@ -384,38 +325,21 @@ function startProcess({
       const runDuration = (Date.now() - startTime) / 1000;
       if (runDuration >= 60) {
         restartCount = 0;
-        logEvent(
-          'INFO',
-          name,
-          `Ran for ${Math.round(runDuration)}s, resetting restart counter`
-        );
+        logEvent('INFO', name, `Ran for ${Math.round(runDuration)}s, resetting restart counter`);
       } else {
         restartCount++;
       }
       if (restartCount >= MAX_RESTART_COUNT) {
-        logEvent(
-          'ERROR',
-          name,
-          `Max restart count (${MAX_RESTART_COUNT}) reached, giving up`
-        );
+        logEvent('ERROR', name, `Max restart count (${MAX_RESTART_COUNT}) reached, giving up`);
         break;
       }
 
-      const delay = Math.min(
-        RESTART_DELAY * (1 << Math.max(0, restartCount - 1)),
-        MAX_DELAY
-      );
-      logEvent(
-        'WARN',
-        name,
-        `Process exited with code ${exitCode}, restarting (${restartCount}/${MAX_RESTART_COUNT}) in ${delay}s...`
-      );
+      const delay = Math.min(RESTART_DELAY * (1 << Math.max(0, restartCount - 1)), MAX_DELAY);
+      logEvent('WARN', name, `Process exited with code ${exitCode}, restarting (${restartCount}/${MAX_RESTART_COUNT}) in ${delay}s...`);
       await sleep(delay * 1000);
     }
 
-    try {
-      fs.closeSync(logFd);
-    } catch {}
+    try { fs.closeSync(logFd); } catch {}
   };
 
   return run();
@@ -445,11 +369,7 @@ async function cleanup() {
   // Force kill any remaining
   for (const entry of managedProcesses) {
     if (entry.pid) {
-      logEvent(
-        'WARN',
-        'main',
-        `Force killing process group (PGID: ${entry.pid})`
-      );
+      logEvent('WARN', 'main', `Force killing process group (PGID: ${entry.pid})`);
       killProcessGroup(entry.pid, 'SIGKILL');
     }
   }
@@ -458,22 +378,14 @@ async function cleanup() {
   for (const port of [SERVER_PORT, CLIENT_DEV_PORT]) {
     const portCleanup = killOrphansByPort(port);
     if (portCleanup.error) {
-      logEvent(
-        'ERROR',
-        'main',
-        `Port ${port} cleanup failed: ${portCleanup.error}`
-      );
+      logEvent('ERROR', 'main', `Port ${port} cleanup failed: ${portCleanup.error}`);
     }
   }
 
   logEvent('INFO', 'main', 'All processes stopped');
 
-  try {
-    fs.closeSync(devStdLogFd);
-  } catch {}
-  try {
-    fs.closeSync(devLogFd);
-  } catch {}
+  try { fs.closeSync(devStdLogFd); } catch {}
+  try { fs.closeSync(devLogFd); } catch {}
 
   process.exit(0);
 }
@@ -494,22 +406,7 @@ function cleanStaleDist() {
 // ── Main ──────────────────────────────────────────────────────────────────────
 async function main() {
   logEvent('INFO', 'main', '========== Dev session started ==========');
-  previewPhaseReporter.emit('dev_orchestrator_start', 'success', {
-    exact: true,
-  });
-  if (previewArtifactPorts.cache_active) {
-    logEvent(
-      'INFO',
-      'main',
-      `Cached generation ${previewArtifactPorts.generation_id} is serving; starting fresh services on shadow ports ${SERVER_PORT}/${CLIENT_DEV_PORT}`
-    );
-    previewPhaseReporter.emit('preview_artifact_shadow_start', 'success', {
-      exact: true,
-      generation_id: previewArtifactPorts.generation_id,
-      fresh_server_port: SERVER_PORT,
-      fresh_client_port: CLIENT_DEV_PORT,
-    });
-  }
+  previewPhaseReporter.emit('dev_orchestrator_start', 'success', { exact: true });
 
   cleanStaleDist();
 
@@ -521,10 +418,7 @@ async function main() {
     exact: true,
   });
   try {
-    execSync('fullstack-cli action-plugin init', {
-      cwd: PROJECT_ROOT,
-      stdio: 'inherit',
-    });
+    execSync('fullstack-cli action-plugin init', { cwd: PROJECT_ROOT, stdio: 'inherit' });
     previewPhaseReporter.emit('action_plugin_init', 'success', {
       duration_ms: Date.now() - actionPluginStartedAt,
       exact: true,
@@ -536,9 +430,7 @@ async function main() {
       exact: true,
       error: error instanceof Error ? error.message : String(error),
     });
-    writeOutput(
-      '⚠️  Action plugin initialization failed, continuing anyway...\n\n'
-    );
+    writeOutput('⚠️  Action plugin initialization failed, continuing anyway...\n\n');
   }
 
   // Start server and client
@@ -558,20 +450,18 @@ async function main() {
     reason: serverCommand.reason,
     missing_modules: serverCommand.missing_modules,
   });
-  const typecheckGate = createDeferredTypecheckGate();
   let serverTypecheckStarted = false;
-  const startServerTypecheck = trigger => {
+  const startServerTypecheck = () => {
     if (serverTypecheckStarted || !serverCommand.type_check_command) return;
     try {
       logEvent(
         'INFO',
         'server-typecheck',
-        `Starting deferred server type checker after ${trigger}`
+        'Starting deferred server type checker after backend TCP ready'
       );
       previewPhaseReporter.emit('backend_typecheck_deferred_start', 'success', {
         exact: true,
         type_check_mode: serverCommand.type_check_mode,
-        trigger,
       });
       const typecheckPromise = startProcess({
         name: 'server-typecheck',
@@ -600,30 +490,6 @@ async function main() {
       );
     }
   };
-  const handleBackendReady = () => {
-    if (!serverCommand.type_check_command) return;
-    const decision = typecheckGate.onBackendReady();
-    if (decision.should_start) {
-      startServerTypecheck(decision.reason);
-      return;
-    }
-    logEvent(
-      'INFO',
-      'server-typecheck',
-      'Skipped type checking during initial preview startup'
-    );
-    previewPhaseReporter.emit('backend_typecheck_skipped', 'success', {
-      exact: true,
-      type_check_mode: serverCommand.type_check_mode,
-      reason: decision.reason,
-      next_trigger: 'source_change_or_backend_restart',
-    });
-  };
-  const handleServerOutput = line => {
-    if (!serverCommand.type_check_command || serverTypecheckStarted) return;
-    const decision = typecheckGate.onCompilerOutput(line);
-    if (decision?.should_start) startServerTypecheck(decision.reason);
-  };
   const serverPromise = startProcess({
     name: 'server',
     command: serverCommand.command,
@@ -635,8 +501,7 @@ async function main() {
       type_check_mode: serverCommand.type_check_mode,
       compiler_selection_reason: serverCommand.reason,
     },
-    onReady: handleBackendReady,
-    onOutputLine: handleServerOutput,
+    onReady: startServerTypecheck,
   });
 
   const clientPromise = startProcess({
@@ -657,7 +522,7 @@ async function main() {
   }
 }
 
-main().catch(err => {
+main().catch((err) => {
   console.error('Fatal error:', err);
   process.exit(1);
 });

package/templates/scripts/preview-startup-timing.cjs

@@ -70,53 +70,6 @@ function buildListeningPortLookupArgs(port) {
   return [`-tiTCP:${validatedPort}`, '-sTCP:LISTEN'];
 }
 
-function resolvePreviewArtifactPorts(options) {
-  const fallback = {
-    cache_active: false,
-    server_port: normalizeTcpPort(options.server_port, 3000, 'SERVER_PORT'),
-    client_port: normalizeTcpPort(options.client_port, 8080, 'CLIENT_DEV_PORT'),
-    generation_id: '',
-  };
-  try {
-    const markerStat = fs.lstatSync(options.marker_file);
-    if (!markerStat.isFile() || markerStat.isSymbolicLink()) return fallback;
-    const marker = JSON.parse(fs.readFileSync(options.marker_file, 'utf8'));
-    if (
-      marker?.schemaVersion !== 1 ||
-      !['cached-serving', 'fresh-serving'].includes(marker?.status) ||
-      !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(marker?.generationId || '')
-    ) {
-      return fallback;
-    }
-    return {
-      cache_active: true,
-      server_port: normalizeTcpPort(
-        marker.freshServerPort,
-        fallback.server_port,
-        'freshServerPort'
-      ),
-      client_port: normalizeTcpPort(
-        marker.freshClientPort,
-        fallback.client_port,
-        'freshClientPort'
-      ),
-      generation_id: marker.generationId,
-    };
-  } catch {
-    return fallback;
-  }
-}
-
-function applyPreviewArtifactHostOverrides(ports, environment) {
-  if (!ports.cache_active) return false;
-  // Cached runtime and switcher use an explicit IPv4 loopback endpoint. Pin
-  // both shadow services to the same address family; Linux commonly resolves
-  // `localhost` to IPv6-only ::1, which otherwise makes cutover impossible.
-  environment.SERVER_HOST = '127.0.0.1';
-  environment.CLIENT_DEV_HOST = '127.0.0.1';
-  return true;
-}
-
 function hasRuntimeCompilerPluginConsumer(projectRoot, sourceRoot) {
   const root = path.resolve(projectRoot, sourceRoot || 'src');
   const stack = [root];
@@ -316,38 +269,6 @@ function resolvePreviewServerCommand(options = {}) {
   };
 }
 
-function createDeferredTypecheckGate() {
-  let initialBackendReadySeen = false;
-
-  return {
-    onBackendReady() {
-      if (!initialBackendReadySeen) {
-        initialBackendReadySeen = true;
-        return {
-          should_start: false,
-          reason: 'initial_preview_startup',
-        };
-      }
-      return {
-        should_start: true,
-        reason: 'backend_restart',
-      };
-    },
-    onCompilerOutput(line) {
-      if (
-        !initialBackendReadySeen ||
-        !/Successfully compiled:\s+\d+\s+files?\s+with\s+swc\b/i.test(line)
-      ) {
-        return null;
-      }
-      return {
-        should_start: true,
-        reason: 'source_change',
-      };
-    },
-  };
-}
-
 function parseTscWatchSummary(line) {
   const match = /Found\s+(\d+)\s+errors?\.\s+Watching for file changes\./i.exec(
     line
@@ -447,13 +368,10 @@ async function waitForTcpReady(options) {
 }
 
 module.exports = {
-  applyPreviewArtifactHostOverrides,
   buildListeningPortLookupArgs,
-  createDeferredTypecheckGate,
   createPreviewPhaseReporter,
   normalizeTcpPort,
   parseTscWatchSummary,
-  resolvePreviewArtifactPorts,
   resolvePreviewServerCommand,
   waitForTcpReady,
 };