@jujulego/jill 1.1.17 → 1.1.18

package/dist/main.js

@@ -4,149 +4,35 @@ var _helpers = require("yargs/helpers");
 
 var _yargs = _interopRequireDefault(require("yargs"));
 
-var _each = require("./commands/each");
+var _each = require("./commands/each.command");
 
-var _info = require("./commands/info");
+var _info = require("./commands/info.command");
 
-var _list = require("./commands/list");
+var _list = require("./commands/list.command");
 
-var _run = require("./commands/run");
+var _run = require("./commands/run.command");
 
-var _command = require("./myr/command");
+var _myr = require("./myr/myr.command");
 
-var _watch = require("./myr/watch");
+var _watch = require("./myr/watch.command");
 
-var _wrapper = require("./wrapper");
+var _plugin = require("./plugin");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // Bootstrap
 (async () => {
   // Options
-  await (0, _yargs.default)((0, _helpers.hideBin)(process.argv)).scriptName('jill').option('project', {
-    alias: 'p',
-    type: 'string',
-    description: 'Project root directory'
-  }).option('package-manager', {
-    choices: ['yarn', 'npm'],
-    type: 'string',
-    description: 'Force package manager'
-  }).option('verbose', {
-    alias: 'v',
-    type: 'count',
-    description: 'Set verbosity level (1 for verbose, 2 for debug)'
-  }).parserConfiguration({
+  const parser = await (0, _yargs.default)((0, _helpers.hideBin)(process.argv)).scriptName('jill').parserConfiguration({
     'populate--': true
-  }).command(['list', 'ls'], 'List workspaces', {
-    private: {
-      type: 'boolean',
-      group: 'Filters:',
-      desc: 'Print only private workspaces'
-    },
-    'with-script': {
-      type: 'array',
-      group: 'Filters:',
-      desc: 'Print only workspaces having the given script'
-    },
-    affected: {
-      alias: 'a',
-      type: 'string',
-      coerce: rev => rev === '' ? 'master' : rev,
-      group: 'Affected:',
-      desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master.\n' + 'Replaces %name by workspace name.'
-    },
-    'affected-rev-sort': {
-      type: 'string',
-      group: 'Affected:',
-      desc: 'Sort applied to git tag / git branch command'
-    },
-    'affected-rev-fallback': {
-      type: 'string',
-      default: 'master',
-      group: 'Affected:',
-      desc: 'Fallback revision, used if no revision matching the given format is found'
-    },
-    attrs: {
-      type: 'array',
-      choices: ['name', 'version', 'root', 'slug'],
-      group: 'Format:',
-      desc: 'Select printed attributes'
-    },
-    headers: {
-      type: 'boolean',
-      group: 'Format:',
-      desc: 'Prints columns headers'
-    },
-    long: {
-      alias: 'l',
-      type: 'boolean',
-      conflicts: 'attrs',
-      group: 'Format:',
-      desc: 'Prints name, version and root of all workspaces'
-    },
-    json: {
-      type: 'boolean',
-      group: 'Format:',
-      desc: 'Prints data as a JSON array'
-    }
-  }, (0, _wrapper.commandHandler)(_list.listCommand)).command('info', 'Print workspace data', {
-    workspace: {
-      alias: 'w',
-      type: 'string',
-      desc: 'Workspace to use'
-    }
-  }, (0, _wrapper.commandHandler)(_info.infoCommand)).command('run <script>', 'Run script inside workspace', {
-    workspace: {
-      alias: 'w',
-      type: 'string',
-      desc: 'Workspace to use'
-    },
-    'deps-mode': {
-      choice: ['all', 'prod', 'none'],
-      default: 'all',
-      desc: 'Dependency selection mode:\n' + ' - all = dependencies AND devDependencies\n' + ' - prod = dependencies\n' + ' - none = nothing'
-    }
-  }, (0, _wrapper.commandHandler)(_run.runCommand)).command('each <script>', 'Run script on selected workspaces', {
-    'deps-mode': {
-      choice: ['all', 'prod', 'none'],
-      default: 'all',
-      desc: 'Dependency selection mode:\n' + ' - all = dependencies AND devDependencies\n' + ' - prod = dependencies\n' + ' - none = nothing'
-    },
-    private: {
-      type: 'boolean',
-      group: 'Filters:',
-      desc: 'Print only private workspaces'
-    },
-    affected: {
-      alias: 'a',
-      type: 'string',
-      coerce: rev => rev === '' ? 'master' : rev,
-      group: 'Affected:',
-      desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master.\n' + 'Replaces %name by workspace name.'
-    },
-    'affected-rev-sort': {
-      type: 'string',
-      group: 'Affected:',
-      desc: 'Sort applied to git tag / git branch command'
-    },
-    'affected-rev-fallback': {
-      type: 'string',
-      default: 'master',
-      group: 'Affected:',
-      desc: 'Fallback revision, used if no revision matching the given format is found'
-    }
-  }, (0, _wrapper.commandHandler)(_each.eachCommand)).command('myr', 'Interact with myr server', _command.myrCommand).command('watch <script>', 'Run script inside workspace and watch over deps', {
-    daemon: {
-      alias: 'd',
-      boolean: true,
-      default: false,
-      desc: 'Run watch script also in background'
-    },
-    workspace: {
-      alias: 'w',
-      type: 'string',
-      desc: 'Workspace to use'
-    }
-  }, (0, _wrapper.commandHandler)(_watch.watchCommand)).demandCommand(1).help().example('$0 list -a', 'List all affected workspaces towards master branch').example('$0 list --no-private', 'List all public workspaces').parse();
+  }).strictCommands().help();
+
+  const core = _plugin.Plugin.createPlugin('core', [_info.InfoCommand, _list.ListCommand, _run.RunCommand, _each.EachCommand]);
+
+  const myr = _plugin.Plugin.createPlugin('myr', [_myr.MyrCommand, _watch.WatchCommand]);
+
+  core.setup(parser);
+  myr.setup(parser);
+  await parser.parse();
 })();
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["main.ts"],"names":["process","argv","scriptName","option","alias","type","description","choices","parserConfiguration","command","private","group","desc","affected","coerce","rev","default","attrs","headers","long","conflicts","json","listCommand","workspace","infoCommand","choice","runCommand","eachCommand","myrCommand","daemon","boolean","watchCommand","demandCommand","help","example","parse"],"mappings":"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","sourcesContent":["import { hideBin } from 'yargs/helpers';\nimport yargs from 'yargs';\n\nimport { eachCommand } from './commands/each';\nimport { infoCommand } from './commands/info';\nimport { listCommand } from './commands/list';\nimport { runCommand } from './commands/run';\nimport { myrCommand } from './myr/command';\nimport { watchCommand } from './myr/watch';\nimport { commandHandler } from './wrapper';\n\n// Bootstrap\n(async () => {\n  // Options\n  await yargs(hideBin(process.argv))\n    .scriptName('jill')\n    .option('project', {\n      alias: 'p',\n      type: 'string',\n      description: 'Project root directory'\n    })\n    .option('package-manager', {\n      choices: ['yarn', 'npm'],\n      type: 'string',\n      description: 'Force package manager'\n    })\n    .option('verbose', {\n      alias: 'v',\n      type: 'count',\n      description: 'Set verbosity level (1 for verbose, 2 for debug)',\n    })\n    .parserConfiguration({\n      'populate--': true,\n    })\n    .command(['list', 'ls'], 'List workspaces', {\n      private: {\n        type: 'boolean',\n        group: 'Filters:',\n        desc: 'Print only private workspaces',\n      },\n      'with-script': {\n        type: 'array',\n        group: 'Filters:',\n        desc: 'Print only workspaces having the given script',\n      },\n      affected: {\n        alias: 'a',\n        type: 'string',\n        coerce: (rev: string) => rev === '' ? 'master' : rev,\n        group: 'Affected:',\n        desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master.\\n' +\n          'Replaces %name by workspace name.',\n      },\n      'affected-rev-sort': {\n        type: 'string',\n        group: 'Affected:',\n        desc: 'Sort applied to git tag / git branch command',\n      },\n      'affected-rev-fallback': {\n        type: 'string',\n        default: 'master',\n        group: 'Affected:',\n        desc: 'Fallback revision, used if no revision matching the given format is found',\n      },\n      attrs: {\n        type: 'array',\n        choices: ['name', 'version', 'root', 'slug'],\n        group: 'Format:',\n        desc: 'Select printed attributes'\n      },\n      headers: {\n        type: 'boolean',\n        group: 'Format:',\n        desc: 'Prints columns headers'\n      },\n      long: {\n        alias: 'l',\n        type: 'boolean',\n        conflicts: 'attrs',\n        group: 'Format:',\n        desc: 'Prints name, version and root of all workspaces',\n      },\n      json: {\n        type: 'boolean',\n        group: 'Format:',\n        desc: 'Prints data as a JSON array',\n      }\n    }, commandHandler(listCommand))\n    .command('info', 'Print workspace data', {\n      workspace: {\n        alias: 'w',\n        type: 'string',\n        desc: 'Workspace to use'\n      }\n    }, commandHandler(infoCommand))\n    .command('run <script>', 'Run script inside workspace', {\n      workspace: {\n        alias: 'w',\n        type: 'string',\n        desc: 'Workspace to use'\n      },\n      'deps-mode': {\n        choice: ['all', 'prod', 'none'],\n        default: 'all',\n        desc: 'Dependency selection mode:\\n' +\n          ' - all = dependencies AND devDependencies\\n' +\n          ' - prod = dependencies\\n' +\n          ' - none = nothing'\n      },\n    }, commandHandler(runCommand))\n    .command('each <script>', 'Run script on selected workspaces', {\n      'deps-mode': {\n        choice: ['all', 'prod', 'none'],\n        default: 'all',\n        desc: 'Dependency selection mode:\\n' +\n          ' - all = dependencies AND devDependencies\\n' +\n          ' - prod = dependencies\\n' +\n          ' - none = nothing'\n      },\n      private: {\n        type: 'boolean',\n        group: 'Filters:',\n        desc: 'Print only private workspaces',\n      },\n      affected: {\n        alias: 'a',\n        type: 'string',\n        coerce: (rev: string) => rev === '' ? 'master' : rev,\n        group: 'Affected:',\n        desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master.\\n' +\n          'Replaces %name by workspace name.',\n      },\n      'affected-rev-sort': {\n        type: 'string',\n        group: 'Affected:',\n        desc: 'Sort applied to git tag / git branch command',\n      },\n      'affected-rev-fallback': {\n        type: 'string',\n        default: 'master',\n        group: 'Affected:',\n        desc: 'Fallback revision, used if no revision matching the given format is found',\n      },\n    }, commandHandler(eachCommand))\n    .command('myr', 'Interact with myr server', myrCommand)\n    .command('watch <script>', 'Run script inside workspace and watch over deps', {\n      daemon: {\n        alias: 'd',\n        boolean: true,\n        default: false,\n        desc: 'Run watch script also in background'\n      },\n      workspace: {\n        alias: 'w',\n        type: 'string',\n        desc: 'Workspace to use'\n      }\n    }, commandHandler(watchCommand))\n    .demandCommand(1)\n    .help()\n    .example('$0 list -a', 'List all affected workspaces towards master branch')\n    .example('$0 list --no-private', 'List all public workspaces')\n    .parse();\n})();\n"],"file":"main.js"}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/dist/myr/commands/kill.command.d.ts

