@enspirit/emb 0.1.3 → 0.3.0

package/README.md

@@ -14,7 +14,7 @@ $ npm install -g @enspirit/emb
 $ emb COMMAND
 running command...
 $ emb (--version)
-@enspirit/emb/0.1.3 darwin-x64 node-v22.12.0
+@enspirit/emb/0.3.0 darwin-x64 node-v22.12.0
 $ emb --help [COMMAND]
 USAGE
   $ emb COMMAND
@@ -27,6 +27,7 @@ USAGE
 * [`emb clean`](#emb-clean)
 * [`emb components`](#emb-components)
 * [`emb components logs COMPONENT`](#emb-components-logs-component)
+* [`emb components shell COMPONENT`](#emb-components-shell-component)
 * [`emb config print`](#emb-config-print)
 * [`emb containers`](#emb-containers)
 * [`emb containers prune`](#emb-containers-prune)
@@ -39,6 +40,7 @@ USAGE
 * [`emb ps`](#emb-ps)
 * [`emb resources`](#emb-resources)
 * [`emb resources build [COMPONENT]`](#emb-resources-build-component)
+* [`emb shell COMPONENT`](#emb-shell-component)
 * [`emb tasks`](#emb-tasks)
 * [`emb tasks run TASK`](#emb-tasks-run-task)
 * [`emb up`](#emb-up)
@@ -142,6 +144,31 @@ EXAMPLES
   $ emb components logs
 ```
 
+## `emb components shell COMPONENT`
+
+Get a shell on a running component.
+
+```
+USAGE
+  $ emb components shell COMPONENT [--flavor <value>] [-s <value>]
+
+ARGUMENTS
+  COMPONENT  The component you want to get a shell on
+
+FLAGS
+  -s, --shell=<value>   [default: bash] The shell to run
+      --flavor=<value>  Specify the flavor to use.
+
+DESCRIPTION
+  Get a shell on a running component.
+
+ALIASES
+  $ emb shell
+
+EXAMPLES
+  $ emb components shell
+```
+
 ## `emb config print`
 
 Print the current config.
@@ -406,6 +433,31 @@ EXAMPLES
   $ emb resources build build --flavor development
 ```
 
+## `emb shell COMPONENT`
+
+Get a shell on a running component.
+
+```
+USAGE
+  $ emb shell COMPONENT [--flavor <value>] [-s <value>]
+
+ARGUMENTS
+  COMPONENT  The component you want to get a shell on
+
+FLAGS
+  -s, --shell=<value>   [default: bash] The shell to run
+      --flavor=<value>  Specify the flavor to use.
+
+DESCRIPTION
+  Get a shell on a running component.
+
+ALIASES
+  $ emb shell
+
+EXAMPLES
+  $ emb shell
+```
+
 ## `emb tasks`
 
 List tasks.

package/dist/src/cli/commands/components/shell.d.ts

@@ -0,0 +1,14 @@
+import { FlavoredCommand } from '../../index.js';
+export default class ComponentsLogs extends FlavoredCommand<typeof ComponentsLogs> {
+    static aliases: string[];
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        shell: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        component: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/src/cli/commands/components/shell.js

@@ -0,0 +1,41 @@
+import { Args, Flags } from '@oclif/core';
+import { FlavoredCommand, getContext } from '../../index.js';
+import { ComposeExecShellOperation } from '../../../docker/index.js';
+import { ShellExitError } from '../../../errors.js';
+export default class ComponentsLogs extends FlavoredCommand {
+    static aliases = ['shell'];
+    static description = 'Get a shell on a running component.';
+    static enableJsonFlag = false;
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        shell: Flags.string({
+            name: 'shell',
+            char: 's',
+            description: 'The shell to run',
+            default: 'bash',
+        }),
+    };
+    static args = {
+        component: Args.string({
+            name: 'component',
+            description: 'The component you want to get a shell on',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(ComponentsLogs);
+        const { monorepo } = await getContext();
+        try {
+            await monorepo.run(new ComposeExecShellOperation(), {
+                service: args.component,
+                shell: flags.shell,
+            });
+        }
+        catch (error) {
+            if (error instanceof ShellExitError) {
+                this.error(error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/src/docker/compose/operations/ComposeExecOperation.d.ts

@@ -0,0 +1,13 @@
+import { Writable } from 'node:stream';
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+declare const schema: z.ZodObject<{
+    command: z.ZodString;
+    service: z.ZodString;
+}, z.core.$strip>;
+export declare class ComposeExecOperation 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/compose/operations/ComposeExecOperation.js

@@ -0,0 +1,59 @@
+import { spawn } from 'node:child_process';
+import * as z from 'zod';
+import { ComposeExecError } from '../../../errors.js';
+import { AbstractOperation } from '../../../operations/index.js';
+const schema = z.object({
+    command: z.string().describe('The command to execute on the service'),
+    service: z
+        .string()
+        .describe('The name of the compose service to exec a shell'),
+});
+export class ComposeExecOperation extends AbstractOperation {
+    out;
+    constructor(out) {
+        super(schema);
+        this.out = out;
+    }
+    async _run(input) {
+        const { monorepo } = this.context;
+        const cmd = 'docker';
+        const args = ['compose', 'exec', input.service, input.command];
+        const child = spawn(cmd, args, {
+            stdio: 'pipe',
+            shell: true,
+            cwd: monorepo.rootDir,
+        });
+        if (this.out) {
+            child.stderr.pipe(this.out);
+            child.stdout.pipe(this.out);
+        }
+        const forward = (sig) => {
+            try {
+                child.kill(sig);
+            }
+            catch { }
+        };
+        const signals = [
+            'SIGINT',
+            'SIGTERM',
+            'SIGHUP',
+            'SIGQUIT',
+        ];
+        signals.forEach((sig) => {
+            process.on(sig, () => forward(sig));
+        });
+        return new Promise((resolve, reject) => {
+            child.on('error', (err) => {
+                reject(new Error(`Failed to execute docker compose: ${err.message}`));
+            });
+            child.on('exit', (code, signal) => {
+                if (code !== null && code !== 0) {
+                    reject(new ComposeExecError(`The shell exited unexpectedly. ${code}`, code, signal));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+}

package/dist/src/docker/compose/operations/ComposeExecShellOperation.d.ts

@@ -0,0 +1,11 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+declare const schema: z.ZodObject<{
+    shell: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    service: z.ZodString;
+}, z.core.$strip>;
+export declare class ComposeExecShellOperation extends AbstractOperation<typeof schema, void> {
+    constructor();
+    protected _run(input: z.input<typeof schema>): Promise<void>;
+}
+export {};

package/dist/src/docker/compose/operations/ComposeExecShellOperation.js

@@ -0,0 +1,56 @@
+import { spawn } from 'node:child_process';
+import * as z from 'zod';
+import { ShellExitError } from '../../../errors.js';
+import { AbstractOperation } from '../../../operations/index.js';
+const schema = z.object({
+    shell: z.string().default('bash').optional(),
+    service: z
+        .string()
+        .describe('The name of the compose service to exec a shell'),
+});
+export class ComposeExecShellOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(input) {
+        const { monorepo } = this.context;
+        const cmd = 'docker';
+        const args = ['compose', 'exec', input.service, input.shell || 'bash'];
+        const child = spawn(cmd, args, {
+            stdio: 'inherit',
+            cwd: monorepo.rootDir,
+            env: {
+                ...process.env,
+                DOCKER_CLI_HINTS: 'false',
+            },
+        });
+        const forward = (sig) => {
+            try {
+                child.kill(sig);
+            }
+            catch { }
+        };
+        const signals = [
+            'SIGINT',
+            'SIGTERM',
+            'SIGHUP',
+            'SIGQUIT',
+        ];
+        signals.forEach((sig) => {
+            process.on(sig, () => forward(sig));
+        });
+        return new Promise((resolve, reject) => {
+            child.on('error', (err) => {
+                reject(new Error(`Failed to execute docker: ${err.message}`));
+            });
+            child.on('exit', (code, signal) => {
+                if (code !== null && code !== 0) {
+                    reject(new ShellExitError(`The shell exited unexpectedly. ${code}`, input.service, code, signal));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+}

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

@@ -1,2 +1,4 @@
 export * from './ComposeDownOperation.js';
+export * from './ComposeExecOperation.js';
+export * from './ComposeExecShellOperation.js';
 export * from './ComposeUpOperation.js';

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

@@ -1,2 +1,4 @@
 export * from './ComposeDownOperation.js';
+export * from './ComposeExecOperation.js';
+export * from './ComposeExecShellOperation.js';
 export * from './ComposeUpOperation.js';

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

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

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

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

package/dist/src/docker/resources/DockerImageResource.js

@@ -1,42 +1,74 @@
-import { stat, statfs } from 'node:fs/promises';
+import { readdir, stat, statfs } from 'node:fs/promises';
 import { join } from 'node:path';
 import pMap from 'p-map';
 import { GitPrerequisitePlugin } from '../../prerequisites/index.js';
 import { ResourceFactory, } from '../../monorepo/resources/ResourceFactory.js';
 import { BuildImageOperation } from '../operations/index.js';
-const DockerImageOpFactory = async ({ config, component, monorepo }) => {
-    const fromConfig = (config.params || {});
-    const context = fromConfig.context
-        ? fromConfig.context[0] === '/'
-            ? monorepo.join(fromConfig.context)
-            : component.join(fromConfig.context)
-        : monorepo.join(component.rootDir);
-    // Ensure the folder exists
-    await statfs(context);
-    const plugin = new GitPrerequisitePlugin();
-    const sources = await plugin.collect(context);
-    const imageName = [monorepo.name, fromConfig.tag || component.name].join('/');
-    const tagName = fromConfig.tag || monorepo.defaults.docker?.tag || 'latest';
-    const buildParams = {
-        context,
-        dockerfile: fromConfig.dockerfile || 'Dockerfile',
-        src: sources.map((s) => s.path),
-        buildArgs: await monorepo.expand({
-            ...monorepo.defaults.docker?.buildArgs,
-            ...fromConfig.buildArgs,
-        }),
-        tag: await monorepo.expand(`${imageName}:${tagName}`),
-        labels: await monorepo.expand({
-            ...fromConfig.labels,
-            'emb/project': monorepo.name,
-            'emb/component': component.name,
-            'emb/flavor': monorepo.currentFlavor,
-        }),
-        target: fromConfig.target,
-    };
-    const lastUpdatedInfo = async (sources) => {
+class DockerImageResourceBuilder {
+    buildContext;
+    context;
+    constructor(buildContext) {
+        this.buildContext = buildContext;
+        this.context = this.config.context
+            ? this.config.context[0] === '/'
+                ? buildContext.monorepo.join(this.config.context)
+                : buildContext.component.join(this.config.context)
+            : buildContext.monorepo.join(buildContext.component.rootDir);
+    }
+    get monorepo() {
+        return this.buildContext.monorepo;
+    }
+    get config() {
+        return (this.buildContext.config.params || {});
+    }
+    get component() {
+        return this.buildContext.component;
+    }
+    async build() {
+        // Ensure the folder exists
+        await statfs(this.context);
+        const imageName = [
+            this.monorepo.name,
+            this.config.tag || this.component.name,
+        ].join('/');
+        const tagName = this.config.tag || this.monorepo.defaults.docker?.tag || 'latest';
+        const sources = await readdir(this.context, { recursive: true });
+        const buildParams = {
+            context: this.context,
+            dockerfile: this.config.dockerfile || 'Dockerfile',
+            src: sources,
+            buildArgs: await this.monorepo.expand({
+                ...this.monorepo.defaults.docker?.buildArgs,
+                ...this.config.buildArgs,
+            }),
+            tag: await this.monorepo.expand(`${imageName}:${tagName}`),
+            labels: await this.monorepo.expand({
+                ...this.config.labels,
+                'emb/project': this.monorepo.name,
+                'emb/component': this.component.name,
+                'emb/flavor': this.monorepo.currentFlavor,
+            }),
+            target: this.config.target,
+        };
+        return {
+            input: buildParams,
+            operation: new BuildImageOperation(),
+        };
+    }
+    async mustBuild(sentinel) {
+        const plugin = new GitPrerequisitePlugin();
+        const sources = await plugin.collect(this.context);
+        const lastUpdated = await this.lastUpdatedInfo(sources);
+        if (!sentinel) {
+            return lastUpdated;
+        }
+        return lastUpdated && lastUpdated.time.getTime() > sentinel.mtime
+            ? lastUpdated
+            : undefined;
+    }
+    async lastUpdatedInfo(sources) {
         const stats = await pMap(sources, async (s) => {
-            const stats = await stat(join(context, s.path));
+            const stats = await stat(join(this.context, s.path));
             return {
                 time: stats.mtime,
                 path: s.path,
@@ -48,20 +80,7 @@ const DockerImageOpFactory = async ({ config, component, monorepo }) => {
         return stats.reduce((last, entry) => {
             return last.time > entry.time ? last : entry;
         }, stats[0]);
-    };
-    return {
-        async mustBuild(sentinel) {
-            const lastUpdated = await lastUpdatedInfo(sources);
-            if (!sentinel) {
-                return lastUpdated;
-            }
-            return lastUpdated && lastUpdated.time.getTime() > sentinel.mtime
-                ? lastUpdated
-                : undefined;
-        },
-        input: buildParams,
-        operation: new BuildImageOperation(),
-    };
-};
+    }
+}
 // Bring better abstraction and register as part of the plugin initialization
-ResourceFactory.register('docker/image', DockerImageOpFactory);
+ResourceFactory.register('docker/image', async (context) => new DockerImageResourceBuilder(context));

package/dist/src/errors.d.ts

@@ -58,3 +58,22 @@ export declare class CircularDependencyError extends EMBError {
     readonly deps: Array<Array<string>>;
     constructor(msg: string, deps: Array<Array<string>>);
 }
+export declare class ShellExitError extends EMBError {
+    service: string;
+    exitCode: number;
+    signal?: (NodeJS.Signals | null) | undefined;
+    constructor(msg: string, service: string, exitCode: number, signal?: (NodeJS.Signals | null) | undefined);
+}
+export declare class NoContainerFoundError extends EMBError {
+    component: string;
+    constructor(msg: string, component: string);
+}
+export declare class MultipleContainersFoundError extends EMBError {
+    component: string;
+    constructor(msg: string, component: string);
+}
+export declare class ComposeExecError extends EMBError {
+    exitCode: number;
+    signal?: (NodeJS.Signals | null) | undefined;
+    constructor(msg: string, exitCode: number, signal?: (NodeJS.Signals | null) | undefined);
+}

package/dist/src/errors.js

@@ -44,7 +44,7 @@ export class AmbiguousReferenceError extends EMBError {
     ref;
     matches;
     constructor(msg, ref, matches) {
-        super('AMBIGUOUS_TASK', msg);
+        super('AMBIGUOUS_REF', msg);
         this.ref = ref;
         this.matches = matches;
     }
@@ -70,3 +70,37 @@ export class CircularDependencyError extends EMBError {
         this.deps = deps;
     }
 }
+export class ShellExitError extends EMBError {
+    service;
+    exitCode;
+    signal;
+    constructor(msg, service, exitCode, signal) {
+        super('SHELL_EXIT_ERR', msg);
+        this.service = service;
+        this.exitCode = exitCode;
+        this.signal = signal;
+    }
+}
+export class NoContainerFoundError extends EMBError {
+    component;
+    constructor(msg, component) {
+        super('CMP_NO_CONTAINER', msg);
+        this.component = component;
+    }
+}
+export class MultipleContainersFoundError extends EMBError {
+    component;
+    constructor(msg, component) {
+        super('CMP_NO_CONTAINER', msg);
+        this.component = component;
+    }
+}
+export class ComposeExecError extends EMBError {
+    exitCode;
+    signal;
+    constructor(msg, exitCode, signal) {
+        super('COMPOSE_EXEC_ERR', msg);
+        this.exitCode = exitCode;
+        this.signal = signal;
+    }
+}

package/dist/src/monorepo/operations/resources/BuildResourcesOperation.d.ts

@@ -7,6 +7,7 @@ export type BuildResourceMeta = {
     force?: boolean;
     resource?: ResourceInfo;
     builder?: ResourceBuilderInfo<unknown, unknown>;
+    builderInput?: unknown;
     sentinelData?: unknown;
     cacheHit?: boolean;
 };

package/dist/src/monorepo/operations/resources/BuildResourcesOperation.js

@@ -84,35 +84,42 @@ export class BuildResourcesOperation extends AbstractOperation {
             },
             // Actual build
             {
-                title: `Build ${resource.id}`,
+                title: `Checking cache for ${resource.id}`,
                 /** Skip the build if the builder knows it can be skipped */
-                task: async (ctx, task) => {
+                task: async (ctx) => {
                     if (ctx.builder?.mustBuild) {
                         const previousSentinelData = await this.readSentinelFile(resource);
                         ctx.sentinelData =
                             await ctx.builder.mustBuild(previousSentinelData);
                         ctx.cacheHit = !ctx.sentinelData;
                     }
-                    if (!ctx.force && (ctx.dryRun || ctx.cacheHit)) {
-                        const prefix = ctx.dryRun ? '[dry run]' : '[cache hit]';
+                },
+            },
+            {
+                title: `Build image for ${resource.id}`,
+                async task(ctx, task) {
+                    const skip = (prefix) => {
                         parentTask.title = `${prefix} ${resource.id}`;
                         task.skip();
                         return parentTask.skip();
+                    };
+                    if (ctx.cacheHit && !ctx.force && !ctx.dryRun) {
+                        return skip('[cache hit]');
+                    }
+                    const { input, operation } = await ctx.builder.build();
+                    ctx.builderInput = input;
+                    if (ctx.dryRun) {
+                        return skip('[dry run]');
                     }
-                    return ctx.builder.operation.run(ctx.builder?.input);
+                    return operation.run(ctx.builderInput);
                 },
             },
             {
                 // Return build meta data and dump
                 // cache data into sentinel file
                 task: async (ctx) => {
-                    // TODO: clean this
-                    if (ctx.builder?.mustBuild) {
-                        delete ctx.builder.mustBuild;
-                    }
-                    if (ctx.builder?.operation) {
-                        // @ts-expect-error duynno
-                        delete ctx.builder.operation;
+                    if (ctx.builder) {
+                        delete ctx.builder;
                     }
                     //
                     parentContext[resource.id] = ctx;
@@ -140,7 +147,14 @@ export class BuildResourcesOperation extends AbstractOperation {
     }
     async readSentinelFile(resource) {
         const path = this.sentinelFilePath(resource);
+        const stats = await this.context.monorepo.store.stat(path, false);
+        if (!stats) {
+            return undefined;
+        }
         const data = await this.context.monorepo.store.readFile(path, false);
-        return data ? JSON.parse(data) : undefined;
+        return {
+            data,
+            mtime: stats.mtime.getTime(),
+        };
     }
 }

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

@@ -1,7 +1,7 @@
 import { getContext } from '../../../index.js';
-import { ContainerExecOperation } from '../../../docker/index.js';
+import { ComposeExecOperation } from '../../../docker/index.js';
 import { EMBCollection, findRunOrder, taskManagerFactory, } from '../../index.js';
-import { ExecuteLocalCommandOperation, GetComponentContainerOperation, } from '../index.js';
+import { ExecuteLocalCommandOperation } from '../index.js';
 export var ExecutorType;
 (function (ExecutorType) {
     ExecutorType["container"] = "container";
@@ -53,18 +53,17 @@ export class RunTasksOperation {
     }
     async runDocker(task, out) {
         const { monorepo } = getContext();
-        const containerInfo = await monorepo.run(new GetComponentContainerOperation(), task.component);
-        return monorepo.run(new ContainerExecOperation(out), {
+        return monorepo.run(new ComposeExecOperation(out), {
             attachStderr: true,
             attachStdout: true,
-            container: containerInfo.Id,
-            script: task.script,
+            service: task.component,
+            command: task.script,
         });
     }
     async runLocal(task) {
         const { monorepo } = getContext();
         const cwd = task.component
-            ? monorepo.component(task.component).rootDir
+            ? monorepo.join(monorepo.component(task.component).rootDir)
             : monorepo.rootDir;
         return monorepo.run(new ExecuteLocalCommandOperation(), {
             script: task.script,

package/dist/src/monorepo/resources/FileResource.js

@@ -2,12 +2,16 @@ import { CreateFileOperation } from '../index.js';
 import { ResourceFactory } from './ResourceFactory.js';
 // Bring better abstraction and register as part of the plugin initialization
 ResourceFactory.register('file', async ({ config, component }) => {
-    const fromConfig = (config.params || {});
-    const input = {
-        path: component.join(fromConfig?.path || config.name),
-    };
     return {
-        input,
-        operation: new CreateFileOperation(),
+        async build() {
+            const fromConfig = (config.params || {});
+            const input = {
+                path: component.join(fromConfig?.path || config.name),
+            };
+            return {
+                input,
+                operation: new CreateFileOperation(),
+            };
+        },
     };
 });

package/dist/src/monorepo/resources/ResourceFactory.d.ts

@@ -10,8 +10,10 @@ export type SentinelData<T = void> = {
     data: T;
 };
 export type ResourceBuilderInfo<I, O, D = unknown> = {
-    input: I;
-    operation: IOperation<I, O>;
+    build(): Promise<{
+        input: I;
+        operation: IOperation<I, O>;
+    }>;
     mustBuild?: (previousSentinelData: SentinelData<D> | undefined) => Promise<undefined | unknown>;
 };
 export type ResourceFactoryOutput<I, O> = Promise<ResourceBuilderInfo<I, O>>;

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

@@ -14,6 +14,7 @@ export declare class EMBStore {
     init(): Promise<void>;
     join(path: string): string;
     mkdirp(path: string): Promise<void>;
+    stat(path: string, mustExist?: boolean): Promise<import("fs").Stats | undefined>;
     readFile(path: string, mustExist?: boolean): Promise<string | undefined>;
     trash(): Promise<void>;
     writeFile(path: string, data: string): Promise<void>;

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

@@ -1,5 +1,5 @@
 import { constants, createReadStream, createWriteStream } from 'node:fs';
-import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { access, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { dirname, join, normalize } from 'node:path';
 /**
  * A first implementation of a "store" where
@@ -54,6 +54,17 @@ export class EMBStore {
         const normalized = normalize(join('/', path));
         await mkdir(this.join(normalized), { recursive: true });
     }
+    async stat(path, mustExist = true) {
+        try {
+            return await stat(this.join(path));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' && !mustExist) {
+                return;
+            }
+            throw error;
+        }
+    }
     async readFile(path, mustExist = true) {
         try {
             return (await readFile(this.join(path))).toString();

package/oclif.manifest.json

@@ -217,6 +217,57 @@
         "logs.js"
       ]
     },
+    "components:shell": {
+      "aliases": [
+        "shell"
+      ],
+      "args": {
+        "component": {
+          "description": "The component you want to get a shell on",
+          "name": "component",
+          "required": true
+        }
+      },
+      "description": "Get a shell on a running component.",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {
+        "flavor": {
+          "description": "Specify the flavor to use.",
+          "name": "flavor",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "shell": {
+          "char": "s",
+          "description": "The shell to run",
+          "name": "shell",
+          "default": "bash",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "components:shell",
+      "pluginAlias": "@enspirit/emb",
+      "pluginName": "@enspirit/emb",
+      "pluginType": "core",
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "src",
+        "cli",
+        "commands",
+        "components",
+        "shell.js"
+      ]
+    },
     "config:print": {
       "aliases": [],
       "args": {},
@@ -667,5 +718,5 @@
       ]
     }
   },
-  "version": "0.1.3"
+  "version": "0.3.0"
 }

package/package.json

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