@lage-run/cli 0.18.1 → 0.19.1

package/CHANGELOG.json

@@ -2,7 +2,55 @@
   "name": "@lage-run/cli",
   "entries": [
     {
-      "date": "Wed, 04 Sep 2024 23:24:50 GMT",
+      "date": "Sat, 07 Sep 2024 00:01:44 GMT",
+      "version": "0.19.1",
+      "tag": "@lage-run/cli_v0.19.1",
+      "comments": {
+        "patch": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "fb00e0249a448bd0ab09a0f68e9ea3456d2a7152",
+            "comment": "adding parallelism to server"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/config to v0.4.0",
+            "commit": "not available"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler to v1.2.11",
+            "commit": "not available"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Fri, 06 Sep 2024 20:03:01 GMT",
+      "version": "0.19.0",
+      "tag": "@lage-run/cli_v0.19.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "0d2a6f936b7250959f5a42f3c79908b8a475d28d",
+            "comment": "remote execution RPC server and client for Lage"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/rpc to v1.1.0",
+            "commit": "not available"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 04 Sep 2024 23:25:05 GMT",
       "version": "0.18.1",
       "tag": "@lage-run/cli_v0.18.1",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,31 @@
 # Change Log - @lage-run/cli
 
-This log was last generated on Wed, 04 Sep 2024 23:24:50 GMT and should not be manually modified.
+This log was last generated on Sat, 07 Sep 2024 00:01:44 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.19.1
+
+Sat, 07 Sep 2024 00:01:44 GMT
+
+### Patches
+
+- adding parallelism to server (kchau@microsoft.com)
+- Bump @lage-run/config to v0.4.0
+- Bump @lage-run/scheduler to v1.2.11
+
+## 0.19.0
+
+Fri, 06 Sep 2024 20:03:01 GMT
+
+### Minor changes
+
+- remote execution RPC server and client for Lage (kchau@microsoft.com)
+- Bump @lage-run/rpc to v1.1.0
+
 ## 0.18.1
 
-Wed, 04 Sep 2024 23:24:50 GMT
+Wed, 04 Sep 2024 23:25:05 GMT
 
 ### Patches
 

package/lib/cli.js

@@ -10,6 +10,7 @@ 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, {
@@ -20,6 +21,7 @@ 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.d.ts

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

package/lib/commands/exec/action.js

@@ -8,151 +8,32 @@ Object.defineProperty(exports, "execAction", {
         return execAction;
     }
 });
-const _filterArgsForTasks = require("../run/filterArgsForTasks.js");
-const _config = require("@lage-run/config");
-const _workspacetools = require("workspace-tools");
 const _logger = /*#__PURE__*/ _interop_require_default(require("@lage-run/logger"));
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
-const _targetgraph = require("@lage-run/target-graph");
 const _initializeReporters = require("../initializeReporters.js");
-const _runners = require("@lage-run/runners");
-const _targetId = require("@lage-run/target-graph/lib/targetId.js");
+const _executeInProcess = require("./executeInProcess.js");
+const _executeRemotely = require("./executeRemotely.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-/**
- * Parses the package and task from the command as quickly as possible:
- *
- * 1. if cwd overridden in args, use it to read the package.json directly
- * 2. if cwd not overridden and root is not cwd, use the cwd to read the package.json directly
- * 3. if root is cwd, assume the task is global
- *
- * @param options
- * @param command
- * @returns
- */ function parsePackageInfoFromArgs(root, options, command) {
-    const { packageName , task  } = (0, _targetId.getPackageAndTask)(command.args[0]);
-    if (packageName) {
-        const packageInfos = (0, _workspacetools.getPackageInfos)(root);
-        const info = packageInfos[packageName];
-        return {
-            info,
-            task,
-            isGlobal: false
-        };
-    }
-    if (options.cwd) {
-        const packageJsonPath = _path.default.join(options.cwd, "package.json");
-        const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, "utf-8"));
-        return {
-            info: {
-                ...packageJson,
-                packageJsonPath
-            },
-            task,
-            isGlobal: false
-        };
-    }
-    if (root !== process.cwd()) {
-        const packageJsonPath = _path.default.join(process.cwd(), "package.json");
-        if (_fs.default.existsSync(packageJsonPath)) {
-            const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, "utf-8"));
-            return {
-                info: {
-                    ...packageJson,
-                    packageJsonPath
-                },
-                task,
-                isGlobal: false
-            };
-        }
-    }
-    const packageJsonPath = _path.default.join(root, "package.json");
-    const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, "utf-8"));
-    return {
-        info: {
-            ...packageJson,
-            packageJsonPath
-        },
-        task,
-        isGlobal: true
-    };
-}
-function expandTargetDefinition(packageName, task, pipeline, outputs) {
-    const id = packageName ? `${packageName}#${task}` : task;
-    const emptyDefinition = {
-        cache: false,
-        dependsOn: [],
-        options: {},
-        outputs
-    };
-    const definition = id in pipeline ? pipeline[id] : `#${task}` in pipeline ? pipeline[`#${task}`] : `//${task}` in pipeline ? pipeline[`//${task}`] : task in pipeline ? pipeline[task] : emptyDefinition;
-    if (Array.isArray(definition)) {
-        return emptyDefinition;
-    } else {
-        return definition;
-    }
-}
 async function execAction(options, command) {
-    const cwd = process.cwd();
-    const config = await (0, _config.getConfig)(cwd);
-    const { pipeline  } = config;
     const logger = (0, _logger.default)();
     options.logLevel = options.logLevel ?? "info";
     options.reporter = options.reporter ?? "json";
     (0, _initializeReporters.initializeReporters)(logger, options);
-    const root = (0, _workspacetools.getWorkspaceRoot)(cwd);
-    const { info , task , isGlobal  } = parsePackageInfoFromArgs(root, options, command);
-    const packageInfos = {
-        [info.name]: info
-    };
-    const resolve = ()=>{
-        return _path.default.dirname(info.packageJsonPath).replace(/\\/g, "/");
-    };
-    const { taskArgs  } = (0, _filterArgsForTasks.filterArgsForTasks)(command.args);
-    const factory = new _targetgraph.TargetFactory({
-        root,
-        resolve,
-        packageInfos
-    });
-    const definition = 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: 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 runnerPicker = new _runners.TargetRunnerPicker(pickerOptions);
-    const runner = await runnerPicker.pick(target);
-    if (await runner.shouldRun(target)) {
-        logger.info("Running target", {
-            target
-        });
-        await runner.run({
-            target,
-            weight: 1,
-            abortSignal: new AbortController().signal
+    if (options.server) {
+        await (0, _executeRemotely.executeRemotely)({
+            server: typeof options.server === "boolean" ? "localhost:5332" : options.server,
+            logger,
+            args: command.args
         });
-        logger.info("Finished", {
-            target
+    } else {
+        await (0, _executeInProcess.executeInProcess)({
+            logger,
+            args: command.args,
+            cwd: options.cwd,
+            nodeArg: options.nodeArg
         });
     }
 }

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

@@ -0,0 +1,9 @@
+import { type Logger } from "@lage-run/logger";
+interface ExecuteInProcessOptions {
+    cwd?: string;
+    nodeArg?: string[];
+    args?: string[];
+    logger: Logger;
+}
+export declare function executeInProcess({ cwd, args, nodeArg, logger }: ExecuteInProcessOptions): Promise<void>;
+export {};

package/lib/commands/exec/executeInProcess.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "executeInProcess", {
+    enumerable: true,
+    get: function() {
+        return executeInProcess;
+    }
+});
+const _config = require("@lage-run/config");
+const _targetgraph = require("@lage-run/target-graph");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _workspacetools = require("workspace-tools");
+const _filterArgsForTasks = require("../run/filterArgsForTasks.js");
+const _expandTargetDefinition = require("./expandTargetDefinition.js");
+const _runners = require("@lage-run/runners");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/**
+ * Parses the package and task from the command as quickly as possible:
+ *
+ * 1. if cwd overridden in args, use it to read the package.json directly
+ * 2. if cwd not overridden and root is not cwd, use the cwd to read the package.json directly
+ * 3. if root is cwd, assume the task is global
+ *
+ * @param options
+ * @param command
+ * @returns
+ */ function parsePackageInfoFromArgs(root, cwd, packageName, task) {
+    if (packageName && task) {
+        const packageInfos = (0, _workspacetools.getPackageInfos)(root);
+        const info = packageInfos[packageName];
+        return {
+            info,
+            task,
+            isGlobal: false
+        };
+    }
+    if (cwd) {
+        const packageJsonPath = _path.default.join(cwd, "package.json");
+        const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, "utf-8"));
+        return {
+            info: {
+                ...packageJson,
+                packageJsonPath
+            },
+            task,
+            isGlobal: false
+        };
+    }
+    if (root !== process.cwd()) {
+        const packageJsonPath = _path.default.join(process.cwd(), "package.json");
+        if (_fs.default.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, "utf-8"));
+            return {
+                info: {
+                    ...packageJson,
+                    packageJsonPath
+                },
+                task,
+                isGlobal: false
+            };
+        }
+    }
+    const packageJsonPath = _path.default.join(root, "package.json");
+    const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, "utf-8"));
+    return {
+        info: {
+            ...packageJson,
+            packageJsonPath
+        },
+        task,
+        isGlobal: true
+    };
+}
+async function executeInProcess({ cwd , args , nodeArg , logger  }) {
+    const root = (0, _workspacetools.getWorkspaceRoot)(process.cwd());
+    const config = await (0, _config.getConfig)(root);
+    const { pipeline  } = config;
+    const taskArg = args?.length === 1 ? args?.[0] : args?.[1];
+    const packageName = args?.length ?? 0 > 1 ? args?.[0] : undefined;
+    if (!taskArg) {
+        throw new Error("No task provided");
+    }
+    const { info , task , isGlobal  } = parsePackageInfoFromArgs(root, cwd, packageName, taskArg);
+    const packageInfos = {
+        [info.name]: info
+    };
+    const resolve = ()=>{
+        return _path.default.dirname(info.packageJsonPath).replace(/\\/g, "/");
+    };
+    const { taskArgs  } = (0, _filterArgsForTasks.filterArgsForTasks)(args ?? []);
+    const factory = new _targetgraph.TargetFactory({
+        root,
+        resolve,
+        packageInfos
+    });
+    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 runnerPicker = new _runners.TargetRunnerPicker(pickerOptions);
+    const runner = await runnerPicker.pick(target);
+    if (await runner.shouldRun(target)) {
+        logger.info("Running target", {
+            target
+        });
+        await runner.run({
+            target,
+            weight: 1,
+            abortSignal: new AbortController().signal
+        });
+        logger.info("Finished", {
+            target
+        });
+    }
+}

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