@@ -0,0 +1,11 @@
+import { ProjectArgs, ProjectCommand } from '../../project.command';
+import { Arguments, Builder } from '../../command';
+export interface KillArgs extends ProjectArgs {
+    id: string;
+}
+export declare class KillCommand extends ProjectCommand<KillArgs> {
+    readonly name = "kill <id>";
+    readonly description = "Kill task";
+    protected define<T, U>(builder: Builder<T, U>): Builder<T, U & KillArgs>;
+    protected run(args: Arguments<KillArgs>): Promise<number>;
+}

package/dist/myr/commands/kill.command.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KillCommand = void 0;
+
+var _project = require("../../project.command");
+
+var _myrClient = require("../myr-client");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// Command
+class KillCommand extends _project.ProjectCommand {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "name", 'kill <id>');
+
+    _defineProperty(this, "description", 'Kill task');
+  }
+
+  // Methods
+  define(builder) {
+    return super.define(y => builder(y).positional('id', {
+      type: 'string',
+      demandOption: true
+    }));
+  }
+
+  async run(args) {
+    await super.run(args); // Spawn task
+
+    this.spinner.start('Connecting to myr');
+    const client = new _myrClient.MyrClient(this.project);
+    this.spinner.start('Killing task');
+    const task = await client.kill(args.id);
+
+    if (task) {
+      this.spinner.succeed(`Task ${task.id} killed`);
+      return 0;
+    } else {
+      this.spinner.fail(`Task ${args.id} not found`);
+      return 1;
+    }
+  }
+
+}
+
+exports.KillCommand = KillCommand;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/dist/myr/commands/list.command.d.ts

