@lage-run/cli 0.21.0 → 0.23.0

package/CHANGELOG.json

@@ -2,7 +2,133 @@
   "name": "@lage-run/cli",
   "entries": [
     {
-      "date": "Wed, 25 Sep 2024 20:27:33 GMT",
+      "date": "Wed, 02 Oct 2024 20:25:42 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": {
+        "minor": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "2919f9041f931dc6ef65017f7aedb9fef9dab66d",
+            "comment": "Simulate file access for lage server"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/globby to v14.1.0",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/hasher to v1.5.0",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/rpc to v1.2.1",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler to v1.3.1",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/worker-threads-pool to v0.8.2",
+            "commit": "not available"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 25 Sep 2024 20:28:10 GMT",
       "version": "0.21.0",
       "tag": "@lage-run/cli_v0.21.0",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,44 @@
 # Change Log - @lage-run/cli
 
-<!-- This log was last generated on Wed, 25 Sep 2024 20:27:33 GMT and should not be manually modified. -->
+<!-- This log was last generated on Wed, 02 Oct 2024 20:25:42 GMT and should not be manually modified. -->
 
 <!-- Start content -->
 
+## 0.23.0
+
+Wed, 02 Oct 2024 20:25:42 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:49 GMT
+
+### Minor changes
+
+- Simulate file access for lage server (kchau@microsoft.com)
+- Bump @lage-run/globby to v14.1.0
+- Bump @lage-run/hasher to v1.5.0
+- Bump @lage-run/rpc to v1.2.1
+- Bump @lage-run/scheduler to v1.3.1
+- Bump @lage-run/worker-threads-pool to v0.8.2
+
 ## 0.21.0
 
-Wed, 25 Sep 2024 20:27:33 GMT
+Wed, 25 Sep 2024 20:28:10 GMT
 
 ### Minor changes
 

package/bin/lage-server.js

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

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,11 @@ 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 _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
 const _initializeReporters = require("../initializeReporters.js");
+const _runners = require("@lage-run/runners");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -28,22 +30,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 === "string" ? options.server : "localhost:5332";
     (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 +49,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 +60,123 @@ function prepareAndGetFilteredPackages(config, logger, root, options, packageInf
         repoWideChanges: config.repoWideChanges,
         sinceIgnoreGlobs: options.ignore.concat(config.ignore)
     });
-    return scope;
-}
-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;
-        }
-        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, []);
+    const pickerOptions = {
+        npmScript: {
+            script: require.resolve("./runners/NpmScriptRunner.js"),
+            options: {
+                nodeArg: options.nodeArg,
+                taskArgs,
+                npmCmd: config.npmClient
             }
-            packageTasks.get(packageName).push(packageTask); // Use the non-null assertion operator to avoid type errors
+        },
+        worker: {
+            script: require.resolve("./runners/WorkerRunner.js"),
+            options: {
+                taskArgs
+            }
+        },
+        noop: {
+            script: require.resolve("./runners/NoOpRunner.js"),
+            options: {}
         }
-    }
-    return packageTasks;
+    };
+    const runnerPicker = new _runners.TargetRunnerPicker(pickerOptions);
+    const optimizedTargets = await optimizeTargetGraph(targetGraph, runnerPicker);
+    const binPaths = getBinPaths();
+    const packageTasks = optimizedTargets.map((target)=>generatePackageTask(target, taskArgs, config, options, binPaths));
+    logger.info("info", {
+        command: command.args,
+        scope,
+        packageTasks
+    });
 }
-function isTargetNoop(target, packageInfos) {
-    return !packageInfos[target.packageName]?.scripts?.[target.task];
+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"])
+    };
 }
