@lage-run/cli 0.22.0 → 0.23.1

package/CHANGELOG.json

@@ -2,7 +2,109 @@
   "name": "@lage-run/cli",
   "entries": [
     {
-      "date": "Fri, 27 Sep 2024 20:03:27 GMT",
+      "date": "Fri, 04 Oct 2024 23:41:31 GMT",
+      "version": "0.23.1",
+      "tag": "@lage-run/cli_v0.23.1",
+      "comments": {
+        "patch": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "5030c3eca2e52a4b31e4246b06dea37e126aa659",
+            "comment": "Modified info command to accommodate a \"LAGE_WORKER_SERVER\" flag (also, --server)"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/rpc to v1.2.3",
+            "commit": "not available"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 02 Oct 2024 20:26:19 GMT",
+      "version": "0.23.0",
+      "tag": "@lage-run/cli_v0.23.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "6ecbd570669a07fa87429af5de13ec1adc58b864",
+            "comment": "Simulate file access for lage server"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/cache to v1.3.4",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/config to v0.4.3",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/globby to v14.2.0",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/hasher to v1.6.0",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/reporters to v1.2.11",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/rpc to v1.2.2",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/runners to v1.0.3",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler to v1.3.2",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler-types to v0.3.16",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/target-graph to v0.9.0",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/worker-threads-pool to v0.8.3",
+            "commit": "not available"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Fri, 27 Sep 2024 20:03:49 GMT",
       "version": "0.22.0",
       "tag": "@lage-run/cli_v0.22.0",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,40 @@
 # Change Log - @lage-run/cli
 
-<!-- This log was last generated on Fri, 27 Sep 2024 20:03:27 GMT and should not be manually modified. -->
+<!-- This log was last generated on Fri, 04 Oct 2024 23:41:31 GMT and should not be manually modified. -->
 
 <!-- Start content -->
 
+## 0.23.1
+
+Fri, 04 Oct 2024 23:41:31 GMT
+
+### Patches
+
+- Modified info command to accommodate a "LAGE_WORKER_SERVER" flag (also, --server) (kchau@microsoft.com)
+- Bump @lage-run/rpc to v1.2.3
+
+## 0.23.0
+
+Wed, 02 Oct 2024 20:26:19 GMT
+
+### Minor changes
+
+- Simulate file access for lage server (kchau@microsoft.com)
+- Bump @lage-run/cache to v1.3.4
+- Bump @lage-run/config to v0.4.3
+- Bump @lage-run/globby to v14.2.0
+- Bump @lage-run/hasher to v1.6.0
+- Bump @lage-run/reporters to v1.2.11
+- Bump @lage-run/rpc to v1.2.2
+- Bump @lage-run/runners to v1.0.3
+- Bump @lage-run/scheduler to v1.3.2
+- Bump @lage-run/scheduler-types to v0.3.16
+- Bump @lage-run/target-graph to v0.9.0
+- Bump @lage-run/worker-threads-pool to v0.8.3
+
 ## 0.22.0
 
-Fri, 27 Sep 2024 20:03:27 GMT
+Fri, 27 Sep 2024 20:03:49 GMT
 
 ### Minor changes
 

package/bin/lage-server.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../lib/server.js");

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

@@ -2,8 +2,9 @@ import type { Command } from "commander";
 import type { ReporterInitOptions } from "../../types/ReporterInitOptions.js";
 interface ExecOptions extends ReporterInitOptions {
     cwd?: string;
-    server?: string | boolean;
-    nodeArg?: string[];
+    server?: boolean | string;
+    timeout?: number;
+    nodeArg?: string;
 }
 export declare function execAction(options: ExecOptions, command: Command): Promise<void>;
 export {};

package/lib/commands/exec/action.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "execAction", {
 const _logger = /*#__PURE__*/ _interop_require_default(require("@lage-run/logger"));
 const _initializeReporters = require("../initializeReporters.js");
 const _executeInProcess = require("./executeInProcess.js");
+const _executeRemotely = require("./executeRemotely.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -21,10 +22,16 @@ async function execAction(options, command) {
     options.logLevel = options.logLevel ?? "info";
     options.reporter = options.reporter ?? "json";
     (0, _initializeReporters.initializeReporters)(logger, options);
-    await (0, _executeInProcess.executeInProcess)({
-        logger,
-        args: command.args,
-        cwd: options.cwd,
-        nodeArg: options.nodeArg
-    });
+    const { server  } = options;
+    if (server) {
+        logger.info("Running in server mode");
+        await (0, _executeRemotely.executeRemotely)(options, command);
+    } else {
+        await (0, _executeInProcess.executeInProcess)({
+            logger,
+            args: command.args,
+            cwd: options.cwd,
+            nodeArg: options.nodeArg
+        });
+    }
 }

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

@@ -1,7 +1,7 @@
 import { type Logger } from "@lage-run/logger";
 interface ExecuteInProcessOptions {
     cwd?: string;
-    nodeArg?: string[];
+    nodeArg?: string;
     args?: string[];
     logger: Logger;
 }

package/lib/commands/exec/executeInProcess.js

@@ -16,6 +16,7 @@ const _workspacetools = require("workspace-tools");
 const _filterArgsForTasks = require("../run/filterArgsForTasks.js");
 const _expandTargetDefinition = require("./expandTargetDefinition.js");
 const _runners = require("@lage-run/runners");
+const _runnerPickerOptions = require("../../runnerPickerOptions.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -102,26 +103,7 @@ async function executeInProcess({ cwd , args , nodeArg , logger  }) {
     });
     const definition = (0, _expandTargetDefinition.expandTargetDefinition)(isGlobal ? undefined : info.name, task, pipeline, config.cacheOptions.outputGlob ?? []);
     const target = isGlobal ? factory.createGlobalTarget(task, definition) : factory.createPackageTarget(info.name, task, definition);
-    const pickerOptions = {
-        npmScript: {
-            script: require.resolve("../run/runners/NpmScriptRunner.js"),
-            options: {
-                nodeArg,
-                taskArgs,
-                npmCmd: config.npmClient
-            }
-        },
-        worker: {
-            script: require.resolve("../run/runners/WorkerRunner.js"),
-            options: {
-                taskArgs
-            }
-        },
-        noop: {
-            script: require.resolve("../run/runners/NoOpRunner.js"),
-            options: {}
-        }
-    };
+    const pickerOptions = (0, _runnerPickerOptions.runnerPickerOptions)(nodeArg, config.npmClient, taskArgs);
     const runnerPicker = new _runners.TargetRunnerPicker(pickerOptions);
     const runner = await runnerPicker.pick(target);
     if (await runner.shouldRun(target)) {

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

@@ -0,0 +1,7 @@
+import type { ReporterInitOptions } from "../../types/ReporterInitOptions.js";
+interface ExecRemotelyOptions extends ReporterInitOptions {
+    server?: string | boolean;
+    timeout?: number;
+}
+export declare function executeRemotely(options: ExecRemotelyOptions, command: any): Promise<void>;
+export {};

package/lib/commands/exec/executeRemotely.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "executeRemotely", {
+    enumerable: true,
+    get: function() {
+        return executeRemotely;
+    }
+});
+const _logger = /*#__PURE__*/ _interop_require_default(require("@lage-run/logger"));
+const _initializeReporters = require("../initializeReporters.js");
+const _rpc = require("@lage-run/rpc");
+const _filterArgsForTasks = require("../run/filterArgsForTasks.js");
+const _simulateFileAccess = require("./simulateFileAccess.js");
+const _execa = /*#__PURE__*/ _interop_require_default(require("execa"));
+const _getBinPaths = require("../../getBinPaths.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function tryCreateClient(host, port) {
+    const client = (0, _rpc.createClient)({
+        baseUrl: `http://${host}:${port}`,
+        httpVersion: "2"
+    });
+    try {
+        const success = await client.ping({});
+        if (success.pong) {
+            return client;
+        }
+    } catch (e) {
+        if (e instanceof _rpc.ConnectError) {
+            return undefined;
+        }
+        throw e;
+    }
+    return undefined;
+}
+async function tryCreateClientWithRetries(host, port, logger) {
+    let client;
+    const start = Date.now();
+    while(Date.now() - start < 5 * 1000){
+        try {
+            client = await tryCreateClient(host, port);
+            if (client) {
+                return client;
+            }
+        } catch (e) {
+            if (e instanceof _rpc.ConnectError) {
+                logger.error("Error connecting to server", e);
+            }
+        }
+        await new Promise((resolve)=>setTimeout(resolve, 1000));
+    }
+    return undefined;
+}
+async function executeOnServer(args, client, logger) {
+    const task = args.length === 1 ? args[0] : args[1];
+    const packageName = args.length > 1 ? args[0] : undefined;
+    if (!task) {
+        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;
+}
+async function executeRemotely(options, command) {
+    // launch a 'lage-server.js' process, detached if it is not already running
+    // send the command to the server process
+    const { server ="localhost:5332"  } = options;
+    const timeout = options.timeout ?? 120;
+    const serverString = typeof options.server === "boolean" && options.server ? "localhost:5332" : !server ? "localhost:5332" : server;
+    const parts = serverString.split(":");
+    const host = parts[0];
+    const port = parseInt(parts[1] ?? "5332");
+    const logger = (0, _logger.default)();
+    options.logLevel = options.logLevel ?? "info";
+    options.reporter = options.reporter ?? "json";
+    (0, _initializeReporters.initializeReporters)(logger, options);
+    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"
+        });
+        child.unref();
+        logger.info("Server started", {
+            pid: child.pid
+        });
+        logger.info("Creating a client to connect to the background services");
+        client = await tryCreateClientWithRetries(host, port, logger);
+        if (!client) {
+            throw new Error("Server could not be started");
+        }
+    }
+    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);
+    }
+    logger.info("Task execution finished");
+}