@@ -0,0 +1,18 @@
+import { ProjectArgs, ProjectCommand } from '../../project.command';
+import { Arguments, Builder } from '../../command';
+export declare type Attribute = 'identifier' | 'status' | 'cwd' | 'command' | 'cmd' | 'args';
+export declare type Data = Partial<Record<Attribute, string>>;
+export interface ListArgs extends ProjectArgs {
+    all: boolean | undefined;
+    attrs: Attribute[] | undefined;
+    headers: boolean | undefined;
+    long: boolean | undefined;
+    json: boolean | undefined;
+}
+export declare class ListCommand extends ProjectCommand<ListArgs> {
+    readonly name: string[];
+    readonly description = "List myr tasks";
+    private buildExtractor;
+    protected define<T, U>(builder: Builder<T, U>): Builder<T, U & ListArgs>;
+    protected run(args: Arguments<ListArgs>): Promise<void>;
+}

package/dist/myr/commands/list.command.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListCommand = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _project = require("../../project.command");
+
+var _myrClient = require("../myr-client");
+
+var _cliList = require("../../utils/cli-list");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// Constants
+const COLORED_STATUS = {
+  blocked: _chalk.default.yellow('blocked'),
+  ready: _chalk.default.blue('ready'),
+  running: 'running',
+  failed: _chalk.default.red('failed'),
+  done: _chalk.default.green('done')
+};
+const LONG_ATTRIBUTES = ['identifier', 'status', 'cwd', 'command'];
+const DEFAULT_ATTRIBUTES = ['identifier', 'command'];
+const EXTRACTORS = {
+  identifier: tsk => _chalk.default.grey(tsk.id),
+  status: tsk => COLORED_STATUS[tsk.status],
+  cwd: tsk => _path.default.relative(process.cwd(), tsk.cwd) || '.',
+  command: tsk => `${tsk.cmd} ${tsk.args.join(' ')}`,
+  cmd: tsk => tsk.cmd,
+  args: tsk => tsk.args.join(' ')
+}; // Command
+
+class ListCommand extends _project.ProjectCommand {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "name", ['list', 'ls']);
+
+    _defineProperty(this, "description", 'List myr tasks');
+  }
+
+  // Methods
+  buildExtractor(attrs) {
+    return tsk => {
+      const data = {};
+
+      for (const attr of attrs) {
+        data[attr] = EXTRACTORS[attr](tsk);
+      }
+
+      return data;
+    };
+  }
+
+  define(builder) {
+    return super.define(y => builder(y).option('all', {
+      alias: 'a',
+      type: 'boolean',
+      group: 'Filters:',
+      desc: 'Show all tasks (by default list shows only running tasks)'
+    }).option('attrs', {
+      type: 'array',
+      choices: ['identifier', 'status', 'cwd', 'command', 'cmd', 'args'],
+      default: undefined,
+      group: 'Format:',
+      desc: 'Select printed attributes'
+    }).option('headers', {
+      type: 'boolean',
+      group: 'Format:',
+      desc: 'Prints columns headers'
+    }).option('long', {
+      alias: 'l',
+      type: 'boolean',
+      conflicts: 'attrs',
+      group: 'Format:',
+      desc: 'Prints name, version and root of all workspaces'
+    }).option('json', {
+      type: 'boolean',
+      group: 'Format:',
+      desc: 'Prints data as a JSON array'
+    }));
+  }
+
+  async run(args) {
+    await super.run(args); // Spawn task
+
+    this.spinner.start('Connecting to myr');
+    const client = new _myrClient.MyrClient(this.project);
+    this.spinner.start('Requesting tasks');
+    const tasks = await client.tasks();
+    this.spinner.stop(); // Build data
+
+    let attrs = args.attrs || DEFAULT_ATTRIBUTES;
+
+    if (!args.attrs && args.long) {
+      attrs = LONG_ATTRIBUTES;
+    }
+
+    const data = tasks.filter(tsk => args.all || tsk.status === 'running').map(tsk => this.buildExtractor(attrs)(tsk)); // Print data
+
+    const list = new _cliList.CliList();
+
+    if (args.headers ?? attrs.length > 1) {
+      list.setHeaders(attrs);
+    }
+
+    for (const d of data) {
+      list.add(attrs.map(attr => d[attr] || ''));
+    }
+
+    for (const d of list.lines()) {
+      this.log(d);
+    }
+  }
+
+}
+
+exports.ListCommand = ListCommand;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["myr/commands/list.command.ts"],"names":["COLORED_STATUS","blocked","chalk","yellow","ready","blue","running","failed","red","done","green","LONG_ATTRIBUTES","DEFAULT_ATTRIBUTES","EXTRACTORS","identifier","tsk","grey","id","status","cwd","path","relative","process","command","cmd","args","join","ListCommand","ProjectCommand","buildExtractor","attrs","data","attr","define","builder","y","option","alias","type","group","desc","choices","default","undefined","conflicts","run","spinner","start","client","MyrClient","project","tasks","stop","long","filter","all","map","list","CliList","headers","length","setHeaders","d","add","lines","log"],"mappings":"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","sourcesContent":["import { TaskStatus } from '@jujulego/jill-core';\nimport { Task } from '@jujulego/jill-myr';\nimport chalk from 'chalk';\nimport path from 'path';\n\nimport { ProjectArgs, ProjectCommand } from '../../project.command';\nimport { MyrClient } from '../myr-client';\nimport { CliList } from '../../utils/cli-list';\nimport { Arguments, Builder } from '../../command';\n\n// Types\nexport type Attribute = 'identifier' | 'status' | 'cwd' | 'command' | 'cmd' | 'args';\nexport type Data = Partial<Record<Attribute, string>>;\n\ntype Extractor<T> = (tsk: Task) => T;\n\nexport interface ListArgs extends ProjectArgs {\n  all: boolean | undefined;\n\n  attrs: Attribute[] | undefined;\n  headers: boolean | undefined;\n  long: boolean | undefined;\n  json: boolean | undefined;\n}\n\n// Constants\nconst COLORED_STATUS: Record<TaskStatus, string> = {\n  blocked: chalk.yellow('blocked'),\n  ready: chalk.blue('ready'),\n  running: 'running',\n  failed: chalk.red('failed'),\n  done: chalk.green('done')\n};\n\nconst LONG_ATTRIBUTES: Attribute[] = ['identifier', 'status', 'cwd', 'command'];\nconst DEFAULT_ATTRIBUTES: Attribute[] = ['identifier', 'command'];\n\nconst EXTRACTORS: Record<Attribute, Extractor<string | undefined>> = {\n  identifier: tsk => chalk.grey(tsk.id),\n  status: tsk => COLORED_STATUS[tsk.status],\n  cwd: tsk => path.relative(process.cwd(), tsk.cwd) || '.',\n  command: tsk => `${tsk.cmd} ${tsk.args.join(' ')}`,\n  cmd: tsk => tsk.cmd,\n  args: tsk => tsk.args.join(' ')\n};\n\n// Command\nexport class ListCommand extends ProjectCommand<ListArgs> {\n  // Attributes\n  readonly name = ['list', 'ls'];\n  readonly description = 'List myr tasks';\n\n  // Methods\n  private buildExtractor(attrs: Attribute[]): Extractor<Data> {\n    return (tsk) => {\n      const data: Data = {};\n\n      for (const attr of attrs) {\n        data[attr] = EXTRACTORS[attr](tsk);\n      }\n\n      return data;\n    };\n  }\n\n  protected define<T, U>(builder: Builder<T, U>): Builder<T, U & ListArgs> {\n    return super.define(y => builder(y)\n      .option('all', {\n        alias: 'a',\n        type: 'boolean',\n        group: 'Filters:',\n        desc: 'Show all tasks (by default list shows only running tasks)',\n      })\n      .option('attrs', {\n        type: 'array',\n        choices: ['identifier', 'status', 'cwd' ,'command', 'cmd', 'args'],\n        default: undefined as Attribute[] | undefined,\n        group: 'Format:',\n        desc: 'Select printed attributes'\n      })\n      .option('headers', {\n        type: 'boolean',\n        group: 'Format:',\n        desc: 'Prints columns headers'\n      })\n      .option('long', {\n        alias: 'l',\n        type: 'boolean',\n        conflicts: 'attrs',\n        group: 'Format:',\n        desc: 'Prints name, version and root of all workspaces',\n      })\n      .option('json', {\n        type: 'boolean',\n        group: 'Format:',\n        desc: 'Prints data as a JSON array',\n      })\n    );\n  }\n\n  protected async run(args: Arguments<ListArgs>): Promise<void> {\n    await super.run(args);\n\n    // Spawn task\n    this.spinner.start('Connecting to myr');\n    const client = new MyrClient(this.project);\n\n    this.spinner.start('Requesting tasks');\n    const tasks = await client.tasks();\n\n    this.spinner.stop();\n\n    // Build data\n    let attrs = args.attrs as Attribute[] || DEFAULT_ATTRIBUTES;\n\n    if (!args.attrs && args.long) {\n      attrs = LONG_ATTRIBUTES;\n    }\n\n    const data = tasks\n      .filter(tsk => args.all || tsk.status === 'running')\n      .map(tsk => this.buildExtractor(attrs)(tsk));\n\n    // Print data\n    const list = new CliList();\n\n    if (args.headers ?? (attrs.length > 1)) {\n      list.setHeaders(attrs);\n    }\n\n    for (const d of data) {\n      list.add(attrs.map(attr => d[attr] || ''));\n    }\n\n    for (const d of list.lines()) {\n      this.log(d);\n    }\n  }\n}"],"file":"myr/commands/list.command.js"}

