start .ts app with node native type stripping

Author: Unitech

README.md

@@ -85,6 +85,8 @@ You can start any application (Node.js, Bun, and also Python, Ruby, binaries in
 
 ```bash
 $ pm2 start app.js
+$ pm2 start app.ts
+$ pm2 start app.py
 ```
 
 Your app is now daemonized, monitored and kept alive forever.

lib/Common.js

@@ -423,6 +423,25 @@ Common.sink.resolveInterpreter = function(app) {
     app.exec_interpreter = process.execPath;
   }
 
+  // TypeScript support: .ts maps to bun, but when bun is not installed
+  // fall back to node type stripping when the node version supports it
+  if (noInterpreter && extName == '.ts' && betterInterpreter == 'bun' &&
+      cst.IS_BUN === false && which('bun') == null) {
+    var typestrip = require('./tools/typestrip.js');
+    var ts_support = typestrip.supportLevel(typestrip.resolvedNodeVersion());
+
+    if (ts_support === false)
+      throw new Error('TypeScript apps require bun, Node.js >= 22.18 (native type stripping) or a custom interpreter (e.g. --interpreter ts-node)');
+
+    betterInterpreter = 'node';
+    if (ts_support === 'flag') {
+      if (!app.node_args)
+        app.node_args = [];
+      if (app.node_args.indexOf('--experimental-strip-types') === -1)
+        app.node_args.push('--experimental-strip-types');
+    }
+  }
+
   // No interpreter defined and correspondance in schema hashmap
   if (noInterpreter && betterInterpreter) {
     app.exec_interpreter = betterInterpreter;

lib/God/ClusterMode.js

@@ -11,8 +11,10 @@
  * @project PM2
  */
 var cluster       = require('cluster');
+var path          = require('path');
 var Utility       = require('../Utility.js');
 var pkg           = require('../../package.json');
+var typestrip     = require('../tools/typestrip.js');
 
 /**
  * Description
@@ -38,6 +40,15 @@ module.exports = function ClusterMode(God) {
       cluster.settings.execArgv = env_copy.node_args;
     }
 
+    // Cluster workers run on the daemon's node, whose version can differ
+    // from the CLI that resolved the interpreter: ensure type stripping
+    // is active for .ts apps when this node needs the flag
+    if (path.extname(env_copy.pm_exec_path || '') === '.ts' &&
+        typestrip.supportLevel(process.versions.node) === 'flag' &&
+        cluster.settings.execArgv.indexOf('--experimental-strip-types') === -1) {
+      cluster.settings.execArgv = cluster.settings.execArgv.concat('--experimental-strip-types');
+    }
+
     env_copy._pm2_version = pkg.version;
 
     try {

lib/ProcessContainer.js

@@ -110,13 +110,7 @@ delete process.env.pm2_env;
  * @return
  */
 function exec(script, stds) {
-  if (p.extname(script) == '.ts' || p.extname(script) == '.tsx') {
-    try {
-      require('ts-node/register');
-    } catch (e) {
-      console.error('Failed to load Typescript interpreter:', e.message || e);
-    }
-  }
+  ProcessUtils.enableTypeScript(script, pm2_env.pm_cwd);
 
   process.on('message', function (msg) {
     if (msg.type === 'log:reload') {

lib/ProcessContainerFork.js

@@ -25,6 +25,7 @@ if (process.connected &&
 
 // Require the real application
 if (process.env.pm_exec_path) {
+  ProcessUtils.enableTypeScript(process.env.pm_exec_path, process.env.pm_cwd);
   if (ProcessUtils.isESModule(process.env.pm_exec_path) === true) {
     import(url.pathToFileURL(process.env.pm_exec_path));
   }

lib/ProcessUtils.js

@@ -19,6 +19,29 @@ module.exports = {
       }, conf))
     }
   },
+  enableTypeScript(exec_path, cwd) {
+    var path = require('path')
+    var ext = path.extname(exec_path || '')
+
+    if (ext !== '.ts' && ext !== '.tsx')
+      return
+
+    // .ts needs nothing when the runtime already strips types
+    // (enabled by default on node >= 22.18 / >= 23.6, or via flag);
+    // .tsx always needs a transformer
+    var stripping = (process.features && process.features.typescript) ||
+        process.execArgv.indexOf('--experimental-strip-types') !== -1 ||
+        process.execArgv.indexOf('--experimental-transform-types') !== -1
+    if (ext === '.ts' && stripping)
+      return
+
+    // Resolve ts-node from the application dependencies, not from PM2's
+    try {
+      require(require.resolve('ts-node/register', { paths: [cwd || path.dirname(exec_path)] }))
+    } catch (e) {
+      console.error('TypeScript support unavailable: install ts-node in your project or use Node.js >= 22.18 (%s)', e.message || e)
+    }
+  },
   isESModule(exec_path) {
     var fs = require('fs')
     var path = require('path')

lib/tools/typestrip.js

@@ -0,0 +1,55 @@
+
+var fs = require('fs');
+var semver = require('semver');
+var execSync = require('child_process').execSync;
+var which = require('./which.js');
+
+// Node.js type stripping availability:
+// enabled by default since 22.18.0 (22.x line) and 23.6.0,
+// behind --experimental-strip-types since 22.6.0.
+var NATIVE_RANGE = '>=22.18.0 <23.0.0 || >=23.6.0';
+var FLAG_RANGE   = '>=22.6.0';
+
+var resolved_node_version = null;
+
+/**
+ * Type stripping support of a given node version.
+ * Returns 'native' (runs .ts without flags), 'flag'
+ * (needs --experimental-strip-types) or false.
+ */
+function supportLevel(version) {
+  if (semver.satisfies(version, NATIVE_RANGE))
+    return 'native';
+  if (semver.satisfies(version, FLAG_RANGE))
+    return 'flag';
+  return false;
+}
+
+/**
+ * Version of the `node` binary fork mode will spawn (the one in PATH),
+ * which can differ from the node running PM2.
+ */
+function resolvedNodeVersion() {
+  if (resolved_node_version)
+    return resolved_node_version;
+
+  var node_path = which('node');
+  if (node_path == null)
+    return resolved_node_version = process.versions.node;
+
+  try {
+    if (fs.realpathSync(node_path) === fs.realpathSync(process.execPath))
+      return resolved_node_version = process.versions.node;
+    resolved_node_version = execSync(JSON.stringify(node_path) + ' --version', {
+      encoding: 'utf8'
+    }).trim().replace(/^v/, '');
+  } catch(e) {
+    resolved_node_version = process.versions.node;
+  }
+  return resolved_node_version;
+}
+
+module.exports = {
+  supportLevel: supportLevel,
+  resolvedNodeVersion: resolvedNodeVersion
+};

test/e2e.sh

@@ -16,6 +16,7 @@ runTest ./test/e2e/cli/reload.sh
 runTest ./test/e2e/cli/start-app.sh
 runTest ./test/e2e/cli/operate-regex.sh
 #runTest ./test/e2e/cli/bun.sh
+runTest ./test/e2e/cli/typescript.sh
 runTest ./test/e2e/cli/app-configuration.sh
 runTest ./test/e2e/cli/binary.sh
 runTest ./test/e2e/cli/startOrX.sh

test/e2e/cli/typescript.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+
+SRC=$(cd $(dirname "$0"); pwd)
+source "${SRC}/../include.sh"
+
+cd $file_path/interpreter
+
+# Without bun, .ts falls back to node type stripping which requires
+# node >= 22.6; skip on older nodes where no .ts interpreter is available
+if [ "$IS_BUN" = false ] && ! command -v bun > /dev/null 2>&1; then
+  TS_SUPPORT=$(node -p "require('${SRC}/../../../lib/tools/typestrip.js').supportLevel(process.versions.node) !== false")
+  if [ "$TS_SUPPORT" != "true" ]; then
+    echo "Skipping TypeScript test: node $(node -v) has no type stripping and bun is not installed"
+    exit 0
+  fi
+fi
+
+########### typescript fork test
+
+$pm2 delete all
+
+>typescript-native.log
+
+$pm2 start echo-strippable.ts -o typescript-native.log --merge-logs
+
+sleep 1.5
+
+grep "Hello Typescript!" typescript-native.log
+spec "Should run TypeScript file in fork mode"
+
+should 'should have process online' 'online' 1
+
+if [ "$IS_BUN" = false ] && ! command -v bun > /dev/null 2>&1; then
+  should 'should run TypeScript with node interpreter' "exec_interpreter: 'node'" 1
+fi
+
+########### typescript cluster test
+
+$pm2 delete all
+
+>typescript-native.log
+
+$pm2 start echo-strippable.ts -i 2 -o typescript-native.log --merge-logs
+
+sleep 2
+
+should 'should have 2 processes online' 'online' 2
+
+grep "Hello Typescript!" typescript-native.log
+spec "Should run TypeScript file in cluster mode"
+
+$pm2 delete all

test/fixtures/interpreter/echo-strippable.ts

@@ -0,0 +1,11 @@
+// Erasable-only TypeScript syntax: runnable by node type stripping,
+// unlike echo.ts whose constructor parameter property requires a transform
+interface Greeting {
+  message: string;
+}
+
+const greeting: Greeting = { message: "Hello Typescript!" };
+
+console.log(greeting.message);
+
+setInterval(function (): void {}, 2000);