@enspirit/emb 0.17.0 → 0.18.0

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

@@ -0,0 +1,77 @@
+import { spawn } from 'node:child_process';
+import { createWriteStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+export const ComposeLogsArchiveOperationInputSchema = z
+    .object({
+    components: z
+        .array(z.string())
+        .optional()
+        .describe('The list of components to archive logs for (all if omitted)'),
+    outputDir: z
+        .string()
+        .optional()
+        .describe('Output directory for log files (defaults to .emb/<flavor>/logs/docker/compose)'),
+    timestamps: z.boolean().optional().describe('Include timestamps in logs'),
+    tail: z
+        .number()
+        .optional()
+        .describe('Number of lines to show from the end'),
+})
+    .optional();
+export class ComposeLogsArchiveOperation extends AbstractOperation {
+    constructor() {
+        super(ComposeLogsArchiveOperationInputSchema);
+    }
+    async _run(input) {
+        const { monorepo } = this.context;
+        // Determine which components to archive
+        const componentNames = input?.components ?? monorepo.components.map((c) => c.name);
+        // Validate all component names
+        const components = componentNames.map((name) => monorepo.component(name));
+        // Determine output directory
+        const outputDir = input?.outputDir ?? monorepo.store.join('logs/docker/compose');
+        // Ensure output directory exists
+        await mkdir(outputDir, { recursive: true });
+        // Archive logs for each component
+        const archivePromises = components.map(async (component) => {
+            const logPath = join(outputDir, `${component.name}.log`);
+            await this.archiveComponentLogs(component.name, logPath, input);
+            return { component: component.name, path: logPath };
+        });
+        return Promise.all(archivePromises);
+    }
+    async archiveComponentLogs(serviceName, outputPath, input) {
+        const { monorepo } = this.context;
+        // Ensure parent directory exists
+        await mkdir(dirname(outputPath), { recursive: true });
+        const cmd = 'docker';
+        const args = ['compose', 'logs', '--no-color'];
+        if (input?.timestamps) {
+            args.push('-t');
+        }
+        if (input?.tail !== undefined) {
+            args.push('--tail', String(input.tail));
+        }
+        args.push(serviceName);
+        return new Promise((resolve, reject) => {
+            const writeStream = createWriteStream(outputPath);
+            const child = spawn(cmd, args, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                cwd: monorepo.rootDir,
+            });
+            child.stdout?.pipe(writeStream, { end: false });
+            child.stderr?.pipe(writeStream, { end: false });
+            child.on('error', (err) => {
+                writeStream.end();
+                reject(new Error(`Failed to get logs for ${serviceName}: ${err.message}`));
+            });
+            child.on('exit', () => {
+                writeStream.end();
+                resolve();
+            });
+        });
+    }
+}

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

@@ -1,6 +1,7 @@
 export * from './ComposeDownOperation.js';
 export * from './ComposeExecOperation.js';
 export * from './ComposeExecShellOperation.js';
+export * from './ComposeLogsArchiveOperation.js';
 export * from './ComposeLogsOperation.js';
 export * from './ComposePsOperation.js';
 export * from './ComposeRestartOperation.js';

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

@@ -1,6 +1,7 @@
 export * from './ComposeDownOperation.js';
 export * from './ComposeExecOperation.js';
 export * from './ComposeExecShellOperation.js';
+export * from './ComposeLogsArchiveOperation.js';
 export * from './ComposeLogsOperation.js';
 export * from './ComposePsOperation.js';
 export * from './ComposeRestartOperation.js';

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

@@ -1,6 +1,12 @@
+import { CommandExecError } from '../../../index.js';
 import { execa } from 'execa';
+import { Readable } from 'node:stream';
 import * as z from 'zod';
 import { AbstractOperation } from '../../../operations/index.js';
+// Type guard for execa error objects
+function isExecaError(error) {
+    return error instanceof Error && 'exitCode' in error;
+}
 /**
  * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Exec/operation/ContainerExec
  */
@@ -27,20 +33,44 @@ export class ExecuteLocalCommandOperation extends AbstractOperation {
         this.out = out;
     }
     async _run(input) {
-        const proc = input.interactive
-            ? execa(input.script, {
-                cwd: input.workingDir,
-                shell: true,
-                env: input.env,
-                stdin: 'inherit',
-            })
-            : execa(input.script, {
+        try {
+            if (input.interactive) {
+                // For interactive mode, inherit all stdio streams so the child process
+                // has direct access to the terminal TTY. This allows interactive CLI tools
+                // (like ionic, npm, etc.) to detect TTY and show prompts.
+                await execa(input.script, {
+                    cwd: input.workingDir,
+                    shell: true,
+                    env: input.env,
+                    stdio: 'inherit',
+                });
+                // Return an empty stream for type compatibility - the caller won't use it
+                // since interactive mode outputs directly to the terminal
+                return new Readable({
+                    read() {
+                        this.push(null);
+                    },
+                });
+            }
+            // Non-interactive mode: capture output
+            const proc = execa(input.script, {
                 all: true,
                 cwd: input.workingDir,
                 shell: true,
                 env: input.env,
             });
-        proc.all?.pipe(this.out || process.stdout);
-        return proc.all || proc.stdout;
+            // With all: true, proc.all is always defined
+            proc.all.pipe(this.out || process.stdout);
+            await proc;
+            return proc.all;
+        }
+        catch (error) {
+            if (isExecaError(error)) {
+                const stderr = error.stderr?.trim();
+                const message = stderr || error.shortMessage || error.message;
+                throw new CommandExecError(message, error.exitCode ?? 1, error.signal);
+            }
+            throw error;
+        }
     }
 }