package/dist/myr/commands/logs.command.d.ts

@@ -0,0 +1,11 @@
+import { ProjectArgs, ProjectCommand } from '../../project.command';
+import { Arguments, Builder } from '../../command';
+export interface LogsArgs extends ProjectArgs {
+    follow: boolean;
+}
+export declare class LogsCommand extends ProjectCommand<LogsArgs> {
+    readonly name = "logs";
+    readonly description = "Request myr logs";
+    protected define<T, U>(builder: Builder<T, U>): Builder<T, U & LogsArgs>;
+    protected run(args: Arguments<LogsArgs>): Promise<void>;
+}

package/dist/myr/commands/logs.command.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LogsCommand = void 0;
+
+var _winston = require("winston");
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _project = require("../../project.command");
+
+var _myrClient = require("../myr-client");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// Utils
+const printLog = _winston.format.combine({
+  transform: info => Object.assign(info, {
+    [Symbol.for('level')]: info.level
+  })
+}, {
+  transform: info => Object.assign(info, {
+    context: info.task?.substr(0, 8) || info.context
+  })
+}, _winston.format.printf(({
+  context,
+  message,
+  timestamp
+}) => context ? (0, _chalk.default)`[jill-myr] {white ${new Date(timestamp).toLocaleString()}} {grey [${context}]} ${message}` : (0, _chalk.default)`[jill-myr] {white ${new Date(timestamp).toLocaleString()}} ${message}`), _winston.format.colorize({
+  all: true
+})); // Command
+
+
+class LogsCommand extends _project.ProjectCommand {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "name", 'logs');
+
+    _defineProperty(this, "description", 'Request myr logs');
+  }
+
+  // Methods
+  define(builder) {
+    return super.define(y => builder(y).option('follow', {
+      alias: 'f',
+      type: 'boolean',
+      default: false,
+      description: 'Subscribe to logs stream'
+    }));
+  }
+
+  async run(args) {
+    await super.run(args); // Spawn task
+
+    this.spinner.start('Connecting to myr');
+    const client = new _myrClient.MyrClient(this.project);
+    this.spinner.start('Requesting logs');
+    const logs = await client.logs();
+    this.spinner.stop();
+
+    for (const log of logs) {
+      printLog.transform(log);
+      this.log(log[Symbol.for('message')]);
+    } // Follow
+
+
+    if (args.follow) {
+      for await (const log of client.logs$()) {
+        printLog.transform(log);
+        this.log(log[Symbol.for('message')]);
+      }
+    }
+  }
+
+}
+
+exports.LogsCommand = LogsCommand;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/dist/myr/commands/spawn.command.d.ts