-function shouldSkipTarget(target, packageInfos) {
-    return target.id === (0, _targetgraph.getStartTargetId)() || isTargetNoop(target, packageInfos);
+async function optimizeTargetGraph(graph, runnerPicker) {
+    const targetMinimizedNodes = await (0, _targetgraph.removeNodes)([
+        ...graph.targets.values()
+    ] ?? [], async (target)=>{
+        if (target.type === "noop") {
+            return true;
+        }
+        const runner = await runnerPicker.pick(target);
+        if (!await runner.shouldRun(target)) {
+            return true;
+        }
+        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) {
+    if (target.type === "npmScript") {
+        const npmClient = config.npmClient ?? "npm";
+        const command = [
+            npmClient,
+            ...getNpmArgs(target.task, taskArgs)
+        ];
+        return command;
+    } else if (target.type === "worker" && options.server) {
+        const [host, port] = options.server.split(":");
+        const command = [
+            process.execPath,
+            binPaths["lage-server"]
+        ];
+        if (host) {
+            command.push("--host", host);
         }
-        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 (port) {
+            command.push("--port", port);
+        }
+        if (options.concurrency) {
+            command.push("--concurrency", options.concurrency.toString());
+        }
+        if (target.packageName) {
+            command.push(target.packageName);
         }
-        dependenciesCache.get(dependency)?.forEach((dependency)=>result.add(dependency));
+        if (target.task) {
+            command.push(target.task);
+        }
+        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/info/runners/NoOpRunner.d.ts

@@ -0,0 +1 @@
+export { NoOpRunner } from "@lage-run/runners";

package/lib/commands/info/runners/NoOpRunner.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NoOpRunner", {
+    enumerable: true,
+    get: function() {
+        return _runners.NoOpRunner;
+    }
+});
+const _runners = require("@lage-run/runners");

package/lib/commands/info/runners/NpmScriptRunner.d.ts

@@ -0,0 +1 @@
+export { NpmScriptRunner } from "@lage-run/runners";

package/lib/commands/info/runners/NpmScriptRunner.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NpmScriptRunner", {
+    enumerable: true,
+    get: function() {
+        return _runners.NpmScriptRunner;
+    }
+});
+const _runners = require("@lage-run/runners");

package/lib/commands/info/runners/WorkerRunner.d.ts

@@ -0,0 +1 @@
+export { WorkerRunner } from "@lage-run/runners";

package/lib/commands/info/runners/WorkerRunner.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WorkerRunner", {
+    enumerable: true,
+    get: function() {
+        return _runners.WorkerRunner;
+    }
+});
+const _runners = require("@lage-run/runners");

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

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

package/lib/commands/server/action.js

@@ -13,6 +13,7 @@ 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
@@ -48,8 +49,12 @@ async function executeOnServer(args, client, logger) {
         task,
         taskArgs
     });
-    logger.info(`Task ${response.packageName} #${response.task} exited with code ${response.exitCode} `);
+    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) {
     const { port =5332 , host ="localhost" , timeout =1  } = options;
@@ -65,12 +70,17 @@ async function serverAction(options, command) {
     } else {
         logger.info(`Starting server on http://${host}:${port}`);
         const abortController = new AbortController();
-        const lageService = await (0, _lageService.createLageService)(process.cwd(), abortController, logger, options.concurrency);
-        const server = await (0, _rpc.createServer)(lageService, abortController);
-        server.addHook("onRequest", (req, res, next)=>{
-            resetTimer(logger, timeout, abortController, server);
-            next();
+        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
@@ -86,12 +96,15 @@ async function serverAction(options, command) {
 }
 let timeoutHandle;
 function resetTimer(logger, timeout, abortController, server) {
-    if (timeoutHandle) {
-        clearTimeout(timeoutHandle);
-    }
-    timeoutHandle = setTimeout(()=>{
+    clearTimer();
+    timeoutHandle = globalThis.setTimeout(()=>{
         logger.info(`Server timed out after ${timeout} seconds`);
         abortController.abort();
         server.close();
     }, timeout * 1000);
 }
+function clearTimer() {
+    if (timeoutHandle) {
+        globalThis.clearTimeout(timeoutHandle);
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { CacheOptions } from "@lage-run/config";
+import type { PackageTree } from "@lage-run/hasher";
+import type { Target } from "@lage-run/target-graph";
+export declare function getOutputFiles(root: string, target: Target, outputGlob: CacheOptions["outputGlob"], packageTree: PackageTree): string[];

package/lib/commands/server/getOutputFiles.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getOutputFiles", {
+    enumerable: true,
+    get: function() {
+        return getOutputFiles;
+    }
+});
+const _globby = require("@lage-run/globby");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getOutputFiles(root, target, outputGlob, packageTree) {
+    const patterns = target.outputs ?? outputGlob ?? [
+        "**/*"
+    ];
+    const sourceControlledFiles = new Set(packageTree.getPackageFiles(target.packageName ?? "", patterns));
+    const outputs = (0, _globby.glob)(patterns, {
+        cwd: target.cwd,
+        gitignore: false
+    }).map((file)=>_path.default.relative(root, _path.default.join(target.cwd, file))).filter((file)=>!sourceControlledFiles.has(file));
+    return outputs;
+}

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

@@ -1,4 +1,13 @@
 /// <reference types="node" />
 import type { Logger } from "@lage-run/logger";
 import type { ILageService } from "@lage-run/rpc";
-export declare function createLageService(cwd: string, abortController: AbortController, logger: Logger, maxWorkers?: number): Promise<ILageService>;
+export declare function createLageService({ cwd, serverControls, logger, maxWorkers, }: {
+    cwd: string;
+    serverControls: {
+        abortController: AbortController;
+        countdownToShutdown: () => void;
+        clearCountdown: () => void;
+    };
+    logger: Logger;
+    maxWorkers?: number;
+}): Promise<ILageService>;

package/lib/commands/server/lageService.js

@@ -13,6 +13,9 @@ const _targetgraph = require("@lage-run/target-graph");
 const _workspacetools = require("workspace-tools");
 const _createTargetGraph = require("../run/createTargetGraph.js");
 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");
 function findAllTasks(pipeline) {
     const tasks = new Set();
     for (const key of Object.keys(pipeline)){
@@ -25,18 +28,15 @@ function findAllTasks(pipeline) {
     }
     return Array.from(tasks);
 }
-let targetGraph;
-let config;
+let context;
 async function initializeOnce(cwd, logger) {
-    if (!config) {
-        config = await (0, _config.getConfig)(cwd);
-    }
-    if (!targetGraph) {
-        const { pipeline  } = config;
+    if (!context) {
+        const config = await (0, _config.getConfig)(cwd);
         const root = (0, _workspacetools.getWorkspaceRoot)(cwd);
+        const { pipeline  } = config;
         const packageInfos = (0, _workspacetools.getPackageInfos)(root);
         const tasks = findAllTasks(pipeline);
-        targetGraph = (0, _createTargetGraph.createTargetGraph)({
+        const targetGraph = (0, _createTargetGraph.createTargetGraph)({
             logger,
             root,
             dependencies: false,
@@ -44,28 +44,46 @@ async function initializeOnce(cwd, logger) {
             ignore: [],
             pipeline,
             repoWideChanges: config.repoWideChanges,
-            scope: [],
+            scope: undefined,
             since: "",
             outputs: config.cacheOptions.outputGlob,
             tasks,
             packageInfos
         });
+        const dependencyMap = (0, _workspacetools.createDependencyMap)(packageInfos, {
+            withDevDependencies: true,
+            withPeerDependencies: false
+        });
+        const packageTree = new _hasher.PackageTree({
+            root,
+            packageInfos,
+            includeUntracked: true
+        });
+        await packageTree.initialize();
+        context = {
+            config,
+            targetGraph,
+            packageTree,
+            dependencyMap,
+            root
+        };
     }
-    return {
-        config,
-        targetGraph
-    };
+    return context;
 }
 let pool;
-async function createLageService(cwd, abortController, logger, maxWorkers) {
+async function createLageService({ cwd , serverControls , logger , maxWorkers  }) {
     logger.info(`Server started with ${maxWorkers} workers`);
     pool = new _workerthreadspool.WorkerPool({
         script: require.resolve("./singleTargetWorker.js"),
         maxWorkers
     });
-    abortController.signal.addEventListener("abort", ()=>{
+    serverControls.abortController.signal.addEventListener("abort", ()=>{
         pool?.close();
     });
+    pool?.on("idle", ()=>{
+        logger.info("All workers are idle, shutting down after timeout");
+        serverControls.countdownToShutdown();
+    });
     return {
         async ping () {
             return {
@@ -73,7 +91,8 @@ async function createLageService(cwd, abortController, logger, maxWorkers) {
             };
         },
         async runTarget (request) {
-            const { config , targetGraph  } = await initializeOnce(cwd, logger);
+            serverControls.clearCountdown();
+            const { config , targetGraph , dependencyMap , packageTree , root  } = await initializeOnce(cwd, logger);
             const runners = {
                 npmScript: {
                     script: require.resolve("../run/runners/NpmScriptRunner.js"),
@@ -94,7 +113,8 @@ async function createLageService(cwd, abortController, logger, maxWorkers) {
                     options: {}
                 }
             };
-            if (!targetGraph.targets.has((0, _targetgraph.getTargetId)(request.packageName, request.task))) {
+            const id = (0, _targetgraph.getTargetId)(request.packageName, request.task);
+            if (!targetGraph.targets.has(id)) {
                 logger.error(`Target not found: ${request.packageName}#${request.task}`);
                 return {
                     packageName: request.packageName,
@@ -102,7 +122,7 @@ async function createLageService(cwd, abortController, logger, maxWorkers) {
                     exitCode: 1
                 };
             }
-            const target = targetGraph.targets.get((0, _targetgraph.getTargetId)(request.packageName, request.task));
+            const target = targetGraph.targets.get(id);
             const task = {
                 target,
                 runners
@@ -121,16 +141,32 @@ async function createLageService(cwd, abortController, logger, maxWorkers) {
                     pipedStdout.unpipe(process.stdout);
                     pipedStderr.unpipe(process.stderr);
                 });
+                const globalInputs = target.environmentGlob ? (0, _globby.glob)(target.environmentGlob, {
+                    cwd: root,
+                    gitignore: true
+                }) : (0, _globby.glob)(config.cacheOptions?.environmentGlob, {
+                    cwd: root,
+                    gitignore: true
+                });
+                const inputs = ((0, _hasher.getInputFiles)(target, dependencyMap, packageTree) ?? []).concat(globalInputs);
                 return {
                     packageName: request.packageName,
                     task: request.task,
-                    exitCode: 0
+                    exitCode: 0,
+                    hash: "",
+                    inputs,
+                    outputs: (0, _getOutputFiles.getOutputFiles)(root, target, config.cacheOptions?.outputGlob, packageTree),
+                    id
                 };
             } catch (e) {
                 return {
                     packageName: request.packageName,
                     task: request.task,
-                    exitCode: 1
+                    exitCode: 1,
+                    hash: "",
+                    inputs: [],
+                    outputs: [],
+                    id
                 };
             }
         }

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

@@ -0,0 +1,2 @@
+import type { Logger } from "@lage-run/logger";
+export declare function simulateFileAccess(logger: Logger, inputs: string[], outputs: string[]): Promise<void>;

package/lib/commands/server/simulateFileAccess.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "simulateFileAccess", {
+    enumerable: true,
+    get: function() {
+        return simulateFileAccess;
+    }
+});
+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
+    };
+}
+async function simulateFileAccess(logger, inputs, outputs) {
+    const root = (0, _workspacetools.getWorkspaceRoot)(process.cwd());
+    logger.silly("Now probing and touching inputs and outputs");
+    // probe input files
+    let fd;
+    for (const input of inputs){
+        fd = _fs.default.openSync(_path.default.join(root, input), "r");
+        _fs.default.closeSync(fd);
+    }
+    // touch output files
+    const time = new Date();
+    for (const output of outputs){
+        try {
+            _fs.default.utimesSync(_path.default.join(root, output), time, time);
+        } catch (e) {
+        // ignore
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/cli",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "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,17 +21,18 @@
     "lint": "monorepo-scripts lint"
   },
   "dependencies": {
-    "@lage-run/cache": "^1.3.3",
-    "@lage-run/config": "^0.4.2",
-    "@lage-run/hasher": "^1.4.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.0",
-    "@lage-run/runners": "^1.0.2",
-    "@lage-run/scheduler": "^1.3.0",
-    "@lage-run/scheduler-types": "^0.3.15",
-    "@lage-run/target-graph": "^0.8.10",
-    "@lage-run/worker-threads-pool": "^0.8.1",
+    "@lage-run/reporters": "^1.2.11",
+    "@lage-run/rpc": "^1.2.2",
+    "@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/server/executeRemotely.d.ts

@@ -1,8 +0,0 @@
-import { type Logger } from "@lage-run/logger";
-interface ExecClientOptions {
-    logger: Logger;
-    server: string;
-    args?: string[];
-}
-export declare function executeRemotely({ logger, server, args }: ExecClientOptions): Promise<void>;
-export {};

package/lib/commands/server/executeRemotely.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "executeRemotely", {
-    enumerable: true,
-    get: function() {
-        return executeRemotely;
-    }
-});
-const _filterArgsForTasks = require("../run/filterArgsForTasks.js");
-async function executeRemotely({ logger , server , args  }) {
-    const task = args?.length === 1 ? args?.[0] : args?.[1];
-    const packageName = args?.length ?? 0 > 1 ? args?.[0] : undefined;
-    if (!task) {
-        throw new Error("No task provided");
-    }
-    const { taskArgs  } = (0, _filterArgsForTasks.filterArgsForTasks)(args ?? []);
-    const rpc = (await import("@lage-run/rpc")).default;
-    const baseUrl = server.startsWith("http") ? server : `http://${server}`;
-    const client = rpc.createClient({
-        baseUrl,
-        httpVersion: baseUrl.startsWith("https") ? "2" : "1.1"
-    });
-    const response = await client.runTarget({
-        packageName,
-        task,
-        taskArgs
-    });
-    logger.info(`Task ${response.packageName}#${response.task} exited with code ${response.exitCode}`);
-    process.exitCode = response.exitCode;
-}