@enspirit/emb 0.14.1 → 0.17.0

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

@@ -1,10 +1,17 @@
 import { Args, Flags } from '@oclif/core';
 import { BaseCommand, getContext } from '../../index.js';
+import { ComposeLogsOperation } from '../../../docker/index.js';
 export default class ComponentsLogs extends BaseCommand {
     static aliases = ['logs'];
     static description = 'Get components logs.';
     static enableJsonFlag = false;
-    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> backend',
+        '<%= config.bin %> <%= command.id %> backend frontend',
+        '<%= config.bin %> <%= command.id %> --no-follow backend',
+    ];
+    static strict = false;
     static flags = {
         follow: Flags.boolean({
             name: 'follow',
@@ -17,32 +24,22 @@ export default class ComponentsLogs extends BaseCommand {
     static args = {
         component: Args.string({
             name: 'component',
-            description: 'The component you want to see the logs of',
-            required: true,
+            description: 'The component(s) you want to see the logs of (all if omitted)',
+            required: false,
         }),
     };
     async run() {
-        const { flags, args } = await this.parse(ComponentsLogs);
-        const { monorepo, docker, compose } = await getContext();
-        const component = monorepo.component(args.component);
-        const containerId = await compose.getContainer(component.name, {
-            mustBeRunning: false,
+        const { flags, argv } = await this.parse(ComponentsLogs);
+        const { monorepo } = await getContext();
+        const componentNames = argv;
+        // Validate that all specified components exist
+        const services = componentNames.map((name) => {
+            const component = monorepo.component(name);
+            return component.name;
+        });
+        await monorepo.run(new ComposeLogsOperation(), {
+            services: services.length > 0 ? services : undefined,
+            follow: flags.follow,
         });
-        const container = await docker.getContainer(containerId);
-        if (flags.follow) {
-            const stream = await container.logs({
-                follow: true,
-                stderr: true,
-                stdout: true,
-            });
-            docker.modem.demuxStream(stream, process.stdout, process.stderr);
-        }
-        else {
-            const res = await container.logs({
-                stderr: true,
-                stdout: true,
-            });
-            this.log(res.toString());
-        }
     }
 }

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

@@ -0,0 +1,14 @@
+import { FlavoredCommand } from '../../index.js';
+export interface SecretInfo {
+    component?: string;
+    key?: string;
+    path: string;
+    provider: string;
+    usageCount: number;
+}
+export default class SecretsIndex extends FlavoredCommand<typeof SecretsIndex> {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    run(): Promise<SecretInfo[]>;
+}

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

@@ -0,0 +1,71 @@
+import { getContext } from '../../../index.js';
+import { printTable } from '@oclif/table';
+import { FlavoredCommand, TABLE_DEFAULTS } from '../../index.js';
+import { aggregateSecrets, discoverSecrets, } from '../../../secrets/SecretDiscovery.js';
+export default class SecretsIndex extends FlavoredCommand {
+    static description = 'List all secret references in the configuration.';
+    static enableJsonFlag = true;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    async run() {
+        const { flags } = await this.parse(SecretsIndex);
+        const context = getContext();
+        const { monorepo, secrets } = context;
+        // Get registered secret providers dynamically
+        const secretProviders = new Set(secrets.getProviderNames());
+        // Collect secrets from all configuration sources
+        const allSecrets = [];
+        // Scan monorepo-level config (env, vars, tasks, defaults, flavors)
+        allSecrets.push(...discoverSecrets({
+            env: monorepo.config.env,
+            vars: monorepo.config.vars,
+            tasks: monorepo.config.tasks,
+            defaults: monorepo.config.defaults,
+            flavors: monorepo.config.flavors,
+        }, { file: '.emb.yml' }, secretProviders));
+        // Scan each component's config
+        for (const component of monorepo.components) {
+            allSecrets.push(...discoverSecrets({
+                tasks: component.config.tasks,
+                resources: component.config.resources,
+            }, {
+                file: `${component.name}/Embfile.yml`,
+                component: component.name,
+            }, secretProviders));
+        }
+        // Aggregate by unique secret reference
+        const aggregated = aggregateSecrets(allSecrets);
+        // Convert to output format
+        const result = aggregated.map((secret) => ({
+            provider: secret.provider,
+            path: secret.path,
+            key: secret.key,
+            component: secret.locations
+                .map((l) => l.component)
+                .filter(Boolean)
+                .join(', ') || undefined,
+            usageCount: secret.locations.length,
+        }));
+        if (!flags.json) {
+            if (result.length === 0) {
+                this.log('No secret references found in configuration.');
+            }
+            else {
+                printTable({
+                    ...TABLE_DEFAULTS,
+                    columns: ['provider', 'path', 'key', 'component', 'usageCount'],
+                    data: result.map((r) => ({
+                        ...r,
+                        key: r.key || '-',
+                        component: r.component || '-',
+                    })),
+                });
+                const providerCount = new Set(result.map((r) => r.provider)).size;
+                this.log(`\nFound ${result.length} secret reference(s) using ${providerCount} provider(s).`);
+            }
+        }
+        return result;
+    }
+}

package/dist/src/cli/commands/secrets/providers.d.ts

@@ -0,0 +1,12 @@
+import { FlavoredCommand } from '../../index.js';
+export interface ProviderInfo {
+    name: string;
+    status: 'connected' | 'not_configured';
+    type: string;
+}
+export default class SecretsProviders extends FlavoredCommand<typeof SecretsProviders> {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    run(): Promise<ProviderInfo[]>;
+}

package/dist/src/cli/commands/secrets/providers.js

@@ -0,0 +1,50 @@
+import { getContext } from '../../../index.js';
+import { printTable } from '@oclif/table';
+import { FlavoredCommand, TABLE_DEFAULTS } from '../../index.js';
+export default class SecretsProviders extends FlavoredCommand {
+    static description = 'Show configured secret providers and their status.';
+    static enableJsonFlag = true;
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const { flags } = await this.parse(SecretsProviders);
+        const context = getContext();
+        const { secrets } = context;
+        const providerNames = secrets.getProviderNames();
+        if (providerNames.length === 0) {
+            if (!flags.json) {
+                this.log('No secret providers configured.');
+                this.log('\nTo configure a provider, add it to your .emb.yml:');
+                this.log(`
+plugins:
+  - name: vault
+    config:
+      address: https://vault.example.com
+      auth:
+        method: oidc
+`);
+            }
+            return [];
+        }
+        const results = providerNames.map((name) => {
+            const provider = secrets.get(name);
+            return {
+                name,
+                type: provider?.constructor.name || 'Unknown',
+                status: provider ? 'connected' : 'not_configured',
+            };
+        });
+        if (!flags.json) {
+            printTable({
+                ...TABLE_DEFAULTS,
+                columns: ['name', 'type', 'status'],
+                data: results.map((r) => ({
+                    name: r.name,
+                    type: r.type,
+                    status: r.status === 'connected' ? '✔ Connected' : '✖ Not configured',
+                })),
+            });
+            this.log(`\n${results.length} provider(s) configured.`);
+        }
+        return results;
+    }
+}

package/dist/src/cli/commands/secrets/validate.d.ts

@@ -0,0 +1,18 @@
+import { FlavoredCommand } from '../../index.js';
+export interface ValidationResult {
+    error?: string;
+    key?: string;
+    path: string;
+    provider: string;
+    status: 'error' | 'ok';
+}
+export default class SecretsValidate extends FlavoredCommand<typeof SecretsValidate> {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        'fail-fast': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<ValidationResult[]>;
+    private validateSecret;
+}

package/dist/src/cli/commands/secrets/validate.js

@@ -0,0 +1,145 @@
+import { getContext } from '../../../index.js';
+import { Flags } from '@oclif/core';
+import { printTable } from '@oclif/table';
+import { FlavoredCommand, TABLE_DEFAULTS } from '../../index.js';
+import { aggregateSecrets, discoverSecrets, } from '../../../secrets/SecretDiscovery.js';
+export default class SecretsValidate extends FlavoredCommand {
+    static description = 'Validate that all secret references can be resolved (without showing values).';
+    static enableJsonFlag = true;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --fail-fast',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        'fail-fast': Flags.boolean({
+            default: false,
+            description: 'Stop on first validation error',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SecretsValidate);
+        const context = getContext();
+        const { monorepo, secrets } = context;
+        // Get registered secret providers dynamically
+        const secretProviders = new Set(secrets.getProviderNames());
+        // Collect secrets from all configuration sources
+        const allSecrets = [];
+        // Scan monorepo-level config (env, vars, tasks, defaults, flavors)
+        allSecrets.push(...discoverSecrets({
+            env: monorepo.config.env,
+            vars: monorepo.config.vars,
+            tasks: monorepo.config.tasks,
+            defaults: monorepo.config.defaults,
+            flavors: monorepo.config.flavors,
+        }, { file: '.emb.yml' }, secretProviders));
+        // Scan each component's config
+        for (const component of monorepo.components) {
+            allSecrets.push(...discoverSecrets({
+                tasks: component.config.tasks,
+                resources: component.config.resources,
+            }, {
+                file: `${component.name}/Embfile.yml`,
+                component: component.name,
+            }, secretProviders));
+        }
+        // Aggregate by unique secret reference
+        const aggregated = aggregateSecrets(allSecrets);
+        if (aggregated.length === 0) {
+            if (!flags.json) {
+                this.log('No secret references found in configuration.');
+            }
+            return [];
+        }
+        // Validate each secret
+        const results = [];
+        let hasErrors = false;
+        for (const secret of aggregated) {
+            // Sequential validation is intentional for fail-fast support
+            // eslint-disable-next-line no-await-in-loop
+            const result = await this.validateSecret(secret, secrets);
+            results.push(result);
+            if (result.status === 'error') {
+                hasErrors = true;
+                if (flags['fail-fast']) {
+                    break;
+                }
+            }
+        }
+        if (!flags.json) {
+            printTable({
+                ...TABLE_DEFAULTS,
+                columns: ['status', 'provider', 'path', 'key'],
+                data: results.map((r) => ({
+                    status: r.status === 'ok' ? '✔' : '✖',
+                    provider: r.provider,
+                    path: r.path,
+                    key: r.key || '-',
+                })),
+            });
+            const passed = results.filter((r) => r.status === 'ok').length;
+            const failed = results.filter((r) => r.status === 'error').length;
+            this.log(`\nValidation: ${passed} passed, ${failed} failed`);
+            // Show error details
+            const errors = results.filter((r) => r.status === 'error');
+            if (errors.length > 0) {
+                this.log('\nError details:');
+                for (const error of errors) {
+                    const ref = error.key
+                        ? `${error.provider}:${error.path}#${error.key}`
+                        : `${error.provider}:${error.path}`;
+                    this.log(`  - ${ref}: ${error.error}`);
+                }
+            }
+        }
+        // Exit with error code if validation failed
+        if (hasErrors) {
+            this.exit(1);
+        }
+        return results;
+    }
+    async validateSecret(secret, secrets) {
+        const provider = secrets.get(secret.provider);
+        if (!provider) {
+            return {
+                provider: secret.provider,
+                path: secret.path,
+                key: secret.key,
+                status: 'error',
+                error: `Provider '${secret.provider}' not configured`,
+            };
+        }
+        try {
+            // Actually fetch the secret to verify access
+            const result = await provider.get({
+                path: secret.path,
+                key: secret.key,
+            });
+            // If a key was specified, verify it exists
+            if (secret.key && result === undefined) {
+                return {
+                    provider: secret.provider,
+                    path: secret.path,
+                    key: secret.key,
+                    status: 'error',
+                    error: `Key '${secret.key}' not found in secret`,
+                };
+            }
+            return {
+                provider: secret.provider,
+                path: secret.path,
+                key: secret.key,
+                status: 'ok',
+            };
+        }
+        catch (error) {
+            return {
+                provider: secret.provider,
+                path: secret.path,
+                key: secret.key,
+                status: 'error',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}

package/dist/src/cli/hooks/init.js

@@ -1,2 +1,8 @@
-const hook = async function (_options) { };
+import { settings } from '@oclif/core';
+const hook = async function (_options) {
+    // Disable oclif's auto-transpilation to avoid spurious warnings when npm-linked.
+    // We always run from compiled JS in dist/, so auto-transpilation is not needed.
+    // This prevents a double tsPath() call that produces "Could not find source" warnings.
+    settings.enableAutoTranspile = false;
+};
 export default hook;

package/dist/src/cli/hooks/postrun.d.ts

@@ -0,0 +1,7 @@
+import { Hook } from '@oclif/core';
+/**
+ * Postrun hook that patches completion scripts after autocomplete generation.
+ * This adds task name completion for the 'tasks run' and 'run' commands.
+ */
+declare const hook: Hook.Postrun;
+export default hook;

package/dist/src/cli/hooks/postrun.js

@@ -0,0 +1,128 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Task completion function to inject into the bash completion script.
+ * This function is called when completing arguments for `tasks run` or `run`.
+ */
+const TASK_COMPLETION_FUNCTION = `
+# EMB: Task name completion for 'tasks run' and 'run' commands
+_emb_complete_tasks() {
+  local cur="\${1:-}"
+  local tasks
+
+  # Get task IDs from emb tasks --json, extract the id field
+  tasks=$(emb tasks --json 2>/dev/null | grep -o '"id": *"[^"]*"' | sed 's/"id": *"//g' | sed 's/"//g')
+
+  if [[ -z "$tasks" ]]; then
+    return
+  fi
+
+  # Filter by substring match if provided (more flexible than prefix-only)
+  if [[ -n "$cur" ]]; then
+    local matches=""
+    for task in $tasks; do
+      if [[ "$task" == *"$cur"* ]]; then
+        matches="$matches $task"
+      fi
+    done
+    COMPREPLY=($matches)
+  else
+    COMPREPLY=($tasks)
+  fi
+}
+`;
+/**
+ * Enhanced completion logic to inject after normalizedCommand is calculated.
+ * Checks if we're completing task arguments for 'tasks run' or 'run'.
+ */
+const TASK_COMPLETION_LOGIC = `
+    # EMB: Check if we're completing task names for 'tasks run' or 'run'
+    if [[ "$normalizedCommand" == tasks:run:* ]] || [[ "$normalizedCommand" == run:* ]] || [[ "$normalizedCommand" == "tasks:run" ]] || [[ "$normalizedCommand" == "run" ]]; then
+      _emb_complete_tasks "$cur"
+      return
+    fi
+`;
+/**
+ * Zsh task completion function to inject.
+ * Uses zsh's compadd to add task completions.
+ * Note: We use compadd instead of _describe because task IDs contain colons
+ * (e.g., "frontend:test") and _describe uses colons as value:description delimiter.
+ */
+const ZSH_TASK_COMPLETION_FUNCTION = `
+# EMB: Task name completion for 'tasks run' and 'run' commands
+_emb_complete_tasks() {
+  local tasks
+  # Get task IDs from emb tasks --json, extract the id field
+  tasks=(\${(f)"$(emb tasks --json 2>/dev/null | grep -o '"id": *"[^"]*"' | sed 's/"id": *"//g' | sed 's/"//g')"})
+
+  if [[ \${#tasks[@]} -gt 0 ]]; then
+    # Use compadd instead of _describe because task IDs contain colons
+    # which _describe interprets as value:description separators
+    compadd -a tasks
+  fi
+}
+`;
+/**
+ * Patches the bash completion script.
+ */
+function patchBashCompletion() {
+    const possiblePaths = [
+        join(homedir(), 'Library/Caches/emb/autocomplete/functions/bash/emb.bash'),
+        join(homedir(), '.cache/emb/autocomplete/functions/bash/emb.bash'),
+    ];
+    const scriptPath = possiblePaths.find((p) => existsSync(p));
+    if (!scriptPath) {
+        return;
+    }
+    const content = readFileSync(scriptPath, 'utf8');
+    // Check if already patched
+    if (content.includes('_emb_complete_tasks')) {
+        return;
+    }
+    // Insert task completion function after the join_by function
+    let patched = content.replace(/function join_by \{[^}]+\}/, (match) => `${match}\n${TASK_COMPLETION_FUNCTION}`);
+    // Insert task completion logic right before the "if [[ -z "$normalizedCommand" ]]" check
+    patched = patched.replace('if [[ -z "$normalizedCommand" ]]; then', `${TASK_COMPLETION_LOGIC.trim()}\n\n    if [[ -z "$normalizedCommand" ]]; then`);
+    writeFileSync(scriptPath, patched, 'utf8');
+}
+/**
+ * Patches the zsh completion script.
+ */
+function patchZshCompletion() {
+    const possiblePaths = [
+        join(homedir(), 'Library/Caches/emb/autocomplete/functions/zsh/_emb'),
+        join(homedir(), '.cache/emb/autocomplete/functions/zsh/_emb'),
+    ];
+    const scriptPath = possiblePaths.find((p) => existsSync(p));
+    if (!scriptPath) {
+        return;
+    }
+    const content = readFileSync(scriptPath, 'utf8');
+    // Check if already patched
+    if (content.includes('_emb_complete_tasks')) {
+        return;
+    }
+    // Insert task completion function after #compdef line
+    let patched = content.replace('#compdef emb', `#compdef emb\n${ZSH_TASK_COMPLETION_FUNCTION}`);
+    // Replace _files with _emb_complete_tasks in run command sections
+    // Pattern 1: Inside _emb_tasks for "tasks run"
+    patched = patched.replace(/("run"\)\s*\n\s*_arguments -S[\s\S]*?)"?\*: :_files"(\s*;;)/, '$1"*: :_emb_complete_tasks"$2');
+    // Pattern 2: Top-level run) command (the alias)
+    patched = patched.replace(/(^run\)\n_arguments -S[\s\S]*?)"?\*: :_files"(\s*;;)/m, '$1"*: :_emb_complete_tasks"$2');
+    writeFileSync(scriptPath, patched, 'utf8');
+}
+/**
+ * Postrun hook that patches completion scripts after autocomplete generation.
+ * This adds task name completion for the 'tasks run' and 'run' commands.
+ */
+const hook = async function (options) {
+    const commandId = options.Command?.id;
+    // Only patch after autocomplete commands
+    if (commandId !== 'autocomplete' && commandId !== 'autocomplete:create') {
+        return;
+    }
+    patchBashCompletion();
+    patchZshCompletion();
+};
+export default hook;

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

@@ -1,6 +1,15 @@
 export * from './types.js';
 export * from './validation.js';
-export declare const loadConfig: () => Promise<{
+export interface LoadConfigOptions {
+    /**
+     * Explicit root directory path. Takes precedence over EMB_ROOT env var.
+     * Can be either:
+     * - A directory containing .emb.yml
+     * - A direct path to a .emb.yml file
+     */
+    root?: string;
+}
+export declare const loadConfig: (options?: LoadConfigOptions) => Promise<{
     rootDir: string;
     config: import("./schema.js").EMBConfig;
 }>;

package/dist/src/config/index.js

@@ -1,10 +1,35 @@
 import { findUp } from 'find-up';
-import { dirname } from 'node:path';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { validateUserConfig } from './validation.js';
 export * from './types.js';
 export * from './validation.js';
-export const loadConfig = async () => {
-    const path = await findUp('.emb.yml');
+export const loadConfig = async (options = {}) => {
+    let path;
+    // Priority 1: Explicit root option (from --root/-C flag)
+    // Priority 2: EMB_ROOT environment variable
+    // Priority 3: Walk up to find .emb.yml (original behavior)
+    const explicitRoot = options.root || process.env.EMB_ROOT;
+    if (explicitRoot) {
+        const resolved = resolve(explicitRoot);
+        // Check if it's a direct path to a config file
+        if (resolved.endsWith('.emb.yml') && existsSync(resolved)) {
+            path = resolved;
+        }
+        else {
+            // Assume it's a directory, look for .emb.yml inside
+            const configPath = join(resolved, '.emb.yml');
+            if (existsSync(configPath)) {
+                path = configPath;
+            }
+            else {
+                throw new Error(`Could not find .emb.yml in specified root: ${explicitRoot}`);
+            }
+        }
+    }
+    else {
+        path = await findUp('.emb.yml');
+    }
     if (!path) {
         throw new Error('Could not find EMB config anywhere');
     }

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

@@ -3,6 +3,12 @@
  * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
  * and run json-schema-to-typescript to regenerate this file.
  */
+export type PluginConfigItem = {
+    [k: string]: unknown;
+} & {
+    name: Identifier;
+    config?: unknown;
+};
 export type Identifier = string;
 export type TaskConfig = TaskConfig1 & {
     description?: string;
@@ -55,10 +61,7 @@ export interface EMBConfig {
          */
         rootDir?: string;
     };
-    plugins?: {
-        name: Identifier;
-        config?: unknown;
-    }[];
+    plugins?: PluginConfigItem[];
     /**
      * Variables to install on the environment
      */