@@ -0,0 +1,11 @@
+import { Arguments, Builder } from '../../command';
+import { WorkspaceArgs, WorkspaceCommand } from '../../workspace.command';
+export interface SpawnArgs extends WorkspaceArgs {
+    command: string;
+}
+export declare class SpawnCommand extends WorkspaceCommand<SpawnArgs> {
+    readonly name = "spawn <command>";
+    readonly description = "Spawn new task";
+    protected define<T, U>(builder: Builder<T, U>): Builder<T, U & SpawnArgs>;
+    protected run(args: Arguments<SpawnArgs>): Promise<number | void>;
+}

package/dist/myr/commands/spawn.command.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SpawnCommand = void 0;
+
+var _workspace = require("../../workspace.command");
+
+var _myrClient = require("../myr-client");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// Command
+class SpawnCommand extends _workspace.WorkspaceCommand {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "name", 'spawn <command>');
+
+    _defineProperty(this, "description", 'Spawn new task');
+  }
+
+  // Methods
+  define(builder) {
+    return super.define(y => builder(y).positional('command', {
+      type: 'string',
+      demandOption: true
+    }));
+  }
+
+  async run(args) {
+    await super.run(args); // Spawn task
+
+    this.spinner.start('Connecting to myr');
+    const client = new _myrClient.MyrClient(this.project);
+    this.spinner.start('Spawning task');
+    const task = await client.spawn(this.workspace.cwd, args.command, args['--']?.map(arg => arg.toString()));
+    this.spinner.succeed(`Task ${task.id} spawned`);
+  }
+
+}
+
+exports.SpawnCommand = SpawnCommand;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/dist/myr/commands/stop.command.d.ts

@@ -0,0 +1,7 @@
+import { Arguments } from '../../command';
+import { ProjectArgs, ProjectCommand } from '../../project.command';
+export declare class StopCommand extends ProjectCommand {
+    readonly name = "stop";
+    readonly description = "Stop myr server. This will kill all running tasks";
+    protected run(argv: Arguments<ProjectArgs>): Promise<void>;
+}