@lark-apaas/fullstack-cli 1.1.66-alpha.20260904133055 → 1.1.66-alpha.20260908191831

package/dist/index.js

@@ -6009,7 +6009,7 @@ function addInjection(sourceFile) {
       type: PARAM_TYPE,
       scope: Scope.Private,
       isReadonly: true,
-      decorators: [{ name: "Inject", arguments: [] }]
+      decorators: [{ name: "Inject", arguments: ["CapabilityService"] }]
     });
   } else {
     classDecl.addConstructor({
@@ -6018,7 +6018,7 @@ function addInjection(sourceFile) {
         type: PARAM_TYPE,
         scope: Scope.Private,
         isReadonly: true,
-        decorators: [{ name: "Inject", arguments: [] }]
+        decorators: [{ name: "Inject", arguments: ["CapabilityService"] }]
       }]
     });
   }

package/package.json

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

package/templates/scripts/dev.js

@@ -5,7 +5,6 @@ const fs = require('fs');
 const path = require('path');
 const { spawn, execSync } = require('child_process');
 const readline = require('readline');
-const { buildNestServerArgs } = require('./nest-type-check.cjs');
 
 // ── Project root ──────────────────────────────────────────────────────────────
 const PROJECT_ROOT = path.resolve(__dirname, '..');
@@ -32,10 +31,9 @@ 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 SERVER_PORT = process.env.SERVER_PORT || '3000';
@@ -52,16 +50,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')
   );
 }
@@ -75,33 +68,21 @@ 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--; }
 }
 
 /** 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 ──────────────────────────────────────────────────
@@ -113,16 +94,11 @@ function killProcessGroup(pid, signal) {
 
 function killOrphansByPort(port) {
   try {
-    const pids = execSync(`lsof -ti :${port}`, {
-      encoding: 'utf8',
-      timeout: 5000,
-    }).trim();
+    const pids = execSync(`lsof -ti :${port}`, { encoding: 'utf8', timeout: 5000 }).trim();
     if (pids) {
       const pidList = pids.split('\n').filter(Boolean);
       for (const p of pidList) {
-        try {
-          process.kill(parseInt(p, 10), 'SIGKILL');
-        } catch {}
+        try { process.kill(parseInt(p, 10), 'SIGKILL'); } catch {}
       }
       return pidList;
     }
@@ -135,7 +111,7 @@ 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));
 }
 
 /**
@@ -165,23 +141,14 @@ function startProcess({ name, command, args, cleanupPort }) {
       entry.child = child;
 
       const startTime = Date.now();
-      logEvent(
-        'INFO',
-        name,
-        `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`
-      );
+      logEvent('INFO', name, `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`);
 
       // Pipe stdout and stderr through readline for timestamped logging
-      const pipeLines = stream => {
-        const rl = readline.createInterface({
-          input: stream,
-          crlfDelay: Infinity,
-        });
-        rl.on('line', line => {
+      const pipeLines = (stream) => {
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+        rl.on('line', (line) => {
           const msg = `[${timestamp()}] [${name}] ${line}\n`;
-          try {
-            fs.writeSync(logFd, msg);
-          } catch {}
+          try { fs.writeSync(logFd, msg); } catch {}
           writeOutput(msg);
         });
       };
@@ -192,8 +159,8 @@ function startProcess({ name, command, args, cleanupPort }) {
       // 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));
       });
 
@@ -210,11 +177,7 @@ function startProcess({ name, command, args, cleanupPort }) {
       if (cleanupPort) {
         const orphans = killOrphansByPort(cleanupPort);
         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);
         }
       }
@@ -224,38 +187,21 @@ function startProcess({ name, command, args, cleanupPort }) {
       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();
@@ -285,11 +231,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');
     }
   }
@@ -300,12 +242,8 @@ async function cleanup() {
 
   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);
 }
@@ -332,22 +270,17 @@ async function main() {
   // Initialize action plugins
   writeOutput('\n🔌 Initializing action plugins...\n');
   try {
-    execSync('fullstack-cli action-plugin init', {
-      cwd: PROJECT_ROOT,
-      stdio: 'inherit',
-    });
+    execSync('fullstack-cli action-plugin init', { cwd: PROJECT_ROOT, stdio: 'inherit' });
     writeOutput('✅ Action plugins initialized\n\n');
   } catch {
-    writeOutput(
-      '⚠️  Action plugin initialization failed, continuing anyway...\n\n'
-    );
+    writeOutput('⚠️  Action plugin initialization failed, continuing anyway...\n\n');
   }
 
   // Start server and client
   const serverPromise = startProcess({
     name: 'server',
     command: 'npm',
-    args: buildNestServerArgs({ projectRoot: PROJECT_ROOT, env: process.env }),
+    args: ['run', 'dev:server'],
     cleanupPort: SERVER_PORT,
   });
 
@@ -369,7 +302,7 @@ async function main() {
   }
 }
 
-main().catch(err => {
+main().catch((err) => {
   console.error('Fatal error:', err);
   process.exit(1);
 });

package/templates/scripts/nest-type-check.cjs

@@ -1,53 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const TYPE_CHECK_ENV = 'MIAODA_NEST_TYPE_CHECK_ENABLED';
-const DISABLED_CONFIG_RELATIVE_PATH = 'logs/nest-cli.type-check-disabled.json';
-
-/**
- * Build the npm arguments used to launch Nest in development.
- *
- * Missing or malformed values deliberately preserve the project's existing
- * nest-cli.json behavior.  The platform injects an exact true/false value;
- * exact true forces the checker on, while exact false writes a narrow runtime
- * config override so the checked-in project config is never mutated.
- */
-function buildNestServerArgs({ projectRoot, env = process.env }) {
-  const enabled = env[TYPE_CHECK_ENV];
-  if (enabled === 'true') {
-    return ['run', 'dev:server', '--', '--type-check'];
-  }
-  if (enabled !== 'false') {
-    return ['run', 'dev:server'];
-  }
-
-  const sourcePath = path.join(projectRoot, 'nest-cli.json');
-  const sourceConfig = JSON.parse(fs.readFileSync(sourcePath, 'utf8'));
-  const runtimeConfig = {
-    ...sourceConfig,
-    compilerOptions: {
-      ...(sourceConfig.compilerOptions || {}),
-      typeCheck: false,
-    },
-  };
-  const runtimePath = path.join(
-    projectRoot,
-    ...DISABLED_CONFIG_RELATIVE_PATH.split('/')
-  );
-  fs.mkdirSync(path.dirname(runtimePath), { recursive: true });
-  const temporaryPath = `${runtimePath}.${process.pid}.tmp`;
-  fs.writeFileSync(
-    temporaryPath,
-    `${JSON.stringify(runtimeConfig, null, 2)}\n`,
-    {
-      mode: 0o600,
-    }
-  );
-  fs.renameSync(temporaryPath, runtimePath);
-
-  return ['run', 'dev:server', '--', '--config', DISABLED_CONFIG_RELATIVE_PATH];
-}
-
-module.exports = { buildNestServerArgs };