@enspirit/emb 0.0.5 → 0.0.6

package/README.md

@@ -1,7 +1,7 @@
 emb (Enspirit's Monorepo Builder)
 =================
 
-A CLI to help on Enspirit monorepos. This aims at replacing our aging [Makefile for monorepos](https://github.com/enspirit/makefile-for-monorepos/pulls)
+A CLI to help on Enspirit monorepos. This aims at replacing our aging [Makefile for monorepos](https://github.com/enspirit/makefile-for-monorepos)
 
 <!-- toc -->
 * [Usage](#usage)
@@ -14,7 +14,7 @@ $ npm install -g @enspirit/emb
 $ emb COMMAND
 running command...
 $ emb (--version)
-@enspirit/emb/0.0.5 darwin-x64 node-v22.12.0
+@enspirit/emb/0.0.6 darwin-x64 node-v22.12.0
 $ emb --help [COMMAND]
 USAGE
   $ emb COMMAND
@@ -36,7 +36,6 @@ USAGE
 * [`emb images delete`](#emb-images-delete)
 * [`emb images prune`](#emb-images-prune)
 * [`emb ps`](#emb-ps)
-* [`emb run COMPONENT SCRIPT`](#emb-run-component-script)
 * [`emb tasks`](#emb-tasks)
 * [`emb tasks run [TASK]`](#emb-tasks-run-task)
 * [`emb up`](#emb-up)
@@ -323,22 +322,6 @@ EXAMPLES
   $ emb ps
 ```
 
-## `emb run COMPONENT SCRIPT`
-
-Run an npm script from a component's package.json
-
-```
-USAGE
-  $ emb run COMPONENT SCRIPT
-
-ARGUMENTS
-  COMPONENT  Component name
-  SCRIPT     NPM script to run
-
-DESCRIPTION
-  Run an npm script from a component's package.json
-```
-
 ## `emb tasks`
 
 List tasks.

package/dist/src/cli/commands/config/print.js

@@ -9,7 +9,7 @@ export default class ConfigPrint extends FlavoredCommand {
         const context = await getContext();
         const { monorepo } = context;
         if (!flags.json) {
-            console.log(YAML.stringify(monorepo.config));
+            this.log(YAML.stringify(monorepo.config));
         }
         return monorepo.config;
     }

package/dist/src/cli/commands/tasks/run.d.ts

@@ -11,6 +11,4 @@ export default class RunTask extends Command {
     };
     static strict: boolean;
     run(): Promise<void>;
-    private dockerExec;
-    private shellExec;
 }

package/dist/src/cli/commands/tasks/run.js

@@ -1,11 +1,7 @@
 import { getContext } from '../../../index.js';
 import { Args, Command, Flags } from '@oclif/core';
 import { Listr } from 'listr2';
-import { PassThrough } from 'node:stream';
-import { getContainer, ListContainersOperation } from '../../../docker/index.js';
-import { dockerExecutor } from '../../../executors/docker.js';
-import { ExecutorType } from '../../../executors/index.js';
-import { shellExecutor } from '../../../executors/shell.js';
+import { ExecutorType, RunTaskOperation, } from '../../../monorepo/operations/tasks/RunTaskOperation.js';
 export default class RunTask extends Command {
     static args = {
         task: Args.string({
@@ -20,7 +16,7 @@ export default class RunTask extends Command {
         executor: Flags.string({
             char: 'x',
             name: 'executor',
-            options: Object.keys(ExecutorType),
+            options: Object.values(ExecutorType),
         }),
     };
     static strict = false;
@@ -38,30 +34,17 @@ export default class RunTask extends Command {
             }, [])
             : monorepo.tasks;
         const runTasks = toRun.map((task) => {
+            const executor = flags.executor ||
+                (task.component ? ExecutorType.container : ExecutorType.local);
             return {
                 rendererOptions: { persistentOutput: true },
-                task: async (_ctx, listrTask) => {
-                    const type = flags.executor
-                        ? flags.executor
-                        : ExecutorType.container;
-                    const logStream = await monorepo.store.createWriteStream(`logs/tasks/run/${task.id}.log`);
-                    // Gonna log on both the logStream and stdout
-                    const tee = new PassThrough();
-                    tee.pipe(listrTask.stdout());
-                    tee.pipe(logStream);
-                    switch (type) {
-                        case ExecutorType.container: {
-                            return this.dockerExec(task, tee);
-                        }
-                        case ExecutorType.local: {
-                            return this.shellExec(task, tee);
-                        }
-                        default: {
-                            throw new Error(`Unsupported executor: ${type}`);
-                        }
-                    }
+                async task(_ctx, listrTask) {
+                    await monorepo.run(new RunTaskOperation(listrTask.stdout()), {
+                        executor,
+                        task,
+                    });
                 },
-                title: `Running ${task.id}`,
+                title: `Running ${task.id} (${executor})`,
             };
         });
         const runner = new Listr([
@@ -78,36 +61,4 @@ export default class RunTask extends Command {
         ]);
         await runner.run();
     }
-    async dockerExec(task, out) {
-        const { monorepo } = getContext();
-        const matching = await monorepo.run(new ListContainersOperation(), {
-            filters: {
-                label: [
-                    `emb/project=${monorepo.name}`,
-                    `emb/component=${task.component}`,
-                ],
-            },
-        });
-        if (matching.length === 0) {
-            throw new Error(`Could not find a running container for '${task.component}'`);
-        }
-        if (matching.length > 1) {
-            throw new Error(`More than one running container found for '${task.component}'`);
-        }
-        const container = await getContainer(matching[0].Id);
-        return dockerExecutor.run(task.script, {
-            container,
-            out,
-        });
-    }
-    async shellExec(task, out) {
-        const { monorepo } = getContext();
-        const cwd = task.component
-            ? monorepo.component(task.component).rootdir
-            : monorepo.rootDir;
-        return shellExecutor.run(task.script, {
-            cwd,
-            out,
-        });
-    }
 }

package/dist/src/config/convert.d.ts

@@ -1,5 +1,4 @@
-import { Component, Flavor } from './schema.js';
-import { ComponentConfig, FlavorConfig, IMonorepoConfig, UserConfig } from './types.js';
+import { Flavor } from './schema.js';
+import { FlavorConfig, IMonorepoConfig, UserConfig } from './types.js';
 export declare const toFlavor: (flavor: Flavor) => FlavorConfig;
-export declare const toComponent: (cmp: Component) => ComponentConfig;
 export declare const toProjectConfig: (config: UserConfig, rootDir?: string) => IMonorepoConfig;

package/dist/src/config/convert.js

@@ -3,14 +3,9 @@ import { cwd } from 'node:process';
 export const toFlavor = (flavor) => {
     return {
         ...flavor,
-        components: flavor.components?.map(toComponent),
+        components: flavor.components,
     };
 };
-export const toComponent = (cmp) => {
-    return typeof cmp === 'string'
-        ? { context: cmp, name: cmp }
-        : cmp;
-};
 export const toProjectConfig = (config, rootDir) => {
     const project = typeof config.project === 'string'
         ? { name: config.project }
@@ -23,7 +18,7 @@ export const toProjectConfig = (config, rootDir) => {
     else {
         project.rootDir = rootDir || cwd();
     }
-    const components = (config.components || []).map((cmp) => toComponent(cmp));
+    const components = config.components || [];
     const { defaults, env, flavors, plugins, vars } = config;
     return {
         components,

package/dist/src/config/schema.d.ts

@@ -3,33 +3,6 @@
  * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
  * and run json-schema-to-typescript to regenerate this file.
  */
-export type Component = string | {
-    /**
-     * The name of the component.
-     */
-    name: string;
-    /**
-     * The directory of the component.
-     */
-    context?: string;
-    /**
-     * A description of the component.
-     */
-    description?: string;
-    buildArgs?: {
-        [k: string]: unknown;
-    };
-    dependencies?: string[];
-    /**
-     * The stage to target for the build
-     */
-    target?: string;
-    /**
-     * The Dockerfile to use
-     */
-    dockerfile?: string;
-    tasks?: Task[];
-};
 export interface EMBConfigSchema {
     project: string | {
         /**
@@ -72,7 +45,7 @@ export interface Defaults {
         tag?: string;
         target?: string;
         buildArgs?: {
-            [k: string]: unknown;
+            [k: string]: string;
         };
         labels?: {
             [k: string]: string;
@@ -80,6 +53,33 @@ export interface Defaults {
         [k: string]: unknown;
     };
 }
+export interface Component {
+    /**
+     * The name of the component.
+     */
+    name: string;
+    /**
+     * The directory of the component.
+     */
+    context?: string;
+    /**
+     * A description of the component.
+     */
+    description?: string;
+    buildArgs?: {
+        [k: string]: string;
+    };
+    dependencies?: string[];
+    /**
+     * The stage to target for the build
+     */
+    target?: string;
+    /**
+     * The Dockerfile to use
+     */
+    dockerfile?: string;
+    tasks?: Task[];
+}
 export interface Task {
     name: string;
     description?: string;

package/dist/src/config/schema.json

@@ -88,7 +88,9 @@
                         "target": { "type": "string" },
                         "buildArgs": {
                             "type": "object",
-                            "additionalProperties": true
+                            "additionalProperties": {
+                                "type": "string"
+                            }
                         },
                         "labels": {
                             "type": "object",
@@ -124,60 +126,53 @@
             "additionalProperties": false
         },
         "component": {
-            "oneOf": [
-                {
+            "type": "object",
+            "required": ["name"],
+            "properties": {
+                "name": {
                     "type": "string",
                     "minLength": 3,
-                    "description": "Shortcut for specifying the component name."
+                    "description": "The name of the component."
                 },
-                {
+                "context": {
+                    "type": "string",
+                    "minLength": 1,
+                    "description": "The directory of the component."
+                },
+                "description": {
+                    "type": "string",
+                    "minLength": 1,
+                    "description": "A description of the component."
+                },
+                "buildArgs": {
                     "type": "object",
-                    "required": ["name"],
-                    "properties": {
-                        "name": {
-                            "type": "string",
-                            "minLength": 3,
-                            "description": "The name of the component."
-                        },
-                        "context": {
-                            "type": "string",
-                            "minLength": 1,
-                            "description": "The directory of the component."
-                        },
-                        "description": {
-                            "type": "string",
-                            "minLength": 1,
-                            "description": "A description of the component."
-                        },
-                        "buildArgs": {
-                            "type": "object",
-                            "properties": {},
-                            "additionalProperties": true
-                        },
-                        "dependencies": {
-                            "type": "array",
-                            "items": {
-                                "type": "string"
-                            }
-                        },
-                        "target": {
-                            "type": "string",
-                            "description": "The stage to target for the build"
-                        },
-                        "dockerfile": {
-                            "type": "string",
-                            "description": "The Dockerfile to use"
-                        },
-                        "tasks": {
-                            "type": "array",
-                            "items": {
-                                "$ref": "#/$defs/task"
-                            }
-                        }
-                    },
-                    "additionalProperties": false
+                    "properties": {},
+                    "additionalProperties": {
+                        "type": "string"
+                    }
+                },
+                "dependencies": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "target": {
+                    "type": "string",
+                    "description": "The stage to target for the build"
+                },
+                "dockerfile": {
+                    "type": "string",
+                    "description": "The Dockerfile to use"
+                },
+                "tasks": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/task"
+                    }
                 }
-            ]
+            },
+            "additionalProperties": false
         },
         "flavor": {
             "type": "object",

package/dist/src/config/types.d.ts

@@ -5,7 +5,7 @@ export type IProjectConfig = {
     rootDir: string;
 };
 export type ComponentConfig = {
-    buildArgs?: Record<PropertyKey, string>;
+    buildArgs?: Record<string, string>;
     context?: string;
     dependencies?: Array<string>;
     dockerfile?: string;
@@ -16,7 +16,7 @@ export type ComponentConfig = {
 };
 export type DefaultSettings = {
     docker?: {
-        buildArgs?: Record<string, unknown>;
+        buildArgs?: Record<string, string>;
         labels?: Record<string, string>;
         tag?: string;
         target?: string;

package/dist/src/config/validation.d.ts

@@ -1 +1,3 @@
+import { Component } from './schema.js';
 export declare const validateUserConfig: (pathOrObject: string | unknown) => Promise<import("./types.js").IMonorepoConfig>;
+export declare const validateEmbfile: (pathOrObject: string | unknown) => Promise<Component>;

package/dist/src/config/validation.js

@@ -3,8 +3,9 @@ import { readFile, stat } from 'node:fs/promises';
 import yaml from 'yaml';
 import { toProjectConfig } from './convert.js';
 import configSchema from './schema.json' with { type: 'json' };
+const ajv = new Ajv();
+ajv.addSchema(configSchema);
 export const validateUserConfig = async (pathOrObject) => {
-    const ajv = new Ajv();
     let userConfig;
     if (typeof pathOrObject === 'string') {
         if (await stat(pathOrObject)) {
@@ -24,3 +25,27 @@ export const validateUserConfig = async (pathOrObject) => {
     }
     return toProjectConfig(userConfig);
 };
+export const validateEmbfile = async (pathOrObject) => {
+    let component;
+    if (typeof pathOrObject === 'string') {
+        if (await stat(pathOrObject)) {
+            const cfgYaml = (await readFile(pathOrObject)).toString();
+            component = yaml.parse(cfgYaml.toString());
+        }
+        else {
+            throw new Error(`Could not find file: ${pathOrObject}`);
+        }
+    }
+    else {
+        component = pathOrObject;
+    }
+    const validate = ajv.getSchema('/schemas/config#/$defs/component');
+    if (!validate) {
+        throw new Error('Could not find the JSON schema validator for Embfile');
+    }
+    if (!validate(component)) {
+        ajv.errors.forEach((err) => console.error(err));
+        throw new Error(`Your .emb.yml is incorrect`);
+    }
+    return component;
+};

package/dist/src/docker/operations/containers/ExecContainerOperation.d.ts

@@ -0,0 +1,22 @@
+import { Writable } from 'node:stream';
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Exec/operation/ContainerExec
+ */
+declare const schema: z.ZodObject<{
+    attachStderr: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    attachStdin: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    attachStdout: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    container: z.ZodString;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    script: z.ZodString;
+    tty: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    workingDir: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare class ContainerExecOperation extends AbstractOperation<typeof schema, void> {
+    protected out?: Writable | undefined;
+    constructor(out?: Writable | undefined);
+    protected _run(input: z.input<typeof schema>): Promise<void>;
+}
+export {};

package/dist/src/docker/operations/containers/ExecContainerOperation.js

@@ -0,0 +1,78 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Exec/operation/ContainerExec
+ */
+const schema = z.object({
+    attachStderr: z
+        .boolean()
+        .default(false)
+        .optional()
+        .describe('Attach to `stderr` of the exec command.'),
+    attachStdin: z
+        .boolean()
+        .default(false)
+        .optional()
+        .describe('Attach to `stdin` of the exec command.'),
+    attachStdout: z
+        .boolean()
+        .default(false)
+        .optional()
+        .describe('Attach to `stdout` of the exec command.'),
+    container: z.string().describe('ID or name of the container'),
+    env: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('A list of environment variables in the form'),
+    script: z.string().describe('Command to run, as a string'),
+    tty: z.boolean().default(false).optional().describe('Allocate a pseudo-TTY'),
+    workingDir: z
+        .string()
+        .optional()
+        .describe('The working directory for the exec process inside the container'),
+});
+export class ContainerExecOperation extends AbstractOperation {
+    out;
+    constructor(out) {
+        super(schema);
+        this.out = out;
+    }
+    async _run(input) {
+        const container = await this.context.docker.getContainer(input.container);
+        const envVars = Object.entries(input.env || {}).reduce((arr, [key, value]) => {
+            return [...arr, `${key}=${value}`];
+        }, []);
+        const options = {
+            AttachStderr: input.attachStderr,
+            AttachStdin: input.attachStdin,
+            AttachStdout: input.attachStdout,
+            Cmd: ['bash', '-eu', '-o', 'pipefail', '-c', input.script],
+            Env: envVars,
+            Tty: input.tty,
+            WorkingDir: input.workingDir,
+        };
+        const exec = await container.exec(options);
+        const stream = await exec.start({});
+        container.modem.demuxStream(stream, this.out || process.stdout, this.out || process.stderr);
+        await new Promise((resolve, reject) => {
+            const onError = (err) => reject(err);
+            const onEnd = async () => {
+                exec.inspect((error, res) => {
+                    if (error)
+                        return reject(error);
+                    const code = res?.ExitCode ?? 0;
+                    if (code !== 0) {
+                        const msg = res?.ProcessConfig?.entrypoint
+                            ? `container exec failed (exit ${code})`
+                            : `command failed (exit ${code})`;
+                        return reject(new Error(msg));
+                    }
+                    resolve();
+                });
+            };
+            stream.on('error', onError);
+            stream.on('end', onEnd);
+            stream.on('close', onEnd); // some engines emit 'close' not 'end'
+        });
+    }
+}

package/dist/src/docker/operations/containers/index.d.ts

@@ -1,2 +1,3 @@
+export * from './ExecContainerOperation.js';
 export * from './ListContainersOperation.js';
 export * from './PruneContainersOperation.js';

package/dist/src/docker/operations/containers/index.js

@@ -1,2 +1,3 @@
+export * from './ExecContainerOperation.js';
 export * from './ListContainersOperation.js';
 export * from './PruneContainersOperation.js';

package/dist/src/monorepo/config.d.ts

@@ -1,13 +1,14 @@
 import { ComponentConfig, DefaultSettings, FlavorConfig, IMonorepoConfig, IProjectConfig, PluginConfig } from '../config/index.js';
 export declare class MonorepoConfig implements IMonorepoConfig {
-    components: ComponentConfig[];
     defaults: DefaultSettings;
     env: Record<string, string>;
     flavors: Array<FlavorConfig>;
     plugins: Array<PluginConfig>;
     project: IProjectConfig;
     vars: Record<string, unknown>;
+    private _components;
     constructor(config: IMonorepoConfig);
+    get components(): ComponentConfig[];
     component(name: string): ComponentConfig;
     flavor(name: string): FlavorConfig;
     toJSON(): Required<IMonorepoConfig>;

package/dist/src/monorepo/config.js

@@ -1,15 +1,18 @@
 import deepMerge from '@fastify/deepmerge';
 import { deepMergeArray } from '../utils/index.js';
 export class MonorepoConfig {
-    components;
     defaults;
     env;
     flavors;
     plugins;
     project;
     vars;
+    _components;
     constructor(config) {
-        this.components = config.components;
+        this._components = config.components.reduce((map, cmp) => {
+            map.set(cmp.name, cmp);
+            return map;
+        }, new Map());
         this.defaults = config.defaults || {};
         this.project = config.project;
         this.vars = config.vars || {};
@@ -17,6 +20,9 @@ export class MonorepoConfig {
         this.env = config.env || {};
         this.plugins = config.plugins || [];
     }
+    get components() {
+        return [...this._components.values()];
+    }
     component(name) {
         const config = this.components.find((c) => c.name === name);
         if (!config) {

package/dist/src/monorepo/operations/components/GetComponentContainerOperation.d.ts

@@ -0,0 +1,6 @@
+import { ContainerInfo } from 'dockerode';
+import { Component } from '../../component.js';
+import { IOperation } from '../../../operations/index.js';
+export declare class GetComponentContainerOperation implements IOperation<Component, ContainerInfo> {
+    run(component: Component | string): Promise<ContainerInfo>;
+}

package/dist/src/monorepo/operations/components/GetComponentContainerOperation.js

@@ -0,0 +1,21 @@
+import { getContext } from '../../../index.js';
+import { ListContainersOperation } from '../../../docker/index.js';
+import { Component } from '../../component.js';
+export class GetComponentContainerOperation {
+    async run(component) {
+        const { monorepo } = getContext();
+        const cmpName = component instanceof Component ? component.name : component;
+        const matching = await monorepo.run(new ListContainersOperation(), {
+            filters: {
+                label: [`emb/project=${monorepo.name}`, `emb/component=${cmpName}`],
+            },
+        });
+        if (matching.length === 0) {
+            throw new Error(`Could not find a running container for '${cmpName}'`);
+        }
+        if (matching.length > 1) {
+            throw new Error(`More than one running container found for '${cmpName}'`);
+        }
+        return matching[0];
+    }
+}

package/dist/src/monorepo/operations/components/index.d.ts

@@ -1 +1,2 @@
 export * from './BuildComponentsOperation.js';
+export * from './GetComponentContainerOperation.js';

package/dist/src/monorepo/operations/components/index.js

@@ -1 +1,2 @@
 export * from './BuildComponentsOperation.js';
+export * from './GetComponentContainerOperation.js';

package/dist/src/monorepo/operations/index.d.ts

@@ -1 +1,3 @@
 export * from './components/index.js';
+export * from './shell/index.js';
+export * from './tasks/index.js';

package/dist/src/monorepo/operations/index.js

@@ -1 +1,3 @@
 export * from './components/index.js';
+export * from './shell/index.js';
+export * from './tasks/index.js';

package/dist/src/monorepo/operations/shell/ExecuteLocalCommandOperation.d.ts

@@ -0,0 +1,18 @@
+import { ResultPromise } from 'execa';
+import { Writable } from 'node:stream';
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Exec/operation/ContainerExec
+ */
+declare const schema: z.ZodObject<{
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    script: z.ZodString;
+    workingDir: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare class ExecuteLocalCommandOperation extends AbstractOperation<typeof schema, ResultPromise> {
+    protected out?: Writable | undefined;
+    constructor(out?: Writable | undefined);
+    protected _run(input: z.input<typeof schema>): Promise<ResultPromise>;
+}
+export {};

package/dist/src/monorepo/operations/shell/ExecuteLocalCommandOperation.js

@@ -0,0 +1,35 @@
+import { execa } from 'execa';
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Exec/operation/ContainerExec
+ */
+const schema = z.object({
+    env: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('A list of environment variables in the form'),
+    script: z.string().describe('Command to run, as a string'),
+    workingDir: z
+        .string()
+        .optional()
+        .describe('The working directory for the exec process inside the container'),
+});
+export class ExecuteLocalCommandOperation extends AbstractOperation {
+    out;
+    constructor(out) {
+        super(schema);
+        this.out = out;
+    }
+    async _run(input) {
+        const process = execa(input.script, {
+            all: true,
+            cwd: input.workingDir,
+            shell: true,
+        });
+        if (this.out) {
+            process.all?.pipe(this.out);
+        }
+        return process;
+    }
+}

package/dist/src/monorepo/operations/shell/index.d.ts

@@ -0,0 +1 @@
+export * from './ExecuteLocalCommandOperation.js';

package/dist/src/monorepo/operations/shell/index.js

@@ -0,0 +1 @@
+export * from './ExecuteLocalCommandOperation.js';

package/dist/src/monorepo/operations/tasks/RunTaskOperation.d.ts

@@ -0,0 +1,18 @@
+import { Writable } from 'node:stream';
+import { TaskInfo } from '../../types.js';
+import { IOperation } from '../../../operations/types.js';
+export declare enum ExecutorType {
+    container = "container",
+    local = "local"
+}
+export type RunTaskOperationParams = {
+    executor: ExecutorType;
+    task: TaskInfo;
+};
+export declare class RunTaskOperation implements IOperation<RunTaskOperationParams, void> {
+    protected out?: Writable | undefined;
+    constructor(out?: Writable | undefined);
+    run(params: RunTaskOperationParams): Promise<void>;
+    private runDocker;
+    private runLocal;
+}

package/dist/src/monorepo/operations/tasks/RunTaskOperation.js

@@ -0,0 +1,50 @@
+import { getContext } from '../../../index.js';
+import { ContainerExecOperation } from '../../../docker/index.js';
+import { ExecuteLocalCommandOperation, GetComponentContainerOperation, } from '../index.js';
+export var ExecutorType;
+(function (ExecutorType) {
+    ExecutorType["container"] = "container";
+    ExecutorType["local"] = "local";
+})(ExecutorType || (ExecutorType = {}));
+export class RunTaskOperation {
+    out;
+    constructor(out) {
+        this.out = out;
+    }
+    async run(params) {
+        switch (params.executor) {
+            case ExecutorType.container: {
+                return this.runDocker(params);
+            }
+            case ExecutorType.local: {
+                return this.runLocal(params);
+            }
+            default: {
+                throw new Error(`Unsupported executor type: ${params.executor}`);
+            }
+        }
+    }
+    async runDocker(params) {
+        const { monorepo } = getContext();
+        if (!params.task.component) {
+            throw new Error(`Support for non-component tasks not implemented`);
+        }
+        const containerInfo = await monorepo.run(new GetComponentContainerOperation(), params.task.component);
+        await monorepo.run(new ContainerExecOperation(this.out), {
+            attachStderr: true,
+            attachStdout: true,
+            container: containerInfo.Id,
+            script: params.task.script,
+        });
+    }
+    async runLocal(params) {
+        const { monorepo } = getContext();
+        const cwd = params.task.component
+            ? monorepo.component(params.task.component).rootdir
+            : monorepo.rootDir;
+        await monorepo.run(new ExecuteLocalCommandOperation(this.out), {
+            script: params.task.script,
+            workingDir: cwd,
+        });
+    }
+}

package/dist/src/monorepo/operations/tasks/index.d.ts

@@ -0,0 +1 @@
+export * from './RunTaskOperation.js';

package/dist/src/monorepo/operations/tasks/index.js

@@ -0,0 +1 @@
+export * from './RunTaskOperation.js';

package/dist/src/monorepo/plugins/ComponentDiscoverPlugin.d.ts

@@ -0,0 +1,15 @@
+import { Monorepo, MonorepoConfig } from '../index.js';
+import { AbstractPlugin } from './plugin.js';
+export type ComponentDiscoverPluginOptions = {
+    glob?: string;
+    ignore?: string | string[];
+};
+export declare const ComponentDiscoverPluginDefaultOptions: {
+    glob: string;
+};
+export declare class ComponentDiscoverPlugin extends AbstractPlugin<ComponentDiscoverPluginOptions> {
+    protected monorepo: Monorepo;
+    static name: string;
+    constructor(config: Partial<ComponentDiscoverPluginOptions>, monorepo: Monorepo);
+    extendConfig(config: MonorepoConfig): Promise<MonorepoConfig>;
+}

package/dist/src/monorepo/plugins/{ComponentsDiscover.js → ComponentDiscoverPlugin.js}

@@ -3,10 +3,22 @@ import { glob } from 'glob';
 import { dirname } from 'node:path';
 import { MonorepoConfig } from '../index.js';
 import { AbstractPlugin } from './plugin.js';
+export const ComponentDiscoverPluginDefaultOptions = {
+    glob: '*/Dockerfile',
+};
 export class ComponentDiscoverPlugin extends AbstractPlugin {
+    monorepo;
     static name = 'autodiscover';
+    constructor(config, monorepo) {
+        super({
+            ...ComponentDiscoverPluginDefaultOptions,
+            ...config,
+        }, monorepo);
+        this.monorepo = monorepo;
+    }
     async extendConfig(config) {
-        const files = await glob('*/Dockerfile', {
+        const files = await glob(this.config.glob || ComponentDiscoverPluginDefaultOptions.glob, {
+            ...this.config,
             cwd: config.project.rootDir,
         });
         const overrides = files.map((path) => {

package/dist/src/monorepo/plugins/EmbfileLoaderPlugin.d.ts

@@ -0,0 +1,14 @@
+import { Monorepo, MonorepoConfig } from '../index.js';
+import { AbstractPlugin } from './plugin.js';
+export type EmbfileLoaderPluginOptions = {
+    glob?: string;
+};
+export declare const EmbfileLoaderPluginDefaultOptions: {
+    glob: string;
+};
+export declare class EmbfileLoaderPlugin extends AbstractPlugin<EmbfileLoaderPluginOptions> {
+    protected monorepo: Monorepo;
+    static name: string;
+    constructor(config: Partial<EmbfileLoaderPluginOptions>, monorepo: Monorepo);
+    extendConfig(config: MonorepoConfig): Promise<MonorepoConfig>;
+}

package/dist/src/monorepo/plugins/EmbfileLoaderPlugin.js

@@ -0,0 +1,33 @@
+import { glob } from 'glob';
+import { join } from 'node:path';
+import { validateEmbfile } from '../../config/index.js';
+import { AbstractPlugin } from './plugin.js';
+export const EmbfileLoaderPluginDefaultOptions = {
+    glob: '*/Embfile.{yaml,yml}',
+};
+export class EmbfileLoaderPlugin extends AbstractPlugin {
+    monorepo;
+    static name = 'embfiles';
+    constructor(config, monorepo) {
+        super({
+            ...EmbfileLoaderPluginDefaultOptions,
+            ...config,
+        }, monorepo);
+        this.monorepo = monorepo;
+    }
+    async extendConfig(config) {
+        const files = await glob(this.config.glob || EmbfileLoaderPluginDefaultOptions.glob, {
+            ...this.config,
+            cwd: config.project.rootDir,
+        });
+        const newConfig = await files.reduce(async (pConfig, path) => {
+            const config = await pConfig;
+            const embfile = await join(config.project.rootDir, path);
+            const component = await validateEmbfile(embfile);
+            return config.with({
+                components: [component],
+            });
+        }, Promise.resolve(config));
+        return newConfig;
+    }
+}

package/dist/src/monorepo/plugins/index.d.ts

@@ -1,7 +1,8 @@
 import { AbstractPlugin } from './plugin.js';
-export * from './ComponentsDiscover.js';
+export * from './ComponentDiscoverPlugin.js';
 export * from './DotEnvPlugin.js';
-import { Monorepo } from '../monorepo.js';
+export * from './EmbfileLoaderPlugin.js';
+import { Monorepo } from '../index.js';
 export type AbstractPluginConstructor = new <C, P extends AbstractPlugin<C>>(config: C, monorepo: Monorepo) => P;
 export declare const registerPlugin: (plugin: AbstractPluginConstructor) => void;
 export declare const getPlugin: (name: string) => AbstractPluginConstructor;

package/dist/src/monorepo/plugins/index.js

@@ -1,7 +1,9 @@
-export * from './ComponentsDiscover.js';
+export * from './ComponentDiscoverPlugin.js';
 export * from './DotEnvPlugin.js';
-import { ComponentDiscoverPlugin } from './ComponentsDiscover.js';
+export * from './EmbfileLoaderPlugin.js';
+import { ComponentDiscoverPlugin } from './ComponentDiscoverPlugin.js';
 import { DotEnvPlugin } from './DotEnvPlugin.js';
+import { EmbfileLoaderPlugin } from './EmbfileLoaderPlugin.js';
 const PluginRegistry = new Map();
 export const registerPlugin = (plugin) => {
     if (PluginRegistry.has(plugin.name)) {
@@ -18,3 +20,4 @@ export const getPlugin = (name) => {
 /** Not sure why we need casting */
 registerPlugin(ComponentDiscoverPlugin);
 registerPlugin(DotEnvPlugin);
+registerPlugin(EmbfileLoaderPlugin);

package/dist/src/operations/abstract/AbstractOperation.d.ts

@@ -1,6 +1,6 @@
 import { EmbContext } from '../../index.js';
 import * as z from 'zod';
-import { IOperation } from '../types.js';
+import { IOperation } from '../index.js';
 export declare abstract class AbstractOperation<S extends z.Schema, O = unknown> implements IOperation<z.infer<S>, O> {
     protected inputSchema: S;
     protected context: EmbContext;

package/dist/src/utils/deepMergeArray.d.ts

@@ -1 +1,4 @@
+export declare const byName: <T extends {
+    name: string;
+}>(item: T) => string;
 export declare const deepMergeArray: <T>(target: Array<T>, source: Array<T>, identifierFn?: (item: T) => unknown) => Array<T>;

package/dist/src/utils/deepMergeArray.js

@@ -1,4 +1,5 @@
 import deepmerge from '@fastify/deepmerge';
+export const byName = (item) => item.name;
 export const deepMergeArray = (target, source, identifierFn) => {
     if (!identifierFn) {
         return deepmerge()(target, source);

package/oclif.manifest.json

@@ -450,40 +450,6 @@
         "prune.js"
       ]
     },
-    "run": {
-      "aliases": [],
-      "args": {
-        "component": {
-          "description": "Component name",
-          "name": "component",
-          "required": true
-        },
-        "script": {
-          "description": "NPM script to run",
-          "name": "script",
-          "required": true
-        }
-      },
-      "description": "Run an npm script from a component's package.json",
-      "flags": {},
-      "hasDynamicHelp": false,
-      "hiddenAliases": [],
-      "id": "run",
-      "pluginAlias": "@enspirit/emb",
-      "pluginName": "@enspirit/emb",
-      "pluginType": "core",
-      "strict": true,
-      "enableJsonFlag": false,
-      "isESM": true,
-      "relativePath": [
-        "dist",
-        "src",
-        "cli",
-        "commands",
-        "run",
-        "index.js"
-      ]
-    },
     "tasks": {
       "aliases": [],
       "args": {},
@@ -570,5 +536,5 @@
       ]
     }
   },
-  "version": "0.0.5"
+  "version": "0.0.6"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@enspirit/emb",
   "type": "module",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "keywords": ["monorepo", "docker", "taskrunner", "ci", "docker compose", "sentinel", "makefile"],
   "author": "Louis Lambeau <louis.lambeau@enspirit.be>",
   "license": "ISC",

package/dist/src/cli/commands/run/index.d.ts

@@ -1,10 +0,0 @@
-import { Command } from '@oclif/core';
-export default class RunComponentScript extends Command {
-    static args: {
-        component: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-        script: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
-    static description: string;
-    static strict: boolean;
-    run(): Promise<void>;
-}

package/dist/src/cli/commands/run/index.js

@@ -1,49 +0,0 @@
-import { getContext } from '../../../index.js';
-import { Args, Command } from '@oclif/core';
-import { Listr } from 'listr2';
-import { spawn } from 'node:child_process';
-import fs from 'node:fs/promises';
-export default class RunComponentScript extends Command {
-    static args = {
-        component: Args.string({
-            description: 'Component name',
-            required: true,
-        }),
-        script: Args.string({ description: 'NPM script to run', required: true }),
-    };
-    static description = "Run an npm script from a component's package.json";
-    static strict = true;
-    async run() {
-        const { args } = await this.parse(RunComponentScript);
-        const { monorepo } = getContext();
-        const component = monorepo.component(args.component);
-        const pkgPath = component.join('package.json');
-        const tasks = new Listr([
-            {
-                rendererOptions: {
-                    persistentOutput: true,
-                },
-                async task(_ctx, _task) {
-                    try {
-                        const pkgRaw = await fs.readFile(pkgPath, 'utf8');
-                        const pkg = JSON.parse(pkgRaw);
-                        if (!pkg.scripts?.[args.script]) {
-                            throw new Error(`Script "${args.script}" not found in ${component.name}/package.json`);
-                        }
-                        return spawn('npm', ['run', args.script], {
-                            cwd: component.rootdir,
-                        }).stdout;
-                    }
-                    catch (error) {
-                        const error_ = error instanceof Error
-                            ? new TypeError(`Failed to run ${component.name}:${args.script}\n${error.message}`)
-                            : new Error(`Failed to run ${component.name}:${args.script}\n${error}`);
-                        throw error_;
-                    }
-                },
-                title: `Running npm script '${args.script}' on ${args.component}`,
-            },
-        ], { concurrent: false });
-        await tasks.run();
-    }
-}

package/dist/src/executors/docker.d.ts

@@ -1,6 +0,0 @@
-import { Container } from 'dockerode';
-import { Executor, ExecutorRunOptions } from './types.js';
-export type DockerExecutorRunOptions = ExecutorRunOptions & {
-    container: Container;
-};
-export declare const dockerExecutor: Executor<DockerExecutorRunOptions>;

package/dist/src/executors/docker.js

@@ -1,14 +0,0 @@
-export const dockerExecutor = {
-    async run(script, options) {
-        const exec = await options.container.exec({
-            AttachStderr: true,
-            AttachStdout: true,
-            Cmd: ['bash', '-c', script],
-        });
-        const stream = await exec.start({});
-        if (options.out) {
-            options.container.modem.demuxStream(stream, options.out, options.out);
-        }
-        return stream;
-    },
-};

package/dist/src/executors/index.d.ts

@@ -1,6 +0,0 @@
-export * from './docker.js';
-export * from './shell.js';
-export declare enum ExecutorType {
-    container = "container",
-    local = "local"
-}

package/dist/src/executors/index.js

@@ -1,7 +0,0 @@
-export * from './docker.js';
-export * from './shell.js';
-export var ExecutorType;
-(function (ExecutorType) {
-    ExecutorType["container"] = "container";
-    ExecutorType["local"] = "local";
-})(ExecutorType || (ExecutorType = {}));

package/dist/src/executors/shell.d.ts

@@ -1,2 +0,0 @@
-import { Executor } from './types.js';
-export declare const shellExecutor: Executor;

package/dist/src/executors/shell.js

@@ -1,14 +0,0 @@
-import { execa } from 'execa';
-export const shellExecutor = {
-    async run(script, options) {
-        const process = execa(script, {
-            all: true,
-            cwd: options.cwd,
-            shell: true,
-        });
-        if (options.out) {
-            process.all?.pipe(options.out);
-        }
-        return process;
-    },
-};

package/dist/src/executors/types.d.ts

@@ -1,8 +0,0 @@
-import { Writable } from 'node:stream';
-export type ExecutorRunOptions = {
-    cwd?: string;
-    out?: Writable;
-};
-export type Executor<RO extends ExecutorRunOptions = ExecutorRunOptions, T = unknown> = {
-    run(script: string, options?: RO): Promise<T>;
-};

package/dist/src/executors/types.js

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

package/dist/src/monorepo/plugins/ComponentsDiscover.d.ts

@@ -1,6 +0,0 @@
-import { MonorepoConfig } from '../index.js';
-import { AbstractPlugin } from './plugin.js';
-export declare class ComponentDiscoverPlugin extends AbstractPlugin {
-    static name: string;
-    extendConfig(config: MonorepoConfig): Promise<MonorepoConfig>;
-}