@lage-run/cli 0.23.2 → 0.23.4

package/CHANGELOG.json

@@ -2,7 +2,49 @@
   "name": "@lage-run/cli",
   "entries": [
     {
-      "date": "Mon, 07 Oct 2024 19:33:03 GMT",
+      "date": "Wed, 09 Oct 2024 17:20:17 GMT",
+      "version": "0.23.4",
+      "tag": "@lage-run/cli_v0.23.4",
+      "comments": {
+        "patch": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "41964958d510982762eaa7a496cad7bbb560bcc5",
+            "comment": "fixing up the lage integrate with buildxl to utilize lage-server"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler to v1.3.3",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/worker-threads-pool to v0.8.4",
+            "commit": "not available"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Tue, 08 Oct 2024 20:03:36 GMT",
+      "version": "0.23.3",
+      "tag": "@lage-run/cli_v0.23.3",
+      "comments": {
+        "patch": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "e0b1d9352f881fd802d982231471152127c65d39",
+            "comment": "uses the shell scripts to have a different executable name"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 07 Oct 2024 19:33:13 GMT",
       "version": "0.23.2",
       "tag": "@lage-run/cli_v0.23.2",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,30 @@
 # Change Log - @lage-run/cli
 
-<!-- This log was last generated on Mon, 07 Oct 2024 19:33:03 GMT and should not be manually modified. -->
+<!-- This log was last generated on Wed, 09 Oct 2024 17:20:17 GMT and should not be manually modified. -->
 
 <!-- Start content -->
 
+## 0.23.4
+
+Wed, 09 Oct 2024 17:20:17 GMT
+
+### Patches
+
+- fixing up the lage integrate with buildxl to utilize lage-server (kchau@microsoft.com)
+- Bump @lage-run/scheduler to v1.3.3
+- Bump @lage-run/worker-threads-pool to v0.8.4
+
+## 0.23.3
+
+Tue, 08 Oct 2024 20:03:36 GMT
+
+### Patches
+
+- uses the shell scripts to have a different executable name (kchau@microsoft.com)
+
 ## 0.23.2
 
-Mon, 07 Oct 2024 19:33:03 GMT
+Mon, 07 Oct 2024 19:33:13 GMT
 
 ### Patches
 

package/lib/commands/exec/action.js

@@ -19,6 +19,7 @@ function _interop_require_default(obj) {
 }
 async function execAction(options, command) {
     const logger = (0, _logger.default)();
+    options.cwd = options.cwd ?? process.cwd();
     options.logLevel = options.logLevel ?? "info";
     options.reporter = options.reporter ?? "json";
     (0, _initializeReporters.initializeReporters)(logger, options);

package/lib/commands/exec/executeRemotely.d.ts

@@ -1,5 +1,6 @@
 import type { ReporterInitOptions } from "../../types/ReporterInitOptions.js";
 interface ExecRemotelyOptions extends ReporterInitOptions {
+    cwd?: string;
     server?: string | boolean;
     timeout?: number;
 }

package/lib/commands/exec/executeRemotely.js

@@ -16,6 +16,10 @@ const _simulateFileAccess = require("./simulateFileAccess.js");
 const _execa = /*#__PURE__*/ _interop_require_default(require("execa"));
 const _getBinPaths = require("../../getBinPaths.js");
 const _parseServerOption = require("../parseServerOption.js");
+const _properlockfile = /*#__PURE__*/ _interop_require_default(require("proper-lockfile"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _workspacetools = require("workspace-tools");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -64,13 +68,47 @@ async function executeOnServer(args, client, logger) {
         throw new Error("No task provided");
     }
     const { taskArgs  } = (0, _filterArgsForTasks.filterArgsForTasks)(args ?? []);
-    const response = await client.runTarget({
-        packageName,
-        task,
-        taskArgs
-    });
-    logger.info(`Task ${response.packageName} ${response.task} exited with code ${response.exitCode} `);
-    return response;
+    try {
+        const response = await client.runTarget({
+            packageName,
+            task,
+            taskArgs
+        });
+        logger.info(`Task ${response.packageName} ${response.task} exited with code ${response.exitCode} `);
+        return response;
+    } catch (error) {
+        if (error instanceof _rpc.ConnectError) {
+            logger.error("Error connecting to server", {
+                error
+            });
+        } else {
+            logger.error("Error running task", {
+                error
+            });
+        }
+    }
+}
+function isAlive(pid) {
+    try {
+        return process.kill(pid, 0);
+    } catch  {
+        return false;
+    }
+}
+function ensurePidFile(lockfilePath) {
+    if (!_fs.default.existsSync(_path.default.dirname(lockfilePath))) {
+        _fs.default.mkdirSync(_path.default.dirname(lockfilePath), {
+            recursive: true
+        });
+    }
+    if (!_fs.default.existsSync(lockfilePath)) {
+        try {
+            const fd = _fs.default.openSync(lockfilePath, "w");
+            _fs.default.closeSync(fd);
+        } catch  {
+        // ignore
+        }
+    }
 }
 async function executeRemotely(options, command) {
     // launch a 'lage-server.js' process, detached if it is not already running
@@ -82,31 +120,54 @@ async function executeRemotely(options, command) {
     options.logLevel = options.logLevel ?? "info";
     options.reporter = options.reporter ?? "json";
     (0, _initializeReporters.initializeReporters)(logger, options);
+    const root = (0, _workspacetools.getWorkspaceRoot)(options.cwd ?? process.cwd());
+    const lockfilePath = _path.default.join(root, `node_modules/.cache/lage/.lage-server-${host}-${port}.pid`);
     let client = await tryCreateClient(host, port);
     const args = command.args;
     if (!client) {
         logger.info(`Starting server on http://${host}:${port}`);
-        const binPaths = (0, _getBinPaths.getBinPaths)();
-        const lageServerBinPath = binPaths["lage-server"];
-        const lageServerArgs = [
-            lageServerBinPath,
-            "--host",
-            host,
-            "--port",
-            port,
-            "--timeout",
-            timeout,
-            ...args
-        ];
-        logger.info(`Launching lage-server with these parameters: "${process.execPath}" ${lageServerArgs.join(" ")}`);
-        const child = (0, _execa.default)(process.execPath, lageServerArgs, {
-            detached: true,
-            stdio: "ignore"
+        logger.info(`acquiring lock: ${lockfilePath}`);
+        ensurePidFile(lockfilePath);
+        const releaseLock = _properlockfile.default.lockSync(lockfilePath, {
+            stale: 1000 * 60 * 1
         });
-        child.unref();
-        logger.info("Server started", {
-            pid: child.pid
+        const pid = parseInt(_fs.default.readFileSync(lockfilePath, "utf-8"));
+        const isServerRunning = pid && isAlive(pid);
+        logger.info("Checking if server is already running", {
+            pid,
+            isServerRunning
         });
+        if (pid && isServerRunning) {
+            logger.info("Server already running", {
+                pid
+            });
+        } else {
+            const binPaths = (0, _getBinPaths.getBinPaths)();
+            const lageServerBinPath = binPaths["lage-server"];
+            const lageServerArgs = [
+                "--host",
+                host,
+                "--port",
+                port,
+                "--timeout",
+                timeout,
+                ...args
+            ];
+            logger.info(`Launching lage-server with these parameters: ${lageServerArgs.join(" ")}`);
+            const child = (0, _execa.default)(lageServerBinPath, lageServerArgs, {
+                cwd: root,
+                detached: true,
+                stdio: "ignore"
+            });
+            if (child && child.pid) {
+                _fs.default.writeFileSync(lockfilePath, child.pid.toString());
+            }
+            child.unref();
+            logger.info("Server started", {
+                pid: child.pid
+            });
+        }
+        releaseLock();
         logger.info("Creating a client to connect to the background services");
         client = await tryCreateClientWithRetries(host, port, logger);
         if (!client) {
@@ -115,11 +176,15 @@ async function executeRemotely(options, command) {
     }
     logger.info(`Executing on server http://${host}:${port}`);
     const response = await executeOnServer(args, client, logger);
-    process.stdout.write(response.stdout);
-    process.stderr.write(response.stderr);
-    process.exitCode = response.exitCode;
-    if (response.exitCode === 0) {
-        await (0, _simulateFileAccess.simulateFileAccess)(logger, response.inputs, response.outputs);
+    if (response) {
+        process.stdout.write(response.stdout);
+        process.stderr.write(response.stderr);
+        process.exitCode = response.exitCode;
+        if (response.exitCode === 0) {
+            await (0, _simulateFileAccess.simulateFileAccess)(logger, response.inputs, response.outputs);
+        }
+    } else {
+        process.exitCode = 1;
     }
     logger.info("Task execution finished");
 }

package/lib/commands/info/action.js

@@ -76,7 +76,7 @@ async function infoAction(options, command) {
 async function optimizeTargetGraph(graph, runnerPicker) {
     const targetMinimizedNodes = await (0, _targetgraph.removeNodes)([
         ...graph.targets.values()
-    ] ?? [], async (target)=>{
+    ], async (target)=>{
         if (target.type === "noop") {
             return true;
         }
@@ -113,7 +113,6 @@ function generateCommand(target, taskArgs, config, options, binPaths) {
     } else if (target.type === "worker" && shouldRunWorkersAsService) {
         const { host , port  } = (0, _parseServerOption.parseServerOption)(options.server);
         const command = [
-            process.execPath,
             binPaths["lage"],
             "exec",
             "--server",
@@ -132,7 +131,6 @@ function generateCommand(target, taskArgs, config, options, binPaths) {
         return command;
     } else if (target.type === "worker") {
         const command = [
-            process.execPath,
             binPaths.lage,
             "exec"
         ];

package/lib/commands/server/lageService.js

@@ -30,9 +30,18 @@ function findAllTasks(pipeline) {
     }
     return Array.from(tasks);
 }
-let context;
-async function initializeOnce(cwd, logger) {
-    if (!context) {
+let initializedPromise;
+/**
+ * Initializes the lageService: the extra "initializePromise" ensures only one initialization is done at a time across threads
+ * @param cwd
+ * @param logger
+ * @returns
+ */ async function initialize(cwd, logger) {
+    if (initializedPromise) {
+        return await initializedPromise;
+    }
+    async function createInitializedPromise() {
+        logger.info("Initializing context");
         const config = await (0, _config.getConfig)(cwd);
         const root = (0, _workspacetools.getWorkspaceRoot)(cwd);
         const { pipeline  } = config;
@@ -61,8 +70,9 @@ async function initializeOnce(cwd, logger) {
             packageInfos,
             includeUntracked: true
         });
+        logger.info("Initializing Package Tree");
         await packageTree.initialize();
-        context = {
+        return {
             config,
             targetGraph,
             packageTree,
@@ -70,7 +80,8 @@ async function initializeOnce(cwd, logger) {
             root
         };
     }
-    return context;
+    initializedPromise = createInitializedPromise();
+    return await initializedPromise;
 }
 let pool;
 async function createLageService({ cwd , serverControls , logger , maxWorkers  }) {
@@ -94,18 +105,21 @@ async function createLageService({ cwd , serverControls , logger , maxWorkers  }
         },
         async runTarget (request) {
             serverControls.clearCountdown();
+            const { config , targetGraph , dependencyMap , packageTree , root  } = await initialize(cwd, logger);
             logger.info("Running target", request);
-            const { config , targetGraph , dependencyMap , packageTree , root  } = await initializeOnce(cwd, logger);
             const runners = (0, _runnerPickerOptions.runnerPickerOptions)(request.nodeOptions, config.npmClient, request.taskArgs);
             const id = (0, _targetgraph.getTargetId)(request.packageName, request.task);
             if (!targetGraph.targets.has(id)) {
-                logger.error(`Target not found: ${request.packageName}#${request.task}`);
+                logger.info(`Target not found: ${request.packageName}#${request.task}`);
                 return {
                     packageName: request.packageName,
                     task: request.task,
                     exitCode: 1
                 };
             }
+            logger.info("Target found", {
+                id
+            });
             const target = targetGraph.targets.get(id);
             const task = {
                 target,

package/lib/getBinPaths.js

@@ -10,24 +10,37 @@ Object.defineProperty(exports, "getBinPaths", {
 });
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function getBinPaths() {
-    let dir = __dirname;
-    let packageJsonPath = "";
-    while(dir !== "/"){
-        packageJsonPath = _path.default.join(dir, "package.json");
-        if (_fs.default.existsSync(packageJsonPath)) {
-            break;
+function findUp(name, dir) {
+    let currentDir = dir;
+    while(currentDir !== "/"){
+        const fullPath = _path.default.join(currentDir, name);
+        if (_fs.default.existsSync(fullPath)) {
+            return fullPath;
         }
-        dir = _path.default.dirname(dir);
+        currentDir = _path.default.dirname(currentDir);
+    }
+    return undefined;
+}
+function getBinPaths() {
+    const bins = _os.default.platform() === "win32" ? [
+        "lage.cmd",
+        "lage-server.cmd"
+    ] : [
+        "lage",
+        "lage-server"
+    ];
+    const binPaths = bins.map((bin)=>findUp("node_modules/.bin/" + bin, __dirname));
+    if (binPaths.some((binPath)=>binPath === undefined)) {
+        throw new Error("Could not find bin paths for lage or lage-server");
     }
-    const packageJson = JSON.parse(_fs.default.readFileSync(_path.default.join(dir, "package.json"), "utf8"));
     return {
-        lage: _path.default.join(dir, packageJson.bin.lage),
-        "lage-server": _path.default.join(dir, packageJson.bin["lage-server"])
+        lage: binPaths[0],
+        "lage-server": binPaths[1]
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/cli",
-  "version": "0.23.2",
+  "version": "0.23.4",
   "description": "Command Line Interface for Lage",
   "repository": {
     "type": "git",
@@ -29,19 +29,21 @@
     "@lage-run/reporters": "^1.2.11",
     "@lage-run/rpc": "^1.2.3",
     "@lage-run/runners": "^1.0.3",
-    "@lage-run/scheduler": "^1.3.2",
+    "@lage-run/scheduler": "^1.3.3",
     "@lage-run/scheduler-types": "^0.3.16",
     "@lage-run/target-graph": "^0.9.0",
-    "@lage-run/worker-threads-pool": "^0.8.3",
+    "@lage-run/worker-threads-pool": "^0.8.4",
     "chokidar": "3.5.3",
     "commander": "9.5.0",
     "execa": "5.1.1",
     "fast-glob": "3.3.2",
+    "proper-lockfile": "^4.1.2",
     "workspace-tools": "0.36.4"
   },
   "devDependencies": {
     "@lage-run/monorepo-fixture": "*",
-    "@lage-run/monorepo-scripts": "*"
+    "@lage-run/monorepo-scripts": "*",
+    "@types/proper-lockfile": "^4.1.4"
   },
   "publishConfig": {
     "access": "public"