@@ -0,0 +1,8 @@
+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/exec/executeRemotely.js

@@ -0,0 +1,32 @@
+"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;
+}

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

@@ -0,0 +1,7 @@
+import { type PipelineDefinition } from "@lage-run/config";
+export declare function expandTargetDefinition(packageName: string | undefined, task: string, pipeline: PipelineDefinition, outputs: string[]): import("@lage-run/target-graph").TargetConfig | {
+    cache: boolean;
+    dependsOn: never[];
+    options: {};
+    outputs: string[];
+};

package/lib/commands/exec/expandTargetDefinition.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "expandTargetDefinition", {
+    enumerable: true,
+    get: function() {
+        return expandTargetDefinition;
+    }
+});
+function expandTargetDefinition(packageName, task, pipeline, outputs) {
+    const id = packageName ? `${packageName}#${task}` : task;
+    const emptyDefinition = {
+        cache: false,
+        dependsOn: [],
+        options: {},
+        outputs
+    };
+    const definition = id in pipeline ? pipeline[id] : `#${task}` in pipeline ? pipeline[`#${task}`] : `//${task}` in pipeline ? pipeline[`//${task}`] : task in pipeline ? pipeline[task] : emptyDefinition;
+    if (Array.isArray(definition)) {
+        return emptyDefinition;
+    } else {
+        return definition;
+    }
+}

package/lib/commands/exec/index.js

@@ -12,4 +12,5 @@ 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

@@ -0,0 +1,9 @@
+import type { ReporterInitOptions } from "../../types/ReporterInitOptions.js";
+import type { Command } from "commander";
+interface WorkerOptions extends ReporterInitOptions {
+    nodeArg?: string[];
+    port?: number;
+    host?: string;
+}
+export declare function workerAction(options: WorkerOptions, command: Command): Promise<void>;
+export {};

package/lib/commands/server/action.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "workerAction", {
+    enumerable: true,
+    get: function() {
+        return workerAction;
+    }
+});
+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");
+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);
+        }
+    }
+    return Array.from(tasks);
+}
+async function workerAction(options, command) {
+    const { port =5332 , host ="localhost"  } = options;
+    const cwd = process.cwd();
+    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
+    });
+}

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

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+declare const serverCommand: Command;
+export { serverCommand };

package/lib/commands/server/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "serverCommand", {
+    enumerable: true,
+    get: function() {
+        return serverCommand;
+    }
+});
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _commander = require("commander");
+const _action = require("./action.js");
+const _addLoggerOptions = require("../addLoggerOptions.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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);

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

@@ -0,0 +1,4 @@
+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>;

package/lib/commands/server/lageService.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createLageService", {
+    enumerable: true,
+    get: function() {
+        return createLageService;
+    }
+});
+const _targetgraph = require("@lage-run/target-graph");
+async function createLageService(targetGraph, logger, npmClient, maxWorkers) {
+    logger.info(`Server started with ${maxWorkers} workers`);
+    const poolModule = (await import("@lage-run/worker-threads-pool")).default;
+    const pool = new poolModule.WorkerPool({
+        script: require.resolve("./singleTargetWorker.js"),
+        maxWorkers
+    });
+    return {
+        async runTarget (request) {
+            const runners = {
+                npmScript: {
+                    script: require.resolve("../run/runners/NpmScriptRunner.js"),
+                    options: {
+                        nodeOptions: request.nodeOptions,
+                        taskArgs: request.taskArgs,
+                        npmCmd: npmClient
+                    }
+                },
+                worker: {
+                    script: require.resolve("../run/runners/WorkerRunner.js"),
+                    options: {
+                        taskArgs: request.taskArgs
+                    }
+                },
+                noop: {
+                    script: require.resolve("../run/runners/NoOpRunner.js"),
+                    options: {}
+                }
+            };
+            if (!targetGraph.targets.has((0, _targetgraph.getTargetId)(request.packageName, request.task))) {
+                logger.error(`Target not found: ${request.packageName}#${request.task}`);
+                return {
+                    packageName: request.packageName,
+                    task: request.task,
+                    exitCode: 1
+                };
+            }
+            const target = targetGraph.targets.get((0, _targetgraph.getTargetId)(request.packageName, request.task));
+            const task = {
+                target,
+                runners
+            };
+            try {
+                await pool.exec(task, 0, (worker, stdout, stderr)=>{
+                    logger.info(`[${worker.threadId}] ${request.packageName}#${request.task} start`);
+                    stdout.pipe(process.stdout);
+                    stderr.pipe(process.stderr);
+                }, (worker)=>{
+                    logger.info(`[${worker.threadId}] ${request.packageName}#${request.task} end`);
+                });
+                return {
+                    packageName: request.packageName,
+                    task: request.task,
+                    exitCode: 0
+                };
+            } catch (e) {
+                return {
+                    packageName: request.packageName,
+                    task: request.task,
+                    exitCode: 1
+                };
+            }
+        }
+    };
+}

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

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

package/lib/commands/server/singleTargetWorker.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _workerthreadspool = require("@lage-run/worker-threads-pool");
+const _runners = require("@lage-run/runners");
+(async ()=>{
+    async function run(data, abortSignal) {
+        let value = undefined;
+        const runnerPicker = new _runners.TargetRunnerPicker(data.runners);
+        const runner = await runnerPicker.pick(data.target);
+        value = await runner.run({
+            target: data.target,
+            weight: 0,
+            abortSignal
+        });
+        return {
+            skipped: false,
+            hash: undefined,
+            value
+        };
+    }
+    (0, _workerthreadspool.registerWorker)(run);
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/cli",
-  "version": "0.18.1",
+  "version": "0.19.1",
   "description": "Command Line Interface for Lage",
   "repository": {
     "type": "git",
@@ -21,14 +21,16 @@
   },
   "dependencies": {
     "@lage-run/cache": "^1.3.1",
-    "@lage-run/config": "^0.3.7",
+    "@lage-run/config": "^0.4.0",
     "@lage-run/hasher": "^1.3.1",
     "@lage-run/logger": "^1.3.0",
     "@lage-run/reporters": "^1.2.8",
+    "@lage-run/rpc": "^1.1.0",
     "@lage-run/runners": "^1.0.1",
-    "@lage-run/scheduler": "^1.2.10",
+    "@lage-run/scheduler": "^1.2.11",
     "@lage-run/scheduler-types": "^0.3.14",
     "@lage-run/target-graph": "^0.8.9",
+    "@lage-run/worker-threads-pool": "^0.8.0",
     "chokidar": "3.5.3",
     "commander": "9.5.0",
     "execa": "5.1.1",