@flink-app/flink 0.14.3 → 2.0.0-alpha.100

package/cli/run.ts

@@ -1,83 +1,66 @@
 #!/usr/bin/env node
-import TypeScriptCompiler from "../src/TypeScriptCompiler";
+import { parseArgs, hasFlag, getOption, normalizeEntry, printHelp, compile, forkApp } from "./cli-utils";
+import { FlinkLogFactory } from "../src/FlinkLogFactory";
+import { loadFlinkConfig } from "../src/utils/loadFlinkConfig";
+import { loadEnvFiles } from "./loadEnvFiles";
 
-module.exports = async function run(args: string[]) {
-    const startTime = Date.now();
+// Load config BEFORE creating logger
+const flinkConfig = loadFlinkConfig();
+FlinkLogFactory.configure(flinkConfig?.logging);
 
-    if (args.includes("--help")) {
-        console.log(`
-    Description
-      Compiles and starts the application.
+module.exports = async function run(args: string[]) {
+    const parsed = parseArgs(args);
 
-    Usage
-      $ flink run <dir>
+    // Load .env files before anything else so all env vars are available at startup.
+    // NODE_ENV defaults to "production" when not explicitly set.
+    if (!process.env.NODE_ENV) {
+        process.env.NODE_ENV = "production";
+    }
 
-    <dir> represents the directory of the Flink application.
-    If no directory is provided, the current directory will be used.
-      
-    Options      
-      --entry         Entry script for app, default "/src/index.ts"
-      --help          Displays this message
-      --precompiled   Will run a precompiled app, default false
-      `);
+    const initLogger = FlinkLogFactory.createLogger("flink.init");
+    const { loaded, injected } = loadEnvFiles(parsed.dir, "production");
 
-        process.exit(0);
+    if (loaded.length > 0) {
+        initLogger.info(`Loaded env files: ${loaded.join(", ")} (${injected} vars injected)`);
     }
 
-    let dir = "./";
-    if (args[0] && !args[0].startsWith("--")) {
-        dir = args[0];
+    if (hasFlag(parsed, "help")) {
+        printHelp({
+            description: "Compiles and starts the application.",
+            usage: "$ flink run <dir>",
+            options: [
+                { name: "entry", description: 'Entry script for app, default "/src/index.ts"' },
+                { name: "help", description: "Displays this message" },
+                { name: "precompiled", description: "Will run a precompiled app, default false" },
+            ],
+        });
+        return;
     }
 
-    let entry = "/src/index.ts";
-    if (args.includes("--entry")) {
-        entry = args[args.indexOf("--entry") + 1];
-        entry = entry.startsWith("/") ? entry : "/" + entry;
-    }
+    const entry = normalizeEntry(getOption(parsed, "entry", "/src/index.ts"));
 
-    if (args.includes("--precompiled")) {
-        if (args.includes("--entry")) {
+    if (hasFlag(parsed, "precompiled")) {
+        if (parsed.options.has("entry")) {
             console.warn("WARNING: --entry is ignored when using --precompiled");
         }
 
-        // Collect extra arguments to pass through to the forked process
-        const extraArgs = args.filter(arg =>
-            arg !== "--precompiled" &&
-            !arg.startsWith("--entry") &&
-            arg !== args[args.indexOf("--entry") + 1]
-        ).filter(arg => arg !== args[0] || args[0].startsWith("--"));
-
-        const forkedProcess = require("child_process").fork(dir + "/dist/.flink/start.js", extraArgs);
-
-        forkedProcess.on("exit", (code: any) => {
-            process.exit(code);
+        forkApp({
+            dir: parsed.dir,
+            args,
+            cliFlags: ["precompiled", "entry"],
         });
         return;
     }
 
-    await TypeScriptCompiler.clean(dir);
-
-    const compiler = new TypeScriptCompiler(dir);
-
-    if (!compiler.getPreEmitDiagnostics()) {
-        process.exit(1);
-    }
-
-    await Promise.all([compiler.parseRepos(), compiler.parseHandlers(), compiler.parseJobs(), compiler.generateStartScript(entry)]);
-
-    console.log(`Compilation done, took ${Date.now() - startTime}ms`);
-
-    compiler.emit();
-
-    // Collect extra arguments to pass through to the forked process
-    const extraArgs = args.filter(arg =>
-        !arg.startsWith("--entry") &&
-        arg !== args[args.indexOf("--entry") + 1]
-    ).filter(arg => arg !== args[0] || args[0].startsWith("--"));
-
-    const forkedProcess = require("child_process").fork(dir + "/dist/.flink/start.js", extraArgs);
+    await compile({
+        dir: parsed.dir,
+        entry,
+        typeCheck: true,
+    });
 
-    forkedProcess.on("exit", (code: any) => {
-        process.exit(code);
+    forkApp({
+        dir: parsed.dir,
+        args,
+        cliFlags: ["entry"],
     });
 };

package/dist/bin/flink.js

@@ -1,7 +1,43 @@
 #!/usr/bin/env node
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var commands = ["build", "generate" /* 'generate' is alias for 'build'   */, "run", "clean", "help"];
+var commands = ["build", "generate" /* 'generate' is alias for 'build' */, "run", "dev", "clean", "help"];
 var argv = process.argv.slice(2);
 var argCommand = argv[0];
 if (!argCommand || argv[0] === "help") {
@@ -16,5 +52,28 @@ if (argCommand === "generate") {
     argCommand = "build";
 }
 var cmd = require("../cli/" + argCommand);
-cmd(argv.slice(1));
+(function () { return __awaiter(void 0, void 0, void 0, function () {
+    var error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, cmd(argv.slice(1))];
+            case 1:
+                _a.sent();
+                return [3 /*break*/, 3];
+            case 2:
+                error_1 = _a.sent();
+                if (process.env.DEBUG === "true") {
+                    console.error(error_1);
+                }
+                else {
+                    console.error("Error: ".concat(error_1.message));
+                }
+                process.exit(1);
+                return [3 /*break*/, 3];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); })();
 exports.default = (function () { });

package/dist/cli/build.js

@@ -36,40 +36,35 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var TypeScriptCompiler_1 = __importDefault(require("../src/TypeScriptCompiler"));
 var cli_utils_1 = require("./cli-utils");
-module.exports = function run(args) {
+var FlinkLogFactory_1 = require("../src/FlinkLogFactory");
+var loadFlinkConfig_1 = require("../src/utils/loadFlinkConfig");
+// Load config BEFORE creating logger
+var flinkConfig = (0, loadFlinkConfig_1.loadFlinkConfig)();
+FlinkLogFactory_1.FlinkLogFactory.configure(flinkConfig === null || flinkConfig === void 0 ? void 0 : flinkConfig.logging);
+module.exports = function build(args) {
     return __awaiter(this, void 0, void 0, function () {
-        var startTime, dir, exclude, compiler;
+        var parsed;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    startTime = Date.now();
-                    if (args.includes("--help")) {
-                        console.log("\n    Description\n      Builds the application.\n      Will generate intermediates files in .flink and compile/transpile\n      javascript bundle in /dist folder\n\n    Usage\n      $ flink build <dir>\n\n    <dir> represents the directory of the Flink application.\n    If no directory is provided, the current directory will be used.\n      \n    Options            \n      --help    Displays this message\n      ");
-                        process.exit(0);
-                    }
-                    dir = "./";
-                    if (args[0] && !args[0].startsWith("--")) {
-                        dir = args[0];
+                    parsed = (0, cli_utils_1.parseArgs)(args);
+                    if ((0, cli_utils_1.hasFlag)(parsed, "help")) {
+                        (0, cli_utils_1.printHelp)({
+                            description: "Builds the application.\n      Will generate intermediates files in .flink and compile/transpile\n      javascript bundle in /dist folder",
+                            usage: "$ flink build <dir>",
+                            options: [{ name: "help", description: "Displays this message" }],
+                        });
+                        return [2 /*return*/];
                     }
-                    exclude = (0, cli_utils_1.getOption)(args, "exclude", "/spec");
-                    return [4 /*yield*/, TypeScriptCompiler_1.default.clean(dir)];
+                    return [4 /*yield*/, (0, cli_utils_1.compile)({
+                            dir: parsed.dir,
+                            typeCheck: true,
+                            timingLogs: true,
+                        })];
                 case 1:
                     _a.sent();
-                    compiler = new TypeScriptCompiler_1.default(dir);
-                    if (!compiler.getPreEmitDiagnostics()) {
-                        process.exit(1);
-                    }
-                    return [4 /*yield*/, Promise.all([compiler.parseRepos(), compiler.parseHandlers(exclude.split(",")), compiler.parseJobs(), compiler.generateStartScript()])];
-                case 2:
-                    _a.sent();
-                    console.log("Compilation done, took ".concat(Date.now() - startTime, "ms"));
-                    compiler.emit();
                     return [2 /*return*/];
             }
         });

package/dist/cli/clean.js

@@ -41,21 +41,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var TypeScriptCompiler_1 = __importDefault(require("../src/TypeScriptCompiler"));
-module.exports = function run(args) {
+var cli_utils_1 = require("./cli-utils");
+module.exports = function clean(args) {
     return __awaiter(this, void 0, void 0, function () {
-        var dir, cleanedFolder;
+        var parsed, cleanedFolder;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    if (args.includes("--help")) {
-                        console.log("\n    Description\n      Removes all generated files.\n\n    Usage\n      $ flink clean <dir>\n\n    <dir> represents the directory of the Flink application.\n    If no directory is provided, the current directory will be used.\n      \n    Options\n      --help    Displays this message\n      ");
-                        process.exit(0);
+                    parsed = (0, cli_utils_1.parseArgs)(args);
+                    if ((0, cli_utils_1.hasFlag)(parsed, "help")) {
+                        (0, cli_utils_1.printHelp)({
+                            description: "Removes all generated files.",
+                            usage: "$ flink clean <dir>",
+                            options: [{ name: "help", description: "Displays this message" }],
+                        });
+                        return [2 /*return*/];
                     }
-                    dir = "./";
-                    if (args[0] && !args[0].startsWith("--")) {
-                        dir = args[0];
-                    }
-                    return [4 /*yield*/, TypeScriptCompiler_1.default.clean(dir)];
+                    return [4 /*yield*/, TypeScriptCompiler_1.default.clean(parsed.dir)];
                 case 1:
                     cleanedFolder = _a.sent();
                     console.log("Cleaned directory ".concat(cleanedFolder));

package/dist/cli/cli-utils.d.ts

@@ -1,3 +1,34 @@
-export declare function getOption(args: string[], name: string, defaultValue: string | boolean, opts?: {
-    isBoolean?: boolean;
-}): string | boolean;
+export interface ParsedArgs {
+    dir: string;
+    flags: Set<string>;
+    options: Map<string, string>;
+}
+export declare function parseArgs(args: string[]): ParsedArgs;
+export declare function hasFlag(parsed: ParsedArgs, name: string): boolean;
+export declare function getOption(parsed: ParsedArgs, name: string, defaultValue: string): string;
+export declare function normalizeEntry(entry: string): string;
+interface HelpOption {
+    name: string;
+    description: string;
+}
+interface HelpConfig {
+    description: string;
+    usage: string;
+    options: HelpOption[];
+}
+export declare function printHelp(config: HelpConfig): void;
+export interface CompileOptions {
+    dir: string;
+    entry?: string;
+    typeCheck?: boolean;
+    timingLogs?: boolean;
+}
+export declare function compile(opts: CompileOptions): Promise<void>;
+export interface ForkOptions {
+    dir: string;
+    args: string[];
+    cliFlags: string[];
+    stdio?: "inherit" | "pipe" | "ignore";
+}
+export declare function forkApp(opts: ForkOptions): ReturnType<typeof require>;
+export {};

package/dist/cli/cli-utils.js

@@ -1,19 +1,200 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.hasFlag = hasFlag;
 exports.getOption = getOption;
-function getOption(args, name, defaultValue, opts) {
-    if (opts === void 0) { opts = {}; }
-    var option = "--".concat(name);
-    if (args.includes(option)) {
-        if (opts.isBoolean && args[args.indexOf(option) + 1] !== "false") {
-            return true;
+exports.normalizeEntry = normalizeEntry;
+exports.printHelp = printHelp;
+exports.compile = compile;
+exports.forkApp = forkApp;
+var TypeScriptCompiler_1 = __importDefault(require("../src/TypeScriptCompiler"));
+function parseArgs(args) {
+    var flags = new Set();
+    var options = new Map();
+    var dir = "./";
+    var i = 0;
+    // First non-flag arg is the directory
+    if (args[0] && !args[0].startsWith("--")) {
+        dir = args[0];
+        i = 1;
+    }
+    while (i < args.length) {
+        var arg = args[i];
+        if (arg.startsWith("--")) {
+            var name = arg.slice(2);
+            var next = args[i + 1];
+            if (next && !next.startsWith("--")) {
+                options.set(name, next);
+                i += 2;
+            }
+            else {
+                flags.add(name);
+                i += 1;
+            }
+        }
+        else {
+            i += 1;
+        }
+    }
+    return { dir: dir, flags: flags, options: options };
+}
+function hasFlag(parsed, name) {
+    return parsed.flags.has(name);
+}
+function getOption(parsed, name, defaultValue) {
+    var _a;
+    return (_a = parsed.options.get(name)) !== null && _a !== void 0 ? _a : defaultValue;
+}
+function normalizeEntry(entry) {
+    return entry.startsWith("/") ? entry : "/" + entry;
+}
+function printHelp(config) {
+    var optionLines = config.options
+        .map(function (opt) { return "      --".concat(opt.name.padEnd(14), " ").concat(opt.description); })
+        .join("\n");
+    console.log("\n    Description\n      ".concat(config.description, "\n\n    Usage\n      ").concat(config.usage, "\n\n    <dir> represents the directory of the Flink application.\n    If no directory is provided, the current directory will be used.\n\n    Options\n").concat(optionLines, "\n"));
+}
+function compile(opts) {
+    return __awaiter(this, void 0, void 0, function () {
+        var dir, entry, _a, typeCheck, _b, timingLogs, start, time, stepStart, compiler;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    dir = opts.dir, entry = opts.entry, _a = opts.typeCheck, typeCheck = _a === void 0 ? true : _a, _b = opts.timingLogs, timingLogs = _b === void 0 ? false : _b;
+                    start = timingLogs ? Date.now() : 0;
+                    time = function (label, stepStart) {
+                        if (timingLogs) {
+                            console.log("\u23F1\uFE0F  ".concat(label, ": ").concat(Date.now() - stepStart, "ms"));
+                        }
+                    };
+                    return [4 /*yield*/, TypeScriptCompiler_1.default.clean(dir)];
+                case 1:
+                    _c.sent();
+                    stepStart = Date.now();
+                    compiler = new TypeScriptCompiler_1.default(dir);
+                    time("Compiler initialization", stepStart);
+                    stepStart = Date.now();
+                    return [4 /*yield*/, compiler.parseRepos()];
+                case 2:
+                    _c.sent();
+                    return [4 /*yield*/, compiler.parseTools()];
+                case 3:
+                    _c.sent();
+                    return [4 /*yield*/, compiler.parseAgents()];
+                case 4:
+                    _c.sent();
+                    return [4 /*yield*/, compiler.parseJobs()];
+                case 5:
+                    _c.sent();
+                    return [4 /*yield*/, compiler.parseServices()];
+                case 6:
+                    _c.sent();
+                    return [4 /*yield*/, compiler.parseAllExtensionDirs()];
+                case 7:
+                    _c.sent();
+                    return [4 /*yield*/, compiler.parseHandlers()];
+                case 8:
+                    _c.sent();
+                    return [4 /*yield*/, compiler.generateStartScript(entry)];
+                case 9:
+                    _c.sent();
+                    return [4 /*yield*/, compiler.generateAllSchemas()];
+                case 10:
+                    _c.sent();
+                    return [4 /*yield*/, compiler.saveAllModifiedFiles()];
+                case 11:
+                    _c.sent();
+                    if (typeCheck) {
+                        stepStart = Date.now();
+                        if (!compiler.getPreEmitDiagnostics()) {
+                            throw new Error("Type checking failed");
+                        }
+                        time("Type checking (getPreEmitDiagnostics)", stepStart);
+                    }
+                    stepStart = Date.now();
+                    if (!(process.env.FLINK_USE_TSC === "true")) return [3 /*break*/, 12];
+                    compiler.emitWithTsc();
+                    return [3 /*break*/, 14];
+                case 12: return [4 /*yield*/, compiler.emit()];
+                case 13:
+                    _c.sent();
+                    _c.label = 14;
+                case 14:
+                    time("Transpilation (".concat(process.env.FLINK_USE_TSC === "true" ? "tsc" : "swc", ")"), stepStart);
+                    if (timingLogs) {
+                        console.log("Compilation done in ".concat(Date.now() - start, "ms"));
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function forkApp(opts) {
+    var dir = opts.dir, args = opts.args, cliFlags = opts.cliFlags, stdio = opts.stdio;
+    // Filter out CLI-specific flags and their values from args passed to child process
+    var cliSet = new Set(cliFlags.map(function (f) { return "--".concat(f); }));
+    var extraArgs = [];
+    for (var i = 0; i < args.length; i++) {
+        if (cliSet.has(args[i])) {
+            // Skip this flag and its value (if the next arg is not a flag)
+            var next = args[i + 1];
+            if (next && !next.startsWith("--")) {
+                i++; // skip value too
+            }
+            continue;
         }
-        var value = args[args.indexOf(option) + 1];
-        if (!value || value.startsWith("--")) {
-            console.log("WARN: Missing value for option", option);
-            process.exit(1);
+        // Skip the dir argument (first non-flag arg)
+        if (i === 0 && !args[i].startsWith("--")) {
+            continue;
         }
-        return value;
+        extraArgs.push(args[i]);
+    }
+    var forkOpts = {};
+    if (stdio) {
+        forkOpts.stdio = stdio;
     }
-    return defaultValue;
+    var forkedProcess = require("child_process").fork(dir + "/dist/.flink/start.js", extraArgs, forkOpts);
+    forkedProcess.on("exit", function (code) {
+        process.exit(code);
+    });
+    return forkedProcess;
 }

package/dist/cli/dev.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};