@lark-apaas/fullstack-cli 1.1.59-alpha.20260722050835 → 1.1.59-alpha.20260722071909

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.59-alpha.20260722050835",
+  "version": "1.1.59-alpha.20260722071909",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",

package/templates/scripts/dev.js

@@ -8,9 +8,7 @@ const readline = require('readline');
 const {
   applyPreviewArtifactHostOverrides,
   buildListeningPortLookupArgs,
-  closePreviewPhaseReporterWithRetry,
   createDeferredTypecheckGate,
-  createPreviewPhaseFrameDecoder,
   createPreviewPhaseReporter,
   normalizeTcpPort,
   parseTscWatchSummary,
@@ -201,7 +199,6 @@ function startProcess({
   args,
   cleanupPort,
   phaseDetail = {},
-  phaseChannel = false,
   onReady,
   onOutputLine,
 }) {
@@ -239,23 +236,12 @@ function startProcess({
     }
 
     while (!stopping) {
-      const childEnv = { ...process.env };
-      // The parent is the only outbox writer. Child processes receive a narrow
-      // producer channel, never the filesystem destination.
-      delete childEnv.MIAODA_PREVIEW_PHASE_OUTBOX_ROOT;
-      if (phaseChannel) {
-        childEnv.MIAODA_PREVIEW_PHASE_FD = '3';
-      } else {
-        delete childEnv.MIAODA_PREVIEW_PHASE_FD;
-      }
       const child = spawn(command, args, {
         detached: true,
-        stdio: phaseChannel
-          ? ['ignore', 'pipe', 'pipe', 'pipe']
-          : ['ignore', 'pipe', 'pipe'],
+        stdio: ['ignore', 'pipe', 'pipe'],
         shell: true,
         cwd: PROJECT_ROOT,
-        env: childEnv,
+        env: { ...process.env },
       });
 
       entry.pid = child.pid;
@@ -321,24 +307,13 @@ function startProcess({
 
       // Pipe stdout and stderr through readline for timestamped logging
       let typecheckSummaryReported = false;
-      let phaseReported = false;
-      const pipeLines = (stream, allowPhaseFallback = false) => {
+      const pipeLines = stream => {
         const rl = readline.createInterface({
           input: stream,
           crlfDelay: Infinity,
         });
         rl.on('line', line => {
           if (onOutputLine) onOutputLine(line);
-          const legacyPhaseCandidate =
-            allowPhaseFallback && line.startsWith('[MiaodaPreviewPhase] ');
-          if (legacyPhaseCandidate && !phaseReported) {
-            phaseReported = previewPhaseReporter.ingest(line, {
-              producer: 'vite_plugin',
-              allowed_phases: ['vite_http_listening'],
-              attempt,
-              allow_legacy_stdout: true,
-            });
-          }
           if (name === 'server-typecheck' && !typecheckSummaryReported) {
             const summary = parseTscWatchSummary(line);
             if (summary) {
@@ -359,38 +334,11 @@ function startProcess({
           try {
             fs.writeSync(logFd, msg);
           } catch {}
-          // Phase fallbacks are normalized by the parent reporter before they
-          // enter the shared log. Keep the raw child claim quarantined in the
-          // component log so collectors never observe two representations.
-          if (!legacyPhaseCandidate) writeOutput(msg);
+          writeOutput(msg);
         });
       };
-      if (child.stdout) pipeLines(child.stdout, phaseChannel);
+      if (child.stdout) pipeLines(child.stdout);
       if (child.stderr) pipeLines(child.stderr);
-      if (phaseChannel && child.stdio[3]) {
-        let oversizedPhaseFrameReported = false;
-        const phaseDecoder = createPreviewPhaseFrameDecoder({
-          max_bytes: 16 * 1024,
-          on_oversized_frame: () => {
-            if (oversizedPhaseFrameReported) return;
-            oversizedPhaseFrameReported = true;
-            logEvent(
-              'WARN',
-              name,
-              'Dropped an oversized preview phase producer frame'
-            );
-          },
-          on_frame: line => {
-            if (phaseReported) return;
-            phaseReported = previewPhaseReporter.ingest(line, {
-              producer: 'vite_plugin',
-              allowed_phases: ['vite_http_listening'],
-              attempt,
-            });
-          },
-        });
-        child.stdio[3].on('data', chunk => phaseDecoder.push(chunk));
-      }
 
       // Wait for the direct child to exit.
       // NOTE: must use 'exit', not 'close'. With shell:true, grandchild processes
@@ -520,16 +468,6 @@ async function cleanup() {
 
   logEvent('INFO', 'main', 'All processes stopped');
 
-  const previewPhaseSealed =
-    await closePreviewPhaseReporterWithRetry(previewPhaseReporter);
-  if (!previewPhaseSealed) {
-    logEvent(
-      'ERROR',
-      'main',
-      'Preview phase outbox did not seal after bounded shutdown retries'
-    );
-  }
-
   try {
     fs.closeSync(devStdLogFd);
   } catch {}
@@ -537,7 +475,7 @@ async function cleanup() {
     fs.closeSync(devLogFd);
   } catch {}
 
-  process.exit(previewPhaseSealed ? 0 : 1);
+  process.exit(0);
 }
 
 process.on('SIGTERM', cleanup);
@@ -706,7 +644,6 @@ async function main() {
     command: 'npm',
     args: ['run', 'dev:client'],
     cleanupPort: CLIENT_DEV_PORT,
-    phaseChannel: true,
   });
 
   writeOutput(`📋 Dev processes running. Press Ctrl+C to stop.\n`);
@@ -720,14 +657,7 @@ async function main() {
   }
 }
 
-main().catch(async err => {
+main().catch(err => {
   console.error('Fatal error:', err);
-  const previewPhaseSealed =
-    await closePreviewPhaseReporterWithRetry(previewPhaseReporter);
-  if (!previewPhaseSealed) {
-    console.error(
-      'Preview phase outbox did not seal after bounded fatal-exit retries'
-    );
-  }
   process.exit(1);
 });

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

@@ -1,17 +1,11 @@
 'use strict';
 
 const fs = require('fs');
-const crypto = require('crypto');
 const net = require('net');
 const path = require('path');
-const {
-  MAX_EVENT_BYTES,
-  createFallbackSessionID,
-  createPreviewPhaseOutbox,
-} = require('./preview-phase-outbox.cjs');
 
 const PREFIX = '[MiaodaPreviewPhase] ';
-const RUN_ID_PATTERN = /^prv_[A-Za-z0-9_-]{1,60}$/;
+const RUN_ID_PATTERN = /^prv_[A-Za-z0-9_-]{1,128}$/;
 
 function resolveAppId(env) {
   const basePath = env.CLIENT_BASE_PATH || '';
@@ -19,457 +13,30 @@ function resolveAppId(env) {
   return match ? match[1] : env.MIAODA_APP_ID || '';
 }
 
-function createPreviewPhaseFrameDecoder(options = {}) {
-  const maxBytes = options.max_bytes || 16 * 1024;
-  const onFrame = options.on_frame;
-  const onOversizedFrame = options.on_oversized_frame || (() => {});
-  if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
-    throw new Error('preview phase frame max_bytes must be a positive integer');
-  }
-  if (typeof onFrame !== 'function') {
-    throw new Error('preview phase frame on_frame callback is required');
-  }
-
-  let pending = [];
-  let pendingBytes = 0;
-  let droppingOversizedFrame = false;
-
-  function reset() {
-    pending = [];
-    pendingBytes = 0;
-  }
-
-  function push(chunk) {
-    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    let offset = 0;
-    while (offset < buffer.length) {
-      const newline = buffer.indexOf(0x0a, offset);
-      const end = newline < 0 ? buffer.length : newline;
-      const segment = buffer.subarray(offset, end);
-
-      if (!droppingOversizedFrame) {
-        if (pendingBytes + segment.length > maxBytes) {
-          reset();
-          droppingOversizedFrame = true;
-          onOversizedFrame();
-        } else if (segment.length > 0) {
-          pending.push(segment);
-          pendingBytes += segment.length;
-        }
-      }
-
-      if (newline < 0) return;
-      if (!droppingOversizedFrame) {
-        onFrame(Buffer.concat(pending, pendingBytes).toString('utf8'));
-      }
-      reset();
-      droppingOversizedFrame = false;
-      offset = newline + 1;
-    }
-  }
-
-  return { push };
-}
-
 function createPreviewPhaseReporter(options = {}) {
   const env = options.env || process.env;
   const write = options.write || (line => process.stdout.write(`${line}\n`));
   const now = options.now || Date.now;
-  const randomUUID = options.random_uuid || crypto.randomUUID;
-  const producer = options.producer || 'dev_orchestrator';
-  const onDiagnostic =
-    options.on_diagnostic ||
-    (diagnostic => {
-      try {
-        process.stderr.write(
-          `[MiaodaPreviewOutbox] ${JSON.stringify(diagnostic)}\n`
-        );
-      } catch {
-        // Diagnostics must never block preview startup.
-      }
-    });
-  const producerInstanceID = randomUUID();
-  const fallbackSessionID =
-    options.fallback_session_id || createFallbackSessionID(randomUUID);
-  const runId = env.MIAODA_PREVIEW_RUN_ID || '';
-  let outbox = null;
-  let outboxInitializationError = null;
-  if (RUN_ID_PATTERN.test(runId)) {
-    try {
-      outbox = createPreviewPhaseOutbox({
-        root: options.outbox_root || env.MIAODA_PREVIEW_PHASE_OUTBOX_ROOT,
-        run_id: runId,
-        producer_epoch: env.MIAODA_PREVIEW_PHASE_PRODUCER_EPOCH,
-        expected_instance_id: env.MIAODA_PREVIEW_PHASE_INSTANCE_ID,
-        writer_instance_id: producerInstanceID,
-        producer_instance_id: producerInstanceID,
-        fallback_session_id: fallbackSessionID,
-        process_start_ticks: options.process_start_ticks,
-        get_process_start_ticks: options.get_process_start_ticks,
-        fs: options.fs,
-        register_producer: options.register_producer,
-        spawn_sync: options.spawn_sync,
-        random_uuid: randomUUID,
-        now,
-      });
-    } catch (error) {
-      outboxInitializationError = error;
-    }
-  }
-  const producerSequences = new Map();
-  let fallbackSequence = 0;
-  const startupTerminalPhases = new Set();
-  let reporterSealed = false;
-  let quiesceAcknowledged = false;
-  let terminalCloseScheduled = false;
-  let quiescePollTimer = null;
-
-  function reportDiagnostic(diagnostic) {
-    try {
-      onDiagnostic(diagnostic);
-    } catch {
-      // Diagnostics must never become a preview-startup failure mode.
-    }
-  }
 
-  function scheduleTerminalClose() {
-    if (terminalCloseScheduled || reporterSealed) return;
-    terminalCloseScheduled = true;
-    queueMicrotask(() => {
-      terminalCloseScheduled = false;
-      if (reporterSealed) return;
-      // backend_tcp_ready's synchronous onReady callback emits the initial
-      // deferred-typecheck decision immediately after the readiness event.
-      // Closing in a microtask keeps that terminal startup decision inside the
-      // same durable generation without extending the outbox into later source
-      // changes or daemon restarts.
-      flush();
-      close();
-    });
-  }
-
-  if (outboxInitializationError) {
-    reportDiagnostic({
-      code: 'outbox_initialization_failed',
-      run_id: runId,
-      error:
-        outboxInitializationError instanceof Error
-          ? outboxInitializationError.message
-          : String(outboxInitializationError),
-    });
-  }
-
-  function emitForProducer(eventProducer, phase, status, detail = {}) {
-    if (!RUN_ID_PATTERN.test(runId) || reporterSealed) return false;
+  function emit(phase, status, detail = {}) {
+    const runId = env.MIAODA_PREVIEW_RUN_ID || '';
+    if (!RUN_ID_PATTERN.test(runId)) return false;
     const atMs = detail.at_ms == null ? now() : detail.at_ms;
-    const producerSeq = (producerSequences.get(eventProducer) || 0) + 1;
-    producerSequences.set(eventProducer, producerSeq);
     const event = {
       ...detail,
       schema_version: 1,
-      event_id: `${runId}:${randomUUID()}`,
       run_id: runId,
       app_id: resolveAppId(env),
       sandbox_id: env.SANDBOX_ID || '',
       phase,
       status,
       at_ms: atMs,
-      producer: eventProducer,
-      producer_instance_id:
-        eventProducer === producer
-          ? producerInstanceID
-          : `${producerInstanceID}:${eventProducer}`,
-      producer_seq: producerSeq,
-      recorded_at_ms: now(),
-      transport: 'outbox',
     };
-    let serializedEvent = JSON.stringify(event);
-    if (Buffer.byteLength(serializedEvent, 'utf8') > MAX_EVENT_BYTES) {
-      reportDiagnostic({
-        code: 'event_rejected',
-        reason: 'event_too_large',
-        run_id: runId,
-        phase,
-        event_id: event.event_id,
-      });
-      return false;
-    }
-    let persisted = false;
-    // Stdout remains a diagnostic mirror. Only canonical append success or a
-    // fallback event fdatasync is delivery proof.
-    let fallbackSpoolPersisted = false;
-    if (!outbox) {
-      event.transport = 'stdout_fallback';
-      reportDiagnostic({
-        code: 'stdout_fallback_untracked',
-        run_id: runId,
-        phase,
-        event_id: event.event_id,
-      });
-    } else {
-      try {
-        persisted = outbox.append(event);
-      } catch (error) {
-        if (error?.code === 'PREVIEW_PHASE_EVENT_TOO_LARGE') {
-          reportDiagnostic({
-            code: 'event_rejected',
-            reason: 'event_too_large',
-            run_id: runId,
-            phase,
-            event_id: event.event_id,
-          });
-          return false;
-        }
-        const nextFallbackSequence = fallbackSequence + 1;
-        event.transport = 'fallback_spool';
-        event.fallback_session_id = fallbackSessionID;
-        event.fallback_seq = nextFallbackSequence;
-        try {
-          fallbackSpoolPersisted = outbox.append_fallback(event);
-          if (fallbackSpoolPersisted) {
-            fallbackSequence = nextFallbackSequence;
-          }
-        } catch (fallbackError) {
-          if (fallbackError?.code !== 'PREVIEW_PHASE_EVENT_TOO_LARGE') {
-            reportDiagnostic({
-              code: 'fallback_spool_failed',
-              run_id: runId,
-              phase,
-              event_id: event.event_id,
-              error:
-                fallbackError instanceof Error
-                  ? fallbackError.message
-                  : String(fallbackError),
-            });
-          }
-        }
-        if (!fallbackSpoolPersisted) {
-          event.transport = 'stdout_fallback';
-          delete event.fallback_session_id;
-          delete event.fallback_seq;
-          reportDiagnostic({
-            code: 'stdout_fallback_untracked',
-            run_id: runId,
-            phase,
-            event_id: event.event_id,
-          });
-        }
-        if (error?.code !== 'PREVIEW_PHASE_OUTBOX_DEGRADED') {
-          reportDiagnostic({
-            code: 'outbox_append_failed',
-            run_id: runId,
-            phase,
-            event_id: event.event_id,
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-      }
-    }
-    serializedEvent = JSON.stringify(event);
-    if (Buffer.byteLength(serializedEvent, 'utf8') > MAX_EVENT_BYTES) {
-      reportDiagnostic({
-        code: 'event_rejected',
-        reason: 'event_too_large',
-        run_id: runId,
-        phase,
-        event_id: event.event_id,
-      });
-      return false;
-    }
-    try {
-      write(`${PREFIX}${serializedEvent}`);
-    } catch (error) {
-      reportDiagnostic({
-        code: 'stdout_mirror_failed',
-        run_id: runId,
-        phase,
-        event_id: event.event_id,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-    const delivered = persisted || fallbackSpoolPersisted;
-    if (delivered && outbox?.is_local_sealed?.()) {
-      reporterSealed = true;
-      stopQuiescePolling();
-    }
-    if (
-      delivered &&
-      status !== 'start' &&
-      (phase === 'backend_tcp_ready' || phase === 'vite_http_listening')
-    ) {
-      startupTerminalPhases.add(phase);
-      if (startupTerminalPhases.size === 2) {
-        scheduleTerminalClose();
-      }
-    }
-    return delivered;
-  }
-
-  function emit(phase, status, detail = {}) {
-    return emitForProducer(producer, phase, status, detail);
-  }
-
-  function ingest(rawFrame, context = {}) {
-    if (
-      typeof rawFrame !== 'string' ||
-      Buffer.byteLength(rawFrame, 'utf8') > 16 * 1024
-    ) {
-      return false;
-    }
-    const isLegacyStdoutFrame =
-      context.allow_legacy_stdout === true && rawFrame.startsWith(PREFIX);
-    const serializedFrame = isLegacyStdoutFrame
-      ? rawFrame.slice(PREFIX.length).trim()
-      : rawFrame;
-    let frame;
-    try {
-      frame = JSON.parse(serializedFrame);
-    } catch {
-      return false;
-    }
-    const allowedPhases = Array.isArray(context.allowed_phases)
-      ? context.allowed_phases
-      : [];
-    if (
-      (!isLegacyStdoutFrame &&
-        frame?.protocol !== 'preview_phase_producer_v1') ||
-      frame.schema_version !== 1 ||
-      frame.run_id !== runId ||
-      !allowedPhases.includes(frame.phase) ||
-      !/^(?:start|success|error|fallback|skipped|cancelled)$/.test(
-        frame.status || ''
-      ) ||
-      !Number.isFinite(frame.at_ms) ||
-      frame.at_ms <= 0
-    ) {
-      return false;
-    }
-    const detail = {
-      at_ms: frame.at_ms,
-      ...(Number.isFinite(frame.duration_ms) && frame.duration_ms >= 0
-        ? { duration_ms: frame.duration_ms }
-        : {}),
-      ...(Number.isFinite(frame.precision_ms) && frame.precision_ms >= 0
-        ? { precision_ms: frame.precision_ms }
-        : {}),
-      ...(typeof frame.exact === 'boolean' ? { exact: frame.exact } : {}),
-      ...(Number.isSafeInteger(context.attempt) && context.attempt > 0
-        ? { attempt: context.attempt }
-        : {}),
-    };
-    return emitForProducer(
-      context.producer || 'child_process',
-      frame.phase,
-      frame.status,
-      detail
-    );
-  }
-
-  function flush() {
-    if (reporterSealed) return true;
-    if (!outbox) return outboxInitializationError == null;
-    try {
-      return outbox.flush();
-    } catch (error) {
-      reportDiagnostic({
-        code: 'outbox_flush_failed',
-        run_id: runId,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return false;
-    }
-  }
-
-  function stopQuiescePolling() {
-    if (quiescePollTimer == null) return;
-    clearInterval(quiescePollTimer);
-    quiescePollTimer = null;
-  }
-
-  function pollQuiesce() {
-    if (reporterSealed) return quiesceAcknowledged;
-    if (!outbox) return false;
-    try {
-      const quiesce = outbox.poll_quiesce();
-      if (quiesce.local_sealed) {
-        reporterSealed = true;
-        quiesceAcknowledged = quiesce.canonical_acknowledged;
-        stopQuiescePolling();
-      }
-      return quiesce.canonical_acknowledged;
-    } catch (error) {
-      reportDiagnostic({
-        code: 'outbox_quiesce_failed',
-        run_id: runId,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return false;
-    }
-  }
-
-  function close() {
-    if (reporterSealed) return true;
-    if (!outbox) return outboxInitializationError == null;
-    try {
-      const sealed = outbox.close();
-      if (sealed) {
-        reporterSealed = true;
-        stopQuiescePolling();
-      }
-      return sealed;
-    } catch (error) {
-      reportDiagnostic({
-        code: 'outbox_close_failed',
-        run_id: runId,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return false;
-    }
-  }
-
-  if (outbox) {
-    const intervalMs = options.quiesce_poll_interval_ms ?? 100;
-    if (Number.isSafeInteger(intervalMs) && intervalMs > 0) {
-      quiescePollTimer = setInterval(pollQuiesce, intervalMs);
-      if (typeof quiescePollTimer.unref === 'function') {
-        quiescePollTimer.unref();
-      }
-    }
-  }
-
-  return { emit, ingest, flush, close, pollQuiesce };
-}
-
-async function closePreviewPhaseReporterWithRetry(reporter, options = {}) {
-  const retryDelaysMs = options.retry_delays_ms || [0, 25, 100, 250, 500, 1000];
-  const sleep =
-    options.sleep ||
-    (delayMs => new Promise(resolve => setTimeout(resolve, delayMs)));
-  if (
-    !reporter ||
-    typeof reporter.flush !== 'function' ||
-    typeof reporter.close !== 'function' ||
-    !Array.isArray(retryDelaysMs) ||
-    retryDelaysMs.length === 0 ||
-    retryDelaysMs.some(delayMs => !Number.isSafeInteger(delayMs) || delayMs < 0)
-  ) {
-    throw new Error('invalid preview phase reporter close retry configuration');
+    write(`${PREFIX}${JSON.stringify(event)}`);
+    return true;
   }
 
-  for (const delayMs of retryDelaysMs) {
-    if (delayMs > 0) await sleep(delayMs);
-    try {
-      reporter.flush();
-    } catch {
-      // close() repeats the durable flush and reports the authoritative result.
-    }
-    try {
-      if (reporter.close()) return true;
-    } catch {
-      // A later bounded attempt may succeed after a transient filesystem fault.
-    }
-  }
-  return false;
+  return { emit };
 }
 
 function createTscServerCommand(reason, missingModules = []) {
@@ -882,9 +449,7 @@ async function waitForTcpReady(options) {
 module.exports = {
   applyPreviewArtifactHostOverrides,
   buildListeningPortLookupArgs,
-  closePreviewPhaseReporterWithRetry,
   createDeferredTypecheckGate,
-  createPreviewPhaseFrameDecoder,
   createPreviewPhaseReporter,
   normalizeTcpPort,
   parseTscWatchSummary,