@jujulego/jill 2.4.0-alpha.2 → 2.4.0-alpha.4

package/dist/ink-command-SIxVoU_e.js

@@ -0,0 +1,1177 @@
+import { withTimestamp, LogLevel, quick, qlevelColor, toStderr, Logger, logger$, withLabel } from '@jujulego/logger';
+import { Container, decorate, injectable, inject, ContainerModule } from 'inversify';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { SpawnTask, GroupTask, TaskSet, TaskManager } from '@jujulego/tasks';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { Box, Text, useStderr, render } from 'ink';
+import { useState, useLayoutEffect, useMemo, Fragment as Fragment$1 } from 'react';
+import os from 'node:os';
+import path from 'node:path';
+import Ajv from 'ajv';
+import wt, { BroadcastChannel, setEnvironmentData, getEnvironmentData } from 'node:worker_threads';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
+import { source$, once$, waitFor$ } from '@jujulego/event-tree';
+import Spinner from 'ink-spinner';
+import symbols from 'log-symbols';
+import ms from 'pretty-ms';
+import getDecorators from 'inversify-inject-decorators';
+import 'reflect-metadata';
+import { flow$, filter$, var$ } from '@jujulego/aegis';
+import { qprop } from '@jujulego/quick-tag';
+import { chalkTemplateStderr } from 'chalk-template';
+
+// Utils
+async function dynamicImport(filepath) {
+    return import(/* webpackIgnore: true */ process.platform === "win32" ? `file://${filepath}` : filepath);
+}
+function fixDefaultExport(mod) {
+    return "default" in mod ? mod.default : mod;
+}
+
+// Container
+const container = new Container();
+// Utilities
+const { lazyInject, lazyInjectNamed } = fixDefaultExport(getDecorators)(container);
+
+// Decorators
+/**
+ * Register class as a service
+ */ function Service() {
+    return (cls)=>{
+        decorate(injectable(), cls);
+        container.bind(cls).toSelf().inSingletonScope().onActivation((ctx, service)=>{
+            if ("onServiceActivate" in service) {
+                service.onServiceActivate(ctx);
+            }
+            return service;
+        });
+        return cls;
+    };
+}
+
+// Constants
+const LOG_BROADCAST_CHANNEL = Symbol.for("jujulego:jill:log-broadcast-channel");
+// Parameters
+container.bind(LOG_BROADCAST_CHANNEL).toConstantValue("jujulego:jill:logger");
+
+function _ts_decorate$4(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_param$2(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let ThreadGateway = class ThreadGateway {
+    // Constructor
+    constructor(channel){
+        this._source = source$();
+        this.subscribe = this._source.subscribe;
+        this.unsubscribe = this._source.unsubscribe;
+        this.clear = this._source.clear;
+        this.channel = new BroadcastChannel(channel);
+        this.channel.unref();
+        this.channel.onmessage = (log)=>{
+            this._source.next(log.data);
+        };
+        this.channel.onmessageerror = (data)=>{
+            this._source.next(withTimestamp()({
+                level: LogLevel.error,
+                message: quick.string`Unable to read message: #!json:${data.data}`
+            }));
+        };
+    }
+    // Methods
+    next(data) {
+        this.channel.postMessage(data);
+    }
+};
+ThreadGateway = _ts_decorate$4([
+    Service(),
+    _ts_param$2(0, inject(LOG_BROADCAST_CHANNEL))
+], ThreadGateway);
+
+function _ts_decorate$3(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+// Utils
+const jillLogFormat = qlevelColor(quick.wrap(chalkTemplateStderr).function`#?:${qprop("label")}{grey [#$]} ?#${qprop("message")}#?:${qprop("error")}\n#!error$?#`);
+let LogGateway = class LogGateway {
+    // Lifecycle
+    onServiceActivate({ container }) {
+        const threadGtw = container.get(ThreadGateway);
+        if (wt.isMainThread) {
+            // Redirect logs to stderr
+            flow$(this._source, toStderr(jillLogFormat));
+            // Add thread gateway as input
+            this.connect(threadGtw);
+        } else {
+            // Redirect logs to thread gateway
+            flow$(this._source, threadGtw);
+        }
+    }
+    connect(origin) {
+        return flow$(origin, filter$((log)=>log.level >= this.level), this._source);
+    }
+    // Properties
+    get listeners() {
+        return Array.from(this._source.listeners);
+    }
+    get level() {
+        return this.level$.read();
+    }
+    set level(level) {
+        this.level$.mutate(level);
+    }
+    constructor(){
+        // Attributes
+        this.level$ = var$(LogLevel.info);
+        this._source = source$();
+        // Methods
+        this.subscribe = this._source.subscribe;
+        this.unsubscribe = this._source.unsubscribe;
+        this.clear = this._source.clear;
+    }
+};
+LogGateway = _ts_decorate$3([
+    Service()
+], LogGateway);
+
+// Service
+container.bind(Logger).toDynamicValue(()=>logger$(withTimestamp())).inSingletonScope().onActivation(({ container }, logger)=>{
+    const gateway = container.get(LogGateway);
+    gateway.connect(logger);
+    return logger;
+});
+
+function _ts_decorate$2(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_param$1(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let ContextService = class ContextService {
+    // Constructor
+    constructor(logger){
+        this._storage = new AsyncLocalStorage();
+        this._logger = logger.child(withLabel("context"));
+        this.reset();
+    }
+    // Methods
+    reset(context = {}) {
+        this._storage.enterWith(context);
+    }
+    _getContext() {
+        const ctx = this._storage.getStore();
+        if (!ctx) {
+            this._logger.warning("Trying to access uninitialized context");
+            return {};
+        }
+        return ctx;
+    }
+    _updateContext(update) {
+        Object.assign(this._getContext(), update);
+    }
+    // Properties
+    get application() {
+        return this._getContext().application;
+    }
+    set application(application) {
+        this._updateContext({
+            application
+        });
+    }
+    get project() {
+        return this._getContext().project;
+    }
+    set project(project) {
+        this._updateContext({
+            project
+        });
+    }
+    get workspace() {
+        return this._getContext().workspace;
+    }
+    set workspace(workspace) {
+        this._updateContext({
+            workspace
+        });
+    }
+};
+ContextService = _ts_decorate$2([
+    Service(),
+    _ts_param$1(0, inject(Logger))
+], ContextService);
+
+// Symbols
+const CONFIG_OPTIONS = Symbol("jujulego:jill:config-options");
+// Constants
+const VERBOSITY_LEVEL = {
+    1: "verbose",
+    2: "debug"
+};
+// Options
+function applyConfigOptions(parser) {
+    return parser.option("verbose", {
+        alias: "v",
+        type: "count",
+        description: "Set verbosity level",
+        coerce: (cnt)=>VERBOSITY_LEVEL[Math.min(cnt, 2)]
+    }).option("jobs", {
+        alias: "j",
+        type: "number",
+        description: "Set maximum parallel job number"
+    }).option("hooks", {
+        type: "boolean",
+        description: "Run hook scripts"
+    });
+}
+container.bind(CONFIG_OPTIONS).toDynamicValue(()=>{
+    const parser = yargs(hideBin(process.argv)).help(false).version(false);
+    applyConfigOptions(parser);
+    return parser.parse();
+}).inSingletonScope();
+
+// Constants
+const CURRENT = "current";
+
+// Symbols
+const MODULE = Symbol("jujulego:jill:module");
+const REGISTRY = Symbol("jujulego:jill:registry");
+// Utils
+function getRegistry(target) {
+    const registry = Reflect.getMetadata(REGISTRY, target);
+    if (typeof registry !== "function") {
+        throw new Error(`No registry found in ${target.name}`);
+    }
+    return registry;
+}
+function setRegistry(target, registry) {
+    Reflect.defineMetadata(REGISTRY, registry, target);
+}
+function getModule(target, assert = false) {
+    let module = Reflect.getMetadata(MODULE, target);
+    if (!module || !(module instanceof ContainerModule)) {
+        const registry = Reflect.getMetadata(REGISTRY, target);
+        if (typeof registry !== "function") {
+            if (assert) {
+                throw new Error(`No module found in ${target.name}`);
+            }
+            return null;
+        }
+        module = new ContainerModule(registry);
+        setModule(target, module);
+    }
+    return module;
+}
+function setModule(target, module) {
+    Reflect.defineMetadata(MODULE, module, target);
+}
+
+// Class
+class ExitException extends Error {
+    // Constructor
+    constructor(code, message){
+        super(message);
+        this.code = code;
+    }
+}
+
+// Decorator
+function Middleware() {
+    return (target)=>{
+        decorate(injectable(), target);
+        container.bind(target).toSelf().inSingletonScope();
+    };
+}
+// Utils
+function applyMiddlewares(parser, middlewares) {
+    let tmp = parser;
+    for (const cls of middlewares){
+        const middleware = container.get(cls);
+        if (middleware.builder) {
+            tmp = middleware.builder(tmp);
+        }
+        tmp.middleware((args)=>middleware.handler(args));
+    }
+    return tmp;
+}
+
+// Symbols
+const COMMAND_OPTS = Symbol("jujulego:jill:command-opts");
+const COMMAND = Symbol("jujulego:jill:command");
+const COMMAND_MODULE = Symbol("jujulego:jill:command-module");
+// Utils
+function getCommandOpts(target) {
+    const opts = Reflect.getMetadata(COMMAND_OPTS, target);
+    if (typeof opts !== "object") {
+        throw new Error(`No command options found in ${target.name}`);
+    }
+    return opts;
+}
+function buildCommandModule(cmd, opts) {
+    return {
+        command: opts.command,
+        aliases: opts.aliases,
+        describe: opts.describe,
+        deprecated: opts.deprecated,
+        builder (parser) {
+            if (opts.middlewares) {
+                parser = applyMiddlewares(parser, opts.middlewares);
+            }
+            if (cmd.builder) {
+                parser = cmd.builder(parser);
+            }
+            return parser;
+        },
+        handler: async (args)=>{
+            try {
+                await cmd.handler(args);
+            } catch (err) {
+                if (err.message) {
+                    const logger = container.get(Logger);
+                    logger.error("Error while running command:", err);
+                }
+                throw new ExitException(1);
+            }
+        }
+    };
+}
+// Decorator
+function Command(opts) {
+    return (target)=>{
+        decorate(injectable(), target);
+        Reflect.defineMetadata(COMMAND_OPTS, opts, target);
+        const cmd = opts.command.split(" ")[0];
+        setRegistry(target, (bind)=>{
+            bind(target).toSelf();
+            bind(COMMAND).toDynamicValue(({ container })=>container.getAsync(target)).whenTargetNamed(cmd);
+            bind(COMMAND_MODULE).toDynamicValue(async ({ container })=>{
+                const cmd = await container.getAsync(target);
+                return buildCommandModule(cmd, opts);
+            }).whenTargetNamed(cmd);
+        });
+    };
+}
+
+// Symbols
+const AJV = Symbol("jujulego:jill:Ajv");
+// Setup
+container.bind(AJV).toDynamicValue(({ container })=>{
+    const logger = container.get(Logger);
+    return new Ajv.default({
+        allErrors: true,
+        logger: logger.child(withLabel("ajv")),
+        strict: process.env.NODE_ENV === "development" ? "log" : true
+    });
+}).inSingletonScope();
+
+function isCacheUpdate(msg) {
+    return typeof msg === "object" && msg !== null && "key" in msg && "value" in msg;
+}
+// Chanel
+const channel = new BroadcastChannel("jujulego:jill:worker-cache");
+channel.unref();
+channel.onmessage = (arg)=>{
+    const msg = arg;
+    if (isCacheUpdate(msg.data)) {
+        setEnvironmentData(msg.data.key, msg.data.value);
+    }
+};
+// Utils
+async function workerCache(key, compute) {
+    const cache = getEnvironmentData(key);
+    if (cache !== undefined) return cache;
+    // Compute it
+    const result = await compute();
+    setEnvironmentData(key, result);
+    channel.postMessage({
+        key,
+        value: result
+    });
+    return result;
+}
+
+var $schema = "http://json-schema.org/draft-07/schema";
+var type = "object";
+var additionalProperties = false;
+var properties = {
+	jobs: {
+		type: "number"
+	},
+	hooks: {
+		type: "boolean",
+		"default": true,
+		description: "Run hook scripts"
+	},
+	plugins: {
+		type: "array",
+		items: {
+			type: "string"
+		}
+	},
+	verbose: {
+		type: "string",
+		"enum": [
+			"info",
+			"verbose",
+			"debug"
+		]
+	}
+};
+var schema = {
+	$schema: $schema,
+	type: type,
+	additionalProperties: additionalProperties,
+	properties: properties
+};
+
+// Symbols
+const CONFIG_EXPLORER = Symbol("jujulego:jill:config-explorer");
+const CONFIG_VALIDATOR = Symbol("jujulego:jill:config-validator");
+// Setup
+container.bind(CONFIG_VALIDATOR).toDynamicValue(({ container })=>{
+    const ajv = container.get(AJV);
+    return ajv.compile(schema);
+}).inSingletonScope();
+container.bind(CONFIG_EXPLORER).toDynamicValue(()=>{
+    return cosmiconfig("jill", {
+        loaders: {
+            ".cjs": (filepath)=>dynamicImport(filepath).then((mod)=>mod.default),
+            ".js": (filepath)=>dynamicImport(filepath).then((mod)=>mod.default),
+            ".json": defaultLoaders[".json"],
+            ".yaml": defaultLoaders[".yaml"],
+            ".yml": defaultLoaders[".yml"],
+            noExt: defaultLoaders.noExt
+        }
+    });
+}).inSingletonScope();
+
+// Symbols
+const CONFIG = Symbol("jujulego:jill:config");
+// Loader
+async function configLoader() {
+    const logger = container.get(Logger).child(withLabel("config"));
+    const options = container.get(CONFIG_OPTIONS);
+    const explorer = container.get(CONFIG_EXPLORER);
+    const validator = container.get(CONFIG_VALIDATOR);
+    // Load file
+    const loaded = await explorer.search();
+    const config = loaded?.config ?? {};
+    // Apply options from cli
+    if (options.jobs) config.jobs = options.jobs;
+    if (options.verbose) config.verbose = options.verbose;
+    if (options.hooks !== undefined) config.hooks = options.hooks;
+    // Apply defaults
+    config.jobs ??= os.cpus().length - 1;
+    config.hooks ??= true;
+    // Validate
+    if (!validator(config)) {
+        const ajv = container.get(AJV);
+        const errors = ajv.errorsText(validator.errors, {
+            separator: "\n- ",
+            dataVar: "config"
+        });
+        logger.error(`Errors in config file:\n- ${errors}`);
+        throw new ExitException(1);
+    }
+    // Apply on logger
+    if (config.verbose) {
+        container.get(LogGateway).level = LogLevel[config.verbose];
+    }
+    if (loaded) {
+        // Resolve paths relative to config file
+        const base = path.dirname(loaded.filepath);
+        config.plugins = config.plugins?.map((plugin)=>path.resolve(base, plugin));
+        logger.verbose(`Loaded ${loaded.filepath} config file`);
+    }
+    logger.debug`Loaded config:\n#!json:${config}`;
+    return config;
+}
+container.bind(CONFIG).toDynamicValue(async ()=>await workerCache("jujulego:jill:config", configLoader)).inSingletonScope();
+
+function _ts_decorate$1(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let PluginLoaderService = class PluginLoaderService {
+    // Constructor
+    constructor(_config, logger){
+        this._config = _config;
+        this._logger = logger.child(withLabel("plugin"));
+    }
+    // Methods
+    async _importPlugin(filepath) {
+        this._logger.verbose`Loading plugin ${filepath}`;
+        // Load plugin
+        let plugin = await dynamicImport(filepath);
+        while(plugin && typeof plugin === "object" && "default" in plugin){
+            plugin = plugin.default;
+        }
+        if (!plugin) {
+            throw new Error(`Invalid plugin ${filepath}: no plugin class found`);
+        }
+        // Load module from plugin
+        const module = getModule(plugin);
+        if (!module) {
+            throw new Error(`Invalid plugin ${filepath}: invalid plugin class`);
+        }
+        return module;
+    }
+    async loadPlugins(ctn = container) {
+        if (!this._config.plugins) return;
+        for (const path of this._config.plugins){
+            const plugin = await this._importPlugin(path);
+            ctn.load(plugin);
+        }
+    }
+};
+PluginLoaderService = _ts_decorate$1([
+    Service(),
+    _ts_param(0, inject(CONFIG)),
+    _ts_param(1, inject(Logger))
+], PluginLoaderService);
+
+// Utils
+function linesFrom(task, stream) {
+    const inner = source$();
+    if (task.completed) {
+        return inner;
+    }
+    // Listen to stream
+    let current = "";
+    const stop = task.on(`stream.${stream}`, (chunk)=>{
+        const data = current + chunk.data.toString("utf-8");
+        const lines = data.split(/\r?\n/);
+        current = lines.pop() ?? "";
+        for (const line of lines){
+            inner.next(line);
+        }
+    });
+    // Listen to end of task
+    once$(task, "completed", ()=>{
+        stop();
+        if (current) {
+            inner.next(current);
+        }
+    });
+    return inner;
+}
+
+// Utils
+function isCommandCtx(ctx) {
+    return "workspace" in ctx && "command" in ctx;
+}
+// Class
+class CommandTask extends SpawnTask {
+    // Constructor
+    constructor(workspace, command, args, opts = {}){
+        let cmd = command;
+        if (opts.superCommand) {
+            if (typeof opts.superCommand === "string") {
+                opts.superCommand = [
+                    opts.superCommand
+                ];
+            }
+            if (opts.superCommand.length > 0) {
+                cmd = opts.superCommand[0];
+                args = [
+                    ...opts.superCommand.slice(1),
+                    command,
+                    ...args
+                ];
+            }
+        }
+        super(cmd, args, {
+            workspace,
+            command
+        }, {
+            ...opts,
+            cwd: workspace.cwd,
+            env: {
+                FORCE_COLOR: "1",
+                ...opts.env
+            }
+        });
+        this.workspace = workspace;
+        this._logStreams();
+    }
+    // Methods
+    _logStreams() {
+        // TODO: clean up this subscriptions
+        linesFrom(this, "stdout").subscribe((line)=>this._logger.info(line));
+        linesFrom(this, "stderr").subscribe((line)=>this._logger.info(line));
+    }
+}
+
+// Utils
+function capitalize(txt) {
+    return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+}
+function splitCommandLine(line) {
+    line = line.trim();
+    const parts = [];
+    let current_cote = "";
+    let last = 0;
+    for(let i = 1; i < line.length; ++i){
+        const c = line[i];
+        if (current_cote) {
+            if (c === current_cote) {
+                current_cote = "";
+            }
+        } else {
+            if ([
+                '"',
+                "'"
+            ].includes(c)) {
+                current_cote = c;
+            } else if (c === " ") {
+                parts.push(line.slice(last, i));
+                last = i + 1;
+            }
+        }
+    }
+    parts.push(line.slice(last));
+    return parts;
+}
+
+// Utils
+function isScriptCtx(ctx) {
+    return "workspace" in ctx && "script" in ctx;
+}
+// Class
+class ScriptTask extends GroupTask {
+    // Constructor
+    constructor(workspace, script, args, opts){
+        super(script, {
+            workspace,
+            script
+        }, opts);
+        this.workspace = workspace;
+        this.script = script;
+        this.args = args;
+        this._preHookTasks = null;
+        this._postHookTasks = null;
+        this._scriptTasks = null;
+        this._runHooks = opts?.runHooks ?? true;
+    }
+    // Methods
+    async _runScript(script, args) {
+        const line = this.workspace.getScript(script);
+        if (!line) {
+            return null;
+        }
+        // Create command task for script
+        const [command, ...commandArgs] = splitCommandLine(line);
+        if (command === "jill") {
+            this._logger.debug(`Interpreting ${line}`);
+            const argv = commandArgs.map((arg)=>arg.replace(/^["'](.+)["']$/, "$1"));
+            const { JillApplication } = await import('./jill.application-NaKSF97o.js').then(function (n) { return n.j; });
+            const app = container.get(JillApplication);
+            const tasks = await app.tasksOf(argv, {
+                project: this.project,
+                workspace: this.workspace
+            });
+            if (tasks.length) {
+                const set = new TaskSet();
+                for (const tsk of tasks){
+                    set.add(tsk);
+                }
+                return set;
+            }
+        }
+        const pm = await this.workspace.project.packageManager();
+        const set = new TaskSet();
+        set.add(new CommandTask(this.workspace, command, [
+            ...commandArgs,
+            ...args
+        ], {
+            logger: this._logger,
+            superCommand: pm === "yarn" ? [
+                "yarn",
+                "exec"
+            ] : undefined
+        }));
+        return set;
+    }
+    async prepare() {
+        // Prepare script run
+        this._scriptTasks = await this._runScript(this.script, this.args);
+        if (!this._scriptTasks) {
+            throw new Error(`No script ${this.script} in ${this.workspace.name}`);
+        }
+        // Prepare hooks run
+        if (this._runHooks) {
+            this._preHookTasks = await this._runScript(`pre${this.script}`, []);
+            this._postHookTasks = await this._runScript(`post${this.script}`, []);
+        }
+        // Add tasks to group
+        if (this._preHookTasks) {
+            this._logger.verbose(`Found pre-hook script "pre${this.script}"`);
+            for (const tsk of this._preHookTasks){
+                this.add(tsk);
+            }
+        }
+        for (const tsk of this._scriptTasks){
+            this.add(tsk);
+        }
+        if (this._postHookTasks) {
+            this._logger.verbose(`Found post-hook script "post${this.script}"`);
+            for (const tsk of this._postHookTasks){
+                this.add(tsk);
+            }
+        }
+    }
+    async *_orchestrate() {
+        if (!this._scriptTasks) {
+            throw new Error("ScriptTask needs to be prepared. Call prepare before starting it");
+        }
+        // Run pre-hook
+        if (this._preHookTasks) {
+            yield* this._preHookTasks;
+            if (await this._hasFailed(this._preHookTasks)) {
+                return this.setStatus("failed");
+            }
+        }
+        // Run script
+        yield* this._scriptTasks;
+        if (await this._hasFailed(this._scriptTasks)) {
+            return this.setStatus("failed");
+        }
+        // Run post-hook
+        if (this._postHookTasks) {
+            yield* this._postHookTasks;
+            if (await this._hasFailed(this._postHookTasks)) {
+                return this.setStatus("failed");
+            }
+        }
+        this.setStatus("done");
+    }
+    async _hasFailed(set) {
+        const results = await waitFor$(set, "finished");
+        return results.failed > 0;
+    }
+    _stop() {
+        if (!this._scriptTasks) return;
+        for (const tsk of this._scriptTasks){
+            tsk.stop();
+        }
+    }
+    complexity(cache = new Map()) {
+        let complexity = super.complexity(cache);
+        if (this._scriptTasks) {
+            complexity += this._scriptTasks.tasks.reduce((cpl, tsk)=>cpl + tsk.complexity(cache), 0);
+        }
+        cache.set(this.id, complexity);
+        return complexity;
+    }
+    // Properties
+    get project() {
+        return this.workspace.project;
+    }
+}
+
+// Symbols
+const TASK_MANAGER = Symbol("jujulego:jill:TaskManager");
+// Service
+container.bind(TASK_MANAGER).toDynamicValue(({ container })=>{
+    const config = container.get(CONFIG);
+    const logger = container.get(Logger);
+    return new TaskManager({
+        jobs: config.jobs,
+        logger
+    });
+}).inSingletonScope();
+
+// Component
+function List({ items, headers }) {
+    if (items.length === 0) {
+        return null;
+    }
+    return /*#__PURE__*/ jsx(Box, {
+        children: Object.keys(items[0]).map((key)=>/*#__PURE__*/ jsxs(Box, {
+                flexDirection: "column",
+                marginRight: 2,
+                children: [
+                    headers && /*#__PURE__*/ jsx(Text, {
+                        bold: true,
+                        children: capitalize(key)
+                    }),
+                    items.map((item, idx)=>/*#__PURE__*/ jsx(Text, {
+                            children: item[key] || " "
+                        }, idx))
+                ]
+            }, key))
+    });
+}
+
+// Components
+function TaskName({ task }) {
+    if (isScriptCtx(task.context)) {
+        return /*#__PURE__*/ jsxs(Text, {
+            children: [
+                "Run ",
+                /*#__PURE__*/ jsx(Text, {
+                    bold: true,
+                    children: task.context.script
+                }),
+                " in ",
+                task.context.workspace.name
+            ]
+        });
+    } else {
+        return /*#__PURE__*/ jsx(Text, {
+            children: task.name
+        });
+    }
+}
+
+// Components
+function TaskSpinner({ task }) {
+    // State
+    const [status, setStatus] = useState(task.status);
+    const [time, setTime] = useState(0);
+    // Effects
+    useLayoutEffect(()=>{
+        return task.on("status", (event)=>{
+            setStatus(event.status);
+        });
+    }, [
+        task
+    ]);
+    useLayoutEffect(()=>{
+        return task.on("completed", ({ duration })=>{
+            setTime(duration);
+        });
+    }, [
+        task
+    ]);
+    // Render
+    const isScriptChild = isCommandCtx(task.context) && task.group && isScriptCtx(task.group.context);
+    switch(status){
+        case "blocked":
+        case "ready":
+        case "starting":
+            return /*#__PURE__*/ jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        color: "grey",
+                        children: "\xb7"
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        children: /*#__PURE__*/ jsx(Text, {
+                            color: "grey",
+                            wrap: "truncate",
+                            children: /*#__PURE__*/ jsx(TaskName, {
+                                task: task
+                            })
+                        })
+                    })
+                ]
+            });
+        case "running":
+            return /*#__PURE__*/ jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        color: isScriptChild ? "dim" : undefined,
+                        children: /*#__PURE__*/ jsx(Spinner, {})
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        children: /*#__PURE__*/ jsx(Text, {
+                            color: isScriptChild ? "dim" : undefined,
+                            wrap: "truncate",
+                            children: /*#__PURE__*/ jsx(TaskName, {
+                                task: task
+                            })
+                        })
+                    })
+                ]
+            });
+        case "done":
+            return /*#__PURE__*/ jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        color: "green",
+                        children: symbols.success
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        children: /*#__PURE__*/ jsx(Text, {
+                            color: isScriptChild ? "dim" : undefined,
+                            wrap: "truncate",
+                            children: /*#__PURE__*/ jsx(TaskName, {
+                                task: task
+                            })
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        flexShrink: 0,
+                        children: /*#__PURE__*/ jsxs(Text, {
+                            color: isScriptChild ? "grey" : "dim",
+                            children: [
+                                "(took ",
+                                ms(time),
+                                ")"
+                            ]
+                        })
+                    })
+                ]
+            });
+        case "failed":
+            return /*#__PURE__*/ jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        color: "red",
+                        children: symbols.error
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        children: /*#__PURE__*/ jsx(Text, {
+                            color: isScriptChild ? "dim" : undefined,
+                            wrap: "truncate",
+                            children: /*#__PURE__*/ jsx(TaskName, {
+                                task: task
+                            })
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        flexShrink: 0,
+                        children: /*#__PURE__*/ jsxs(Text, {
+                            color: isScriptChild ? "grey" : "dim",
+                            children: [
+                                "(took ",
+                                ms(time),
+                                ")"
+                            ]
+                        })
+                    })
+                ]
+            });
+    }
+}
+
+// Components
+function GroupTaskSpinner({ group }) {
+    // State
+    const [verbose, setVerbose] = useState(false);
+    const [status, setStatus] = useState(group.status);
+    const [tasks, setTasks] = useState([
+        ...group.tasks
+    ]);
+    const [canReduce, setCanReduce] = useState(true);
+    // Memo
+    const forceExtended = useMemo(()=>verbose || tasks.some((tsk)=>!isCommandCtx(tsk.context)), [
+        verbose,
+        tasks
+    ]);
+    const isReduced = useMemo(()=>!forceExtended && canReduce, [
+        forceExtended,
+        canReduce
+    ]);
+    // Effects
+    useLayoutEffect(()=>{
+        const config = container.get(CONFIG);
+        if (config.verbose) {
+            setVerbose([
+                "verbose",
+                "debug"
+            ].includes(config.verbose));
+        }
+    }, []);
+    useLayoutEffect(()=>{
+        return group.on("status", (event)=>{
+            setStatus(event.status);
+        });
+    }, [
+        group
+    ]);
+    useLayoutEffect(()=>{
+        let dirty = false;
+        return group.on("task.added", ()=>{
+            if (!dirty) {
+                dirty = true;
+                queueMicrotask(()=>{
+                    setTasks([
+                        ...group.tasks
+                    ]);
+                    dirty = false;
+                });
+            }
+        });
+    }, [
+        group
+    ]);
+    useLayoutEffect(()=>{
+        if (status === "running") {
+            setCanReduce(false);
+        } else if (status === "done") {
+            setCanReduce(true);
+        }
+    }, [
+        status
+    ]);
+    // Render
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(TaskSpinner, {
+                task: group
+            }),
+            isReduced || /*#__PURE__*/ jsx(Box, {
+                flexDirection: "column",
+                marginLeft: 2,
+                children: tasks.map((task)=>/*#__PURE__*/ jsx(Fragment$1, {
+                        children: task instanceof GroupTask ? /*#__PURE__*/ jsx(GroupTaskSpinner, {
+                            group: task
+                        }) : /*#__PURE__*/ jsx(TaskSpinner, {
+                            task: task
+                        })
+                    }, task.id))
+            })
+        ]
+    });
+}
+
+// Utils
+function taskPredicate(task) {
+    if (task.group) {
+        return false;
+    }
+    if ("hidden" in task.context && task.context.hidden) {
+        return false;
+    }
+    return true;
+}
+// Components
+function TaskManagerSpinner({ manager }) {
+    const [tasks, setTasks] = useState(manager.tasks.filter(taskPredicate));
+    useLayoutEffect(()=>{
+        let dirty = false;
+        return manager.on("added", ()=>{
+            if (!dirty) {
+                dirty = true;
+                queueMicrotask(()=>{
+                    setTasks(manager.tasks.filter(taskPredicate));
+                    dirty = false;
+                });
+            }
+        });
+    }, [
+        manager
+    ]);
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: tasks.map((task)=>task instanceof GroupTask ? /*#__PURE__*/ jsx(GroupTaskSpinner, {
+                group: task
+            }, task.id) : /*#__PURE__*/ jsx(TaskSpinner, {
+                task: task
+            }, task.id))
+    });
+}
+
+// Utils
+function printJson(data, stream = process.stdout) {
+    if (stream.isTTY) {
+        stream.write(JSON.stringify(data, null, 2));
+    } else {
+        stream.write(JSON.stringify(data));
+    }
+}
+
+// Component
+function StaticLogs() {
+    // State
+    const { write } = useStderr();
+    // Effect
+    useLayoutEffect(()=>{
+        const gateway = container.get(LogGateway);
+        // Remove Console transport
+        const listeners = gateway.listeners;
+        gateway.clear();
+        // Add custom transport
+        const off = gateway.subscribe((log)=>{
+            write(jillLogFormat(log) + "\n");
+        });
+        return ()=>{
+            off();
+            // Restore previous listeners
+            for (const lst of listeners){
+                gateway.subscribe(lst);
+            }
+        };
+    }, [
+        write
+    ]);
+    return null;
+}
+
+// Component
+function Layout({ children }) {
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(StaticLogs, {}),
+            children
+        ]
+    });
+}
+
+// Constants
+const INK_APP = Symbol.for("jujulego:jill:ink-app");
+// Setup
+container.bind(INK_APP).toDynamicValue(()=>{
+    if (!wt.isMainThread) {
+        throw new Error("Ink should only be used in main thread");
+    }
+    return render(/*#__PURE__*/ jsx(Layout, {}));
+}).inSingletonScope();
+
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+let InkCommand = class InkCommand {
+    builder(parser) {
+        return parser;
+    }
+    async handler(args) {
+        for await (const children of this.render(args)){
+            this.app.rerender(/*#__PURE__*/ jsx(Layout, {
+                children: children
+            }));
+        }
+        await this.app.waitUntilExit();
+    }
+};
+_ts_decorate([
+    lazyInject(INK_APP)
+], InkCommand.prototype, "app", void 0);
+InkCommand = _ts_decorate([
+    injectable()
+], InkCommand);
+
+export { capitalize as A, splitCommandLine as B, CONFIG as C, workerCache as D, ExitException as E, ContextService as F, GroupTaskSpinner as G, applyConfigOptions as H, InkCommand as I, Layout as L, Middleware as M, PluginLoaderService as P, Service as S, TaskManagerSpinner as T, List as a, TaskName as b, TaskSpinner as c, COMMAND as d, COMMAND_MODULE as e, buildCommandModule as f, getCommandOpts as g, Command as h, applyMiddlewares as i, getRegistry as j, getModule as k, setModule as l, CURRENT as m, container as n, lazyInject as o, lazyInjectNamed as p, isCommandCtx as q, CommandTask as r, setRegistry as s, isScriptCtx as t, ScriptTask as u, TASK_MANAGER as v, linesFrom as w, dynamicImport as x, fixDefaultExport as y, printJson as z };
+//# sourceMappingURL=ink-command-SIxVoU_e.js.map