package/lib/commands/exec/index.js

@@ -11,5 +11,14 @@ Object.defineProperty(exports, "execCommand", {
 const _commander = require("commander");
 const _action = require("./action.js");
 const _addLoggerOptions = require("../addLoggerOptions.js");
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 const execCommand = new _commander.Command("exec");
+execCommand.option("-c|--concurrency <number>", "max jobs to run at a time", (v)=>parseInt(v), _os.default.cpus().length - 1);
+execCommand.option("-s|--server [host:port]", "lage server host");
+execCommand.option("-t|--timeout <seconds>", "lage server autoshutoff timeout", (v)=>parseInt(v), 1 * 60);
 (0, _addLoggerOptions.addLoggerOptions)(execCommand).action(_action.execAction);

package/lib/commands/info/action.d.ts

@@ -1,6 +1,6 @@
 import type { Command } from "commander";
 import type { ReporterInitOptions } from "../../types/ReporterInitOptions.js";
-interface RunOptions extends ReporterInitOptions {
+interface InfoActionOptions extends ReporterInitOptions {
     dependencies: boolean;
     dependents: boolean;
     since: string;
@@ -9,9 +9,10 @@ interface RunOptions extends ReporterInitOptions {
     cache: boolean;
     nodeArg: string;
     ignore: string[];
+    server: string;
 }
 /**
- * (UNSTABLE) The info command displays information about a target graph in a workspace.
+ * The info command displays information about a target graph in a workspace.
  * The generated output can be read and used by other task runners, such as BuildXL.
  *
  * Expected format:
@@ -47,5 +48,5 @@ interface RunOptions extends ReporterInitOptions {
  *   ...
  * ]
  */
-export declare function infoAction(options: RunOptions, command: Command): Promise<void>;
+export declare function infoAction(options: InfoActionOptions, command: Command): Promise<void>;
 export {};

package/lib/commands/info/action.js

@@ -14,9 +14,12 @@ const _config = require("@lage-run/config");
 const _workspacetools = require("workspace-tools");
 const _getFilteredPackages = require("../../filter/getFilteredPackages.js");
 const _logger = /*#__PURE__*/ _interop_require_default(require("@lage-run/logger"));
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _targetgraph = require("@lage-run/target-graph");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _initializeReporters = require("../initializeReporters.js");
+const _runners = require("@lage-run/runners");
+const _getBinPaths = require("../../getBinPaths.js");
+const _runnerPickerOptions = require("../../runnerPickerOptions.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -28,22 +31,11 @@ async function infoAction(options, command) {
     const logger = (0, _logger.default)();
     options.logLevel = options.logLevel ?? "info";
     options.reporter = options.reporter ?? "json";
+    options.server = typeof options.server === "boolean" && options.server ? "localhost:5332" : options.server;
     (0, _initializeReporters.initializeReporters)(logger, options);
     const root = (0, _workspacetools.getWorkspaceRoot)(cwd);
     const packageInfos = (0, _workspacetools.getPackageInfos)(root);
-    const targetGraph = prepareAndCreateTargetGraph(config, logger, root, options, packageInfos, command);
-    const scope = prepareAndGetFilteredPackages(config, logger, root, options, packageInfos);
-    const packageTasks = processTargets(targetGraph.targets, packageInfos, config);
-    logger.info("info", {
-        command: command.args,
-        scope,
-        packageTasks: [
-            ...packageTasks.values()
-        ].flat()
-    });
-}
-function prepareAndCreateTargetGraph(config, logger, root, options, packageInfos, command) {
-    const { tasks  } = (0, _filterArgsForTasks.filterArgsForTasks)(command.args);
+    const { tasks , taskArgs  } = (0, _filterArgsForTasks.filterArgsForTasks)(command.args);
     const targetGraph = (0, _createTargetGraph.createTargetGraph)({
         logger,
         root,
@@ -58,9 +50,6 @@ function prepareAndCreateTargetGraph(config, logger, root, options, packageInfos
         tasks,
         packageInfos
     });
-    return targetGraph;
-}
-function prepareAndGetFilteredPackages(config, logger, root, options, packageInfos) {
     const scope = (0, _getFilteredPackages.getFilteredPackages)({
         root,
         packageInfos,
@@ -72,76 +61,85 @@ function prepareAndGetFilteredPackages(config, logger, root, options, packageInf
         repoWideChanges: config.repoWideChanges,
         sinceIgnoreGlobs: options.ignore.concat(config.ignore)
     });
-    return scope;
+    const pickerOptions = (0, _runnerPickerOptions.runnerPickerOptions)(options.nodeArg, config.npmClient, taskArgs);
+    const runnerPicker = new _runners.TargetRunnerPicker(pickerOptions);
+    const optimizedTargets = await optimizeTargetGraph(targetGraph, runnerPicker);
+    const binPaths = (0, _getBinPaths.getBinPaths)();
+    const packageTasks = optimizedTargets.map((target)=>generatePackageTask(target, taskArgs, config, options, binPaths));
+    logger.info("info", {
+        command: command.args,
+        scope,
+        packageTasks
+    });
 }
-function processTargets(targets, packageInfos, config) {
-    const packageTasks = new Map(); // Initialize the map with the correct type
-    const dependenciesCache = new Map();
-    for (const target of targets.values()){
-        if (shouldSkipTarget(target, packageInfos)) {
-            continue;
+async function optimizeTargetGraph(graph, runnerPicker) {
+    const targetMinimizedNodes = await (0, _targetgraph.removeNodes)([
+        ...graph.targets.values()
+    ] ?? [], async (target)=>{
+        if (target.type === "noop") {
+            return true;
         }
-        const packageTask = generatePackageTask(target, targets, packageInfos, dependenciesCache, config);
-        if (packageTask) {
-            // Check if the packageTask is defined before accessing its properties
-            const packageName = packageTask.package;
-            if (!packageTasks.has(packageName)) {
-                packageTasks.set(packageName, []);
-            }
-            packageTasks.get(packageName).push(packageTask); // Use the non-null assertion operator to avoid type errors
+        const runner = await runnerPicker.pick(target);
+        if (!await runner.shouldRun(target)) {
+            return true;
         }
-    }
-    return packageTasks;
-}
-function isTargetNoop(target, packageInfos) {
-    return !packageInfos[target.packageName]?.scripts?.[target.task];
-}
-function shouldSkipTarget(target, packageInfos) {
-    return target.id === (0, _targetgraph.getStartTargetId)() || isTargetNoop(target, packageInfos);
+        return false;
+    });
+    return (0, _targetgraph.transitiveReduction)(targetMinimizedNodes);
 }
-function generatePackageTask(target, targets, packageInfos, dependenciesCache, config) {
-    const command = generateCommand(target, config);
+function generatePackageTask(target, taskArgs, config, options, binPaths) {
+    const command = generateCommand(target, taskArgs, config, options, binPaths);
     const workingDirectory = getWorkingDirectory(target);
-    const dependenciesSet = resolveDependencies(target.dependencies, targets, packageInfos, dependenciesCache);
     const packageTask = {
         id: target.id,
         command,
-        dependencies: [
-            ...dependenciesSet
-        ],
+        dependencies: target.dependencies,
         workingDirectory,
-        package: target.packageName,
+        package: target.packageName ?? "",
         task: target.task
     };
     return packageTask;
 }
-function resolveDependencies(dependencies, targets, packageInfos, dependenciesCache) {
-    const result = new Set();
-    for (const dependency of dependencies){
-        if (dependency === (0, _targetgraph.getStartTargetId)()) {
-            continue;
+function generateCommand(target, taskArgs, config, options, binPaths) {
+    const shouldRunWorkersAsService = typeof process.env.LAGE_WORKER_SERVER === "string" && process.env.LAGE_WORKER_SERVER !== "false" || !!options.server;
+    if (target.type === "npmScript") {
+        const npmClient = config.npmClient ?? "npm";
+        const command = [
+            npmClient,
+            ...getNpmArgs(target.task, taskArgs)
+        ];
+        return command;
+    } else if (target.type === "worker" && shouldRunWorkersAsService) {
+        const command = [
+            process.execPath,
+            binPaths["lage"],
+            "exec",
+            "--server",
+            options.server
+        ];
+        if (options.concurrency) {
+            command.push("--concurrency", options.concurrency.toString());
+        }
+        if (target.packageName) {
+            command.push(target.packageName);
         }
-        if (!dependenciesCache.has(dependency)) {
-            const dependencyTarget = targets.get(dependency);
-            if (isTargetNoop(dependencyTarget, packageInfos)) {
-                dependenciesCache.set(dependency, resolveDependencies(dependencyTarget.dependencies, targets, packageInfos, dependenciesCache));
-            } else {
-                dependenciesCache.set(dependency, new Set([
-                    dependency
-                ]));
-            }
+        if (target.task) {
+            command.push(target.task);
         }
-        dependenciesCache.get(dependency)?.forEach((dependency)=>result.add(dependency));
+        command.push(...taskArgs);
+        return command;
+    } else if (target.type === "worker") {
+        const command = [
+            process.execPath,
+            binPaths.lage,
+            "exec"
+        ];
+        command.push(target.packageName ?? "");
+        command.push(target.task);
+        command.push(...taskArgs);
+        return command;
     }
-    return result;
-}
-function generateCommand(target, config) {
-    const npmClient = config.npmClient ?? "npm";
-    const command = [
-        npmClient,
-        ...getNpmArgs(target.task, target.taskArgs)
-    ];
-    return command;
+    return [];
 }
 function getWorkingDirectory(target) {
     const cwd = process.cwd();

package/lib/commands/info/index.js

@@ -13,4 +13,8 @@ const _action = require("./action.js");
 const _addFilterOptions = require("../addFilterOptions.js");
 const _addLoggerOptions = require("../addLoggerOptions.js");
 const infoCommand = new _commander.Command("info");
-(0, _addFilterOptions.addFilterOptions)((0, _addLoggerOptions.addLoggerOptions)(infoCommand)).action(_action.infoAction);
+(0, _addFilterOptions.addFilterOptions)((0, _addLoggerOptions.addLoggerOptions)(infoCommand));
+infoCommand.description("Display information about a target graph in a workspace.\n" + "It is used by BuildXL to build a pip-graph");
+infoCommand.option("--server [host:port]", "Run targets of type 'worker' on a background service");
+infoCommand.option("--nodearg|--node-arg <nodeArg>", 'arguments to be passed to node (e.g. --nodearg="--max_old_space_size=1234 --heap-prof" - set via "NODE_OPTIONS" environment variable');
+infoCommand.action(_action.infoAction);

package/lib/commands/run/action.d.ts

@@ -14,7 +14,7 @@ interface RunOptions extends ReporterInitOptions {
     resetCache: boolean;
     nodeArg: string;
     ignore: string[];
-    unstableWatch: boolean;
+    watch: boolean;
     info: boolean;
     maxWorkersPerTask: string[];
     allowNoTargetRuns: boolean;

package/lib/commands/run/action.js

@@ -8,13 +8,10 @@ Object.defineProperty(exports, "action", {
         return action;
     }
 });
-const _infoAction = require("./infoAction.js");
 const _runAction = require("./runAction.js");
 const _watchAction = require("./watchAction.js");
 async function action(options, command) {
-    if (options.info) {
-        return (0, _infoAction.infoAction)(options, command);
-    } else if (options.unstableWatch) {
+    if (options.watch) {
         return (0, _watchAction.watchAction)(options, command);
     } else {
         return (0, _runAction.runAction)(options, command);

package/lib/commands/run/createTargetGraph.d.ts

@@ -6,7 +6,7 @@ interface CreateTargetGraphOptions {
     root: string;
     dependencies: boolean;
     dependents: boolean;
-    since: string;
+    since?: string;
     scope?: string[];
     ignore: string[];
     repoWideChanges: string[];

package/lib/commands/run/index.js

@@ -15,7 +15,7 @@ const _isRunningFromCI = require("../isRunningFromCI.js");
 const _addFilterOptions = require("../addFilterOptions.js");
 const runCommand = new _commander.Command("run");
 (0, _addFilterOptions.addFilterOptions)((0, _addLoggerOptions.addLoggerOptions)(runCommand)).action(_action.action).option("-c, --concurrency <n>", "concurrency", (value)=>parseInt(value, 10)).option("--max-workers-per-task <maxWorkersPerTarget...>", "set max worker per task, e.g. --max-workers-per-task build=2 test=4", [])// Run Command Options
-.option("--no-cache", "disables the cache").option("--reset-cache", "resets the cache, filling it after a run").option("--skip-local-cache", "skips caching locally (defaults to true in CI environments)", _isRunningFromCI.isRunningFromCI).option("--profile [profile]", "writes a run profile into a file that can be processed by Chromium devtool").option("--nodearg|--node-arg <nodeArg>", 'arguments to be passed to node (e.g. --nodearg="--max_old_space_size=1234 --heap-prof" - set via "NODE_OPTIONS" environment variable').option("--continue", "continues the run even on error").option("--allow-no-target-runs").addOption(new _commander.Option("--info", "outputs information about a run action, suitable for calculating shards or as an input for another task runner").conflicts("unstableWatch")).option("--unstable-watch", "runs in watch mode").allowUnknownOption(true).addHelpCommand("[run] command1 [command2...commandN] [options]", "run commands").addHelpText("after", `
+.option("--no-cache", "disables the cache").option("--reset-cache", "resets the cache, filling it after a run").option("--skip-local-cache", "skips caching locally (defaults to true in CI environments)", _isRunningFromCI.isRunningFromCI).option("--profile [profile]", "writes a run profile into a file that can be processed by Chromium devtool").option("--nodearg|--node-arg <nodeArg>", 'arguments to be passed to node (e.g. --nodearg="--max_old_space_size=1234 --heap-prof" - set via "NODE_OPTIONS" environment variable').option("--continue", "continues the run even on error").option("--allow-no-target-runs").option("--watch", "runs in watch mode").allowUnknownOption(true).addHelpCommand("[run] command1 [command2...commandN] [options]", "run commands").addHelpText("after", `
 Runs a set of commands in a target graph. The targets are defined by packages and their scripts as defined the package.json files.
 
 Examples

package/lib/commands/run/runAction.js

@@ -18,6 +18,7 @@ const _scheduler = require("@lage-run/scheduler");
 const _logger = /*#__PURE__*/ _interop_require_default(require("@lage-run/logger"));
 const _errors = require("../../types/errors.js");
 const _createCacheProvider = require("../../cache/createCacheProvider.js");
+const _runnerPickerOptions = require("../../runnerPickerOptions.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -76,24 +77,7 @@ async function runAction(options, command) {
             skipLocalCache: options.skipLocalCache,
             cacheOptions: config.cacheOptions,
             runners: {
-                npmScript: {
-                    script: require.resolve("./runners/NpmScriptRunner.js"),
-                    options: {
-                        nodeArg: options.nodeArg,
-                        taskArgs,
-                        npmCmd: config.npmClient
-                    }
-                },
-                worker: {
-                    script: require.resolve("./runners/WorkerRunner.js"),
-                    options: {
-                        taskArgs
-                    }
-                },
-                noop: {
-                    script: require.resolve("./runners/NoOpRunner.js"),
-                    options: {}
-                },
+                ...(0, _runnerPickerOptions.runnerPickerOptions)(options.nodeArg, config.npmClient, taskArgs),
                 ...config.runners
             }
         },

package/lib/commands/run/watchAction.js

@@ -18,6 +18,7 @@ const _scheduler = require("@lage-run/scheduler");
 const _watcher = require("./watcher.js");
 const _logger = /*#__PURE__*/ _interop_require_wildcard(require("@lage-run/logger"));
 const _createCacheProvider = require("../../cache/createCacheProvider.js");
+const _runnerPickerOptions = require("../../runnerPickerOptions.js");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -106,24 +107,7 @@ async function watchAction(options, command) {
             skipLocalCache: options.skipLocalCache,
             cacheOptions: config.cacheOptions,
             runners: {
-                npmScript: {
-                    script: require.resolve("./runners/NpmScriptRunner.js"),
-                    options: {
-                        nodeArg: options.nodeArg,
-                        taskArgs,
-                        npmCmd: config.npmClient
-                    }
-                },
-                worker: {
-                    script: require.resolve("./runners/WorkerRunner.js"),
-                    options: {
-                        taskArgs
-                    }
-                },
-                noop: {
-                    script: require.resolve("./runners/NoOpRunner.js"),
-                    options: {}
-                },
+                ...(0, _runnerPickerOptions.runnerPickerOptions)(options.nodeArg, config.npmClient, taskArgs),
                 ...config.runners
             }
         },

package/lib/commands/server/MemoryStream.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Writable } from "stream";
+export declare class MemoryStream extends Writable {
+    private chunks;
+    constructor();
+    _write(chunk: any, encoding: BufferEncoding): void;
+    getData(): Buffer;
+    toString(): string;
+}

package/lib/commands/server/MemoryStream.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MemoryStream", {
+    enumerable: true,
+    get: function() {
+        return MemoryStream;
+    }
+});
+const _stream = require("stream");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class MemoryStream extends _stream.Writable {
+    _write(chunk, encoding) {
+        this.chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding));
+    }
+    getData() {
+        return Buffer.concat(this.chunks);
+    }
+    toString() {
+        return this.getData().toString();
+    }
+    constructor(){
+        super();
+        _define_property(this, "chunks", void 0);
+        this.chunks = [];
+    }
+}

package/lib/commands/server/action.d.ts

@@ -1,5 +1,4 @@
 import type { ReporterInitOptions } from "../../types/ReporterInitOptions.js";
-import type { Command } from "commander";
 interface WorkerOptions extends ReporterInitOptions {
     nodeArg?: string[];
     port?: number;
@@ -7,5 +6,5 @@ interface WorkerOptions extends ReporterInitOptions {
     timeout?: number;
     shutdown: boolean;
 }
-export declare function serverAction(options: WorkerOptions, command: Command): Promise<void>;
+export declare function serverAction(options: WorkerOptions): Promise<void>;
 export {};

package/lib/commands/server/action.js

@@ -11,88 +11,36 @@ Object.defineProperty(exports, "serverAction", {
 const _logger = /*#__PURE__*/ _interop_require_default(require("@lage-run/logger"));
 const _initializeReporters = require("../initializeReporters.js");
 const _lageService = require("./lageService.js");
-const _filterArgsForTasks = require("../run/filterArgsForTasks.js");
 const _rpc = require("@lage-run/rpc");
-const _simulateFileAccess = require("./simulateFileAccess.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-async function tryCreateClient(host, port) {
-    const client = (0, _rpc.createClient)({
-        baseUrl: `http://${host}:${port}`,
-        httpVersion: "1.1"
-    });
-    try {
-        const success = await client.ping({});
-        if (success.pong) {
-            return client;
-        }
-    } catch (e) {
-        if (e instanceof _rpc.ConnectError) {
-            return undefined;
-        }
-        throw e;
-    }
-    return undefined;
-}
-async function executeOnServer(args, client, logger) {
-    const task = args.length === 1 ? args[0] : args[1];
-    const packageName = args.length > 1 ? args[0] : undefined;
-    if (!task) {
-        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} `);
-    process.exitCode = response.exitCode;
-    if (response.exitCode === 0) {
-        await (0, _simulateFileAccess.simulateFileAccess)(logger, response.inputs, response.outputs);
-    }
-    logger.info("Task execution finished");
-}
-async function serverAction(options, command) {
+async function serverAction(options) {
     const { port =5332 , host ="localhost" , timeout =1  } = options;
     const logger = (0, _logger.default)();
     options.logLevel = options.logLevel ?? "info";
     options.reporter = options.reporter ?? "json";
     (0, _initializeReporters.initializeReporters)(logger, options);
-    const client = await tryCreateClient(host, port);
-    if (client) {
-        logger.info(`Executing on server http://${host}:${port}`);
-        const args = command.args;
-        await executeOnServer(args, client, logger);
-    } else {
-        logger.info(`Starting server on http://${host}:${port}`);
-        const abortController = new AbortController();
-        const lageService = await (0, _lageService.createLageService)({
-            cwd: process.cwd(),
-            serverControls: {
-                abortController,
-                countdownToShutdown: ()=>resetTimer(logger, timeout, abortController, server),
-                clearCountdown: clearTimer
-            },
-            logger,
-            maxWorkers: options.concurrency
-        });
-        const server = await (0, _rpc.createServer)(lageService, abortController);
-        await server.listen({
-            host,
-            port
-        });
-        logger.info(`Server listening on http://${host}:${port}, timeout in ${timeout} seconds`);
-        const client = await tryCreateClient(host, port);
-        if (!client) {
-            throw new Error("Server could not be reached");
-        }
-        const args = command.args;
-        await executeOnServer(args, client, logger);
-    }
+    logger.info(`Starting server on http://${host}:${port}`);
+    const abortController = new AbortController();
+    const lageService = await (0, _lageService.createLageService)({
+        cwd: process.cwd(),
+        serverControls: {
+            abortController,
+            countdownToShutdown: ()=>resetTimer(logger, timeout, abortController, server),
+            clearCountdown: clearTimer
+        },
+        logger,
+        maxWorkers: options.concurrency
+    });
+    const server = await (0, _rpc.createServer)(lageService, abortController);
+    await server.listen({
+        host,
+        port
+    });
+    logger.info(`Server listening on http://${host}:${port}, timeout in ${timeout} seconds`);
 }
 let timeoutHandle;
 function resetTimer(logger, timeout, abortController, server) {

package/lib/commands/server/lageService.js

@@ -16,6 +16,8 @@ const _workerthreadspool = require("@lage-run/worker-threads-pool");
 const _hasher = require("@lage-run/hasher");
 const _getOutputFiles = require("./getOutputFiles.js");
 const _globby = require("@lage-run/globby");
+const _MemoryStream = require("./MemoryStream.js");
+const _runnerPickerOptions = require("../../runnerPickerOptions.js");
 function findAllTasks(pipeline) {
     const tasks = new Set();
     for (const key of Object.keys(pipeline)){
@@ -45,7 +47,7 @@ async function initializeOnce(cwd, logger) {
             pipeline,
             repoWideChanges: config.repoWideChanges,
             scope: undefined,
-            since: "",
+            since: undefined,
             outputs: config.cacheOptions.outputGlob,
             tasks,
             packageInfos
@@ -92,27 +94,9 @@ async function createLageService({ cwd , serverControls , logger , maxWorkers  }
         },
         async runTarget (request) {
             serverControls.clearCountdown();
+            logger.info("Running target", request);
             const { config , targetGraph , dependencyMap , packageTree , root  } = await initializeOnce(cwd, logger);
-            const runners = {
-                npmScript: {
-                    script: require.resolve("../run/runners/NpmScriptRunner.js"),
-                    options: {
-                        nodeOptions: request.nodeOptions,
-                        taskArgs: request.taskArgs,
-                        npmCmd: config.npmClient
-                    }
-                },
-                worker: {
-                    script: require.resolve("../run/runners/WorkerRunner.js"),
-                    options: {
-                        taskArgs: request.taskArgs
-                    }
-                },
-                noop: {
-                    script: require.resolve("../run/runners/NoOpRunner.js"),
-                    options: {}
-                }
-            };
+            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}`);
@@ -127,6 +111,8 @@ async function createLageService({ cwd , serverControls , logger , maxWorkers  }
                 target,
                 runners
             };
+            const writableStdout = new _MemoryStream.MemoryStream();
+            const writableStderr = new _MemoryStream.MemoryStream();
             let pipedStdout;
             let pipedStderr;
             try {
@@ -134,20 +120,22 @@ async function createLageService({ cwd , serverControls , logger , maxWorkers  }
                     logger.info(`[${worker.threadId}] ${request.packageName}#${request.task} start`);
                     pipedStdout = stdout;
                     pipedStderr = stderr;
-                    stdout.pipe(process.stdout);
-                    stderr.pipe(process.stderr);
+                    stdout.pipe(writableStdout);
+                    stderr.pipe(writableStderr);
                 }, (worker)=>{
                     logger.info(`[${worker.threadId}] ${request.packageName}#${request.task} end`);
-                    pipedStdout.unpipe(process.stdout);
-                    pipedStderr.unpipe(process.stderr);
+                    pipedStdout.unpipe(writableStdout);
+                    pipedStderr.unpipe(writableStderr);
                 });
                 const globalInputs = target.environmentGlob ? (0, _globby.glob)(target.environmentGlob, {
                     cwd: root,
                     gitignore: true
-                }) : (0, _globby.glob)(config.cacheOptions?.environmentGlob, {
+                }) : config.cacheOptions?.environmentGlob ? (0, _globby.glob)(config.cacheOptions?.environmentGlob, {
                     cwd: root,
                     gitignore: true
-                });
+                }) : [
+                    "lage.config.js"
+                ];
                 const inputs = ((0, _hasher.getInputFiles)(target, dependencyMap, packageTree) ?? []).concat(globalInputs);
                 return {
                     packageName: request.packageName,
@@ -156,6 +144,8 @@ async function createLageService({ cwd , serverControls , logger , maxWorkers  }
                     hash: "",
                     inputs,
                     outputs: (0, _getOutputFiles.getOutputFiles)(root, target, config.cacheOptions?.outputGlob, packageTree),
+                    stdout: writableStdout.toString(),
+                    stderr: writableStderr.toString(),
                     id
                 };
             } catch (e) {
@@ -166,6 +156,8 @@ async function createLageService({ cwd , serverControls , logger , maxWorkers  }
                     hash: "",
                     inputs: [],
                     outputs: [],
+                    stdout: "",
+                    stderr: e instanceof Error ? e.toString() : "",
                     id
                 };
             }

package/lib/getBinPaths.d.ts

@@ -0,0 +1,4 @@
+export declare function getBinPaths(): {
+    lage: string;
+    "lage-server": string;
+};

package/lib/getBinPaths.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getBinPaths", {
+    enumerable: true,
+    get: function() {
+        return getBinPaths;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+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;
+        }
+        dir = _path.default.dirname(dir);
+    }
+    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"])
+    };
+}

package/lib/runnerPickerOptions.d.ts

@@ -0,0 +1,2 @@
+import type { TargetRunnerPickerOptions } from "@lage-run/runners";
+export declare function runnerPickerOptions(nodeArg: string | undefined, npmCmd: string, taskArgs: string[]): TargetRunnerPickerOptions;

package/lib/runnerPickerOptions.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runnerPickerOptions", {
+    enumerable: true,
+    get: function() {
+        return runnerPickerOptions;
+    }
+});
+function runnerPickerOptions(nodeArg, npmCmd, taskArgs) {
+    return {
+        npmScript: {
+            script: require.resolve("./runners/NpmScriptRunner.js"),
+            options: {
+                nodeArg,
+                taskArgs,
+                npmCmd
+            }
+        },
+        worker: {
+            script: require.resolve("./runners/WorkerRunner.js"),
+            options: {
+                taskArgs
+            }
+        },
+        noop: {
+            script: require.resolve("./runners/NoOpRunner.js"),
+            options: {}
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/cli",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "description": "Command Line Interface for Lage",
   "repository": {
     "type": "git",
@@ -8,7 +8,8 @@
   },
   "homepage": "https://microsoft.github.io/lage/",
   "bin": {
-    "lage": "./bin/lage"
+    "lage": "./bin/lage.js",
+    "lage-server": "./bin/lage-server.js"
   },
   "license": "MIT",
   "main": "lib/index.js",
@@ -20,18 +21,18 @@
     "lint": "monorepo-scripts lint"
   },
   "dependencies": {
-    "@lage-run/cache": "^1.3.3",
-    "@lage-run/config": "^0.4.2",
-    "@lage-run/globby": "^14.1.0",
-    "@lage-run/hasher": "^1.5.0",
+    "@lage-run/cache": "^1.3.4",
+    "@lage-run/config": "^0.4.3",
+    "@lage-run/globby": "^14.2.0",
+    "@lage-run/hasher": "^1.6.0",
     "@lage-run/logger": "^1.3.1",
-    "@lage-run/reporters": "^1.2.10",
-    "@lage-run/rpc": "^1.2.1",
-    "@lage-run/runners": "^1.0.2",
-    "@lage-run/scheduler": "^1.3.1",
-    "@lage-run/scheduler-types": "^0.3.15",
-    "@lage-run/target-graph": "^0.8.10",
-    "@lage-run/worker-threads-pool": "^0.8.2",
+    "@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-types": "^0.3.16",
+    "@lage-run/target-graph": "^0.9.0",
+    "@lage-run/worker-threads-pool": "^0.8.3",
     "chokidar": "3.5.3",
     "commander": "9.5.0",
     "execa": "5.1.1",

package/lib/commands/run/infoAction.d.ts

@@ -1,14 +0,0 @@
-import type { Command } from "commander";
-import type { ReporterInitOptions } from "../../types/ReporterInitOptions.js";
-interface RunOptions extends ReporterInitOptions {
-    dependencies: boolean;
-    dependents: boolean;
-    since: string;
-    scope: string[];
-    to: string[];
-    cache: boolean;
-    nodeArg: string;
-    ignore: string[];
-}
-export declare function infoAction(options: RunOptions, command: Command): Promise<void>;
-export {};

package/lib/commands/run/infoAction.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "infoAction", {
-    enumerable: true,
-    get: function() {
-        return infoAction;
-    }
-});
-const _createTargetGraph = require("./createTargetGraph.js");
-const _filterArgsForTasks = require("./filterArgsForTasks.js");
-const _config = require("@lage-run/config");
-const _workspacetools = require("workspace-tools");
-const _logger = /*#__PURE__*/ _interop_require_default(require("@lage-run/logger"));
-const _targetgraph = require("@lage-run/target-graph");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-async function infoAction(options, command) {
-    const cwd = process.cwd();
-    const config = await (0, _config.getConfig)(cwd);
-    const logger = (0, _logger.default)();
-    // Build Target Graph
-    const root = (0, _workspacetools.getWorkspaceRoot)(process.cwd());
-    const packageInfos = await (0, _workspacetools.getPackageInfosAsync)(root);
-    const { tasks  } = (0, _filterArgsForTasks.filterArgsForTasks)(command.args);
-    const targetGraph = (0, _createTargetGraph.createTargetGraph)({
-        logger,
-        root,
-        dependencies: options.dependencies,
-        dependents: options.dependents && !options.to,
-        ignore: options.ignore.concat(config.ignore),
-        pipeline: config.pipeline,
-        repoWideChanges: config.repoWideChanges,
-        scope: (options.scope ?? []).concat(options.to ?? []),
-        since: options.since,
-        outputs: config.cacheOptions.outputGlob,
-        tasks,
-        packageInfos
-    });
-    // Make sure we do not attempt writeRemoteCache in info mode
-    config.cacheOptions.writeRemoteCache = false;
-    const { targets  } = targetGraph;
-    for (const target of targets.values()){
-        if (target.id === (0, _targetgraph.getStartTargetId)()) {
-            continue;
-        }
-        const startIdIndex = target.dependencies.indexOf((0, _targetgraph.getStartTargetId)());
-        target.dependencies.splice(startIdIndex, 1);
-        process.stdout.write(`${JSON.stringify(target)}\n`);
-    }
-}