@lage-run/cli 0.19.3 → 0.21.0

package/CHANGELOG.json

@@ -2,7 +2,97 @@
   "name": "@lage-run/cli",
   "entries": [
     {
-      "date": "Wed, 11 Sep 2024 20:52:00 GMT",
+      "date": "Wed, 25 Sep 2024 20:27:33 GMT",
+      "version": "0.21.0",
+      "tag": "@lage-run/cli_v0.21.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/hasher to v1.4.0",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler to v1.3.0",
+            "commit": "not available"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Fri, 13 Sep 2024 18:05:04 GMT",
+      "version": "0.20.0",
+      "tag": "@lage-run/cli_v0.20.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "924b93e66ae3cc60effa7cfc1f5254e1e59e9969",
+            "comment": "adds a lage-server binary that listens and executes and auto shutsdown"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/cache to v1.3.3",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/config to v0.4.2",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/hasher to v1.3.4",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/reporters to v1.2.10",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/rpc to v1.2.0",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/runners to v1.0.2",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler to v1.2.14",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler-types to v0.3.15",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/target-graph to v0.8.10",
+            "commit": "not available"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 11 Sep 2024 20:52:15 GMT",
       "version": "0.19.3",
       "tag": "@lage-run/cli_v0.19.3",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,38 @@
 # Change Log - @lage-run/cli
 
-<!-- This log was last generated on Wed, 11 Sep 2024 20:52:00 GMT and should not be manually modified. -->
+<!-- This log was last generated on Wed, 25 Sep 2024 20:27:33 GMT and should not be manually modified. -->
 
 <!-- Start content -->
 
+## 0.21.0
+
+Wed, 25 Sep 2024 20:27:33 GMT
+
+### Minor changes
+
+- Bump @lage-run/hasher to v1.4.0
+- Bump @lage-run/scheduler to v1.3.0
+
+## 0.20.0
+
+Fri, 13 Sep 2024 18:05:04 GMT
+
+### Minor changes
+
+- adds a lage-server binary that listens and executes and auto shutsdown (kchau@microsoft.com)
+- Bump @lage-run/cache to v1.3.3
+- Bump @lage-run/config to v0.4.2
+- Bump @lage-run/hasher to v1.3.4
+- Bump @lage-run/reporters to v1.2.10
+- Bump @lage-run/rpc to v1.2.0
+- Bump @lage-run/runners to v1.0.2
+- Bump @lage-run/scheduler to v1.2.14
+- Bump @lage-run/scheduler-types to v0.3.15
+- Bump @lage-run/target-graph to v0.8.10
+
 ## 0.19.3
 
-Wed, 11 Sep 2024 20:52:00 GMT
+Wed, 11 Sep 2024 20:52:15 GMT
 
 ### Patches
 

package/lib/cli.js

@@ -10,7 +10,6 @@ const _index2 = require("./commands/affected/index.js");
 const _index3 = require("./commands/init/index.js");
 const _index4 = require("./commands/info/index.js");
 const _index5 = require("./commands/exec/index.js");
-const _index6 = require("./commands/server/index.js");
 async function main() {
     const program = new _commander.Command();
     program.addCommand(_index.runCommand, {
@@ -21,7 +20,6 @@ async function main() {
     program.addCommand(_index3.initCommand);
     program.addCommand(_index4.infoCommand);
     program.addCommand(_index5.execCommand);
-    program.addCommand(_index6.serverCommand);
     await program.parseAsync(process.argv);
 }
 main().catch((err)=>{

package/lib/commands/exec/action.js

@@ -11,7 +11,6 @@ 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
@@ -22,18 +21,10 @@ async function execAction(options, command) {
     options.logLevel = options.logLevel ?? "info";
     options.reporter = options.reporter ?? "json";
     (0, _initializeReporters.initializeReporters)(logger, options);
-    if (options.server) {
-        await (0, _executeRemotely.executeRemotely)({
-            server: typeof options.server === "boolean" ? "localhost:5332" : options.server,
-            logger,
-            args: command.args
-        });
-    } else {
-        await (0, _executeInProcess.executeInProcess)({
-            logger,
-            args: command.args,
-            cwd: options.cwd,
-            nodeArg: options.nodeArg
-        });
-    }
+    await (0, _executeInProcess.executeInProcess)({
+        logger,
+        args: command.args,
+        cwd: options.cwd,
+        nodeArg: options.nodeArg
+    });
 }

package/lib/commands/exec/index.js

@@ -12,5 +12,4 @@ const _commander = require("commander");
 const _action = require("./action.js");
 const _addLoggerOptions = require("../addLoggerOptions.js");
 const execCommand = new _commander.Command("exec");
-execCommand.option("--server [server:port]", "Execute on lage server via RPC", "localhost:5332");
 (0, _addLoggerOptions.addLoggerOptions)(execCommand).action(_action.execAction);

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

@@ -4,6 +4,8 @@ interface WorkerOptions extends ReporterInitOptions {
     nodeArg?: string[];
     port?: number;
     host?: string;
+    timeout?: number;
+    shutdown: boolean;
 }
-export declare function workerAction(options: WorkerOptions, command: Command): Promise<void>;
+export declare function serverAction(options: WorkerOptions, command: Command): Promise<void>;
 export {};

package/lib/commands/server/action.js

@@ -2,68 +2,96 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "workerAction", {
+Object.defineProperty(exports, "serverAction", {
     enumerable: true,
     get: function() {
-        return workerAction;
+        return serverAction;
     }
 });
-const _config = require("@lage-run/config");
 const _logger = /*#__PURE__*/ _interop_require_default(require("@lage-run/logger"));
 const _initializeReporters = require("../initializeReporters.js");
 const _lageService = require("./lageService.js");
-const _workspacetools = require("workspace-tools");
-const _createTargetGraph = require("../run/createTargetGraph.js");
-const _targetId = require("@lage-run/target-graph/lib/targetId.js");
+const _filterArgsForTasks = require("../run/filterArgsForTasks.js");
+const _rpc = require("@lage-run/rpc");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function findAllTasks(pipeline) {
-    const tasks = new Set();
-    for (const key of Object.keys(pipeline)){
-        if (key.includes("#") || key.startsWith("#") || key.endsWith("//")) {
-            const { task  } = (0, _targetId.getPackageAndTask)(key);
-            tasks.add(task);
-        } else {
-            tasks.add(key);
+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");
     }
-    return Array.from(tasks);
+    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;
 }
-async function workerAction(options, command) {
-    const { port =5332 , host ="localhost"  } = options;
-    const cwd = process.cwd();
+async function serverAction(options, command) {
+    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 rpc = (await import("@lage-run/rpc")).default;
-    const config = await (0, _config.getConfig)(cwd);
-    const { pipeline  } = config;
-    const root = (0, _workspacetools.getWorkspaceRoot)(cwd);
-    const packageInfos = (0, _workspacetools.getPackageInfos)(root);
-    const tasks = findAllTasks(pipeline);
-    const targetGraph = (0, _createTargetGraph.createTargetGraph)({
-        logger,
-        root,
-        dependencies: false,
-        dependents: false,
-        ignore: [],
-        pipeline,
-        repoWideChanges: config.repoWideChanges,
-        scope: [],
-        since: "",
-        outputs: config.cacheOptions.outputGlob,
-        tasks,
-        packageInfos
-    });
-    const lageService = await (0, _lageService.createLageService)(targetGraph, logger, config.npmClient, options.concurrency ?? config.concurrency);
-    const server = await rpc.createServer(lageService);
-    logger.info(`Server listening on http://${host}:${port}`);
-    await server.listen({
-        host,
-        port
-    });
+    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)(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();
+        });
+        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);
+    }
+}
+let timeoutHandle;
+function resetTimer(logger, timeout, abortController, server) {
+    if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+    }
+    timeoutHandle = setTimeout(()=>{
+        logger.info(`Server timed out after ${timeout} seconds`);
+        abortController.abort();
+        server.close();
+    }, timeout * 1000);
 }

package/lib/commands/server/index.js

@@ -21,4 +21,5 @@ const serverCommand = new _commander.Command("server");
 serverCommand.option("-c|--concurrency <number>", "max jobs to run at a time", (v)=>parseInt(v), _os.default.cpus().length - 1);
 serverCommand.option("-h|--host <host>", "lage server host", "localhost");
 serverCommand.option("-p|--port <port>", "lage worker server port", (v)=>parseInt(v), 5332);
-(0, _addLoggerOptions.addLoggerOptions)(serverCommand).action(_action.workerAction);
+serverCommand.option("-t|--timeout <seconds>", "lage server autoshutoff timeout", (v)=>parseInt(v), 1 * 60);
+(0, _addLoggerOptions.addLoggerOptions)(serverCommand).action(_action.serverAction);

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

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

package/lib/commands/server/lageService.js

@@ -8,23 +8,79 @@ Object.defineProperty(exports, "createLageService", {
         return createLageService;
     }
 });
+const _config = require("@lage-run/config");
 const _targetgraph = require("@lage-run/target-graph");
-async function createLageService(targetGraph, logger, npmClient, maxWorkers) {
+const _workspacetools = require("workspace-tools");
+const _createTargetGraph = require("../run/createTargetGraph.js");
+const _workerthreadspool = require("@lage-run/worker-threads-pool");
+function findAllTasks(pipeline) {
+    const tasks = new Set();
+    for (const key of Object.keys(pipeline)){
+        if (key.includes("#") || key.startsWith("#") || key.endsWith("//")) {
+            const { task  } = (0, _targetgraph.getPackageAndTask)(key);
+            tasks.add(task);
+        } else {
+            tasks.add(key);
+        }
+    }
+    return Array.from(tasks);
+}
+let targetGraph;
+let config;
+async function initializeOnce(cwd, logger) {
+    if (!config) {
+        config = await (0, _config.getConfig)(cwd);
+    }
+    if (!targetGraph) {
+        const { pipeline  } = config;
+        const root = (0, _workspacetools.getWorkspaceRoot)(cwd);
+        const packageInfos = (0, _workspacetools.getPackageInfos)(root);
+        const tasks = findAllTasks(pipeline);
+        targetGraph = (0, _createTargetGraph.createTargetGraph)({
+            logger,
+            root,
+            dependencies: false,
+            dependents: false,
+            ignore: [],
+            pipeline,
+            repoWideChanges: config.repoWideChanges,
+            scope: [],
+            since: "",
+            outputs: config.cacheOptions.outputGlob,
+            tasks,
+            packageInfos
+        });
+    }
+    return {
+        config,
+        targetGraph
+    };
+}
+let pool;
+async function createLageService(cwd, abortController, logger, maxWorkers) {
     logger.info(`Server started with ${maxWorkers} workers`);
-    const poolModule = (await import("@lage-run/worker-threads-pool")).default;
-    const pool = new poolModule.WorkerPool({
+    pool = new _workerthreadspool.WorkerPool({
         script: require.resolve("./singleTargetWorker.js"),
         maxWorkers
     });
+    abortController.signal.addEventListener("abort", ()=>{
+        pool?.close();
+    });
     return {
+        async ping () {
+            return {
+                pong: true
+            };
+        },
         async runTarget (request) {
+            const { config , targetGraph  } = await initializeOnce(cwd, logger);
             const runners = {
                 npmScript: {
                     script: require.resolve("../run/runners/NpmScriptRunner.js"),
                     options: {
                         nodeOptions: request.nodeOptions,
                         taskArgs: request.taskArgs,
-                        npmCmd: npmClient
+                        npmCmd: config.npmClient
                     }
                 },
                 worker: {
@@ -51,13 +107,19 @@ async function createLageService(targetGraph, logger, npmClient, maxWorkers) {
                 target,
                 runners
             };
+            let pipedStdout;
+            let pipedStderr;
             try {
                 await pool.exec(task, 0, (worker, stdout, stderr)=>{
                     logger.info(`[${worker.threadId}] ${request.packageName}#${request.task} start`);
+                    pipedStdout = stdout;
+                    pipedStderr = stderr;
                     stdout.pipe(process.stdout);
                     stderr.pipe(process.stderr);
                 }, (worker)=>{
                     logger.info(`[${worker.threadId}] ${request.packageName}#${request.task} end`);
+                    pipedStdout.unpipe(process.stdout);
+                    pipedStderr.unpipe(process.stderr);
                 });
                 return {
                     packageName: request.packageName,

package/lib/server.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/server.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _commander = require("commander");
+const _errors = require("./types/errors.js");
+const _index = require("./commands/server/index.js");
+async function main() {
+    const program = new _commander.Command();
+    program.addCommand(_index.serverCommand, {
+        isDefault: true
+    });
+    await program.parseAsync(process.argv);
+}
+main().catch((err)=>{
+    /* eslint-disable no-console */ switch(err){
+        case _errors.NoTargetFoundError:
+            console.log("lage: no targets found that matches the given scope.");
+            break;
+        default:
+            console.error(err);
+            break;
+    }
+    /* eslint-enable no-console */ process.exitCode = 1;
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/cli",
-  "version": "0.19.3",
+  "version": "0.21.0",
   "description": "Command Line Interface for Lage",
   "repository": {
     "type": "git",
@@ -20,16 +20,16 @@
     "lint": "monorepo-scripts lint"
   },
   "dependencies": {
-    "@lage-run/cache": "^1.3.2",
-    "@lage-run/config": "^0.4.1",
-    "@lage-run/hasher": "^1.3.3",
+    "@lage-run/cache": "^1.3.3",
+    "@lage-run/config": "^0.4.2",
+    "@lage-run/hasher": "^1.4.0",
     "@lage-run/logger": "^1.3.1",
-    "@lage-run/reporters": "^1.2.9",
-    "@lage-run/rpc": "^1.1.0",
-    "@lage-run/runners": "^1.0.1",
-    "@lage-run/scheduler": "^1.2.13",
-    "@lage-run/scheduler-types": "^0.3.14",
-    "@lage-run/target-graph": "^0.8.9",
+    "@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",
     "chokidar": "3.5.3",
     "commander": "9.5.0",