@formigio/fazemos-cli 0.2.2 → 0.2.4

package/dist/index.js

@@ -697,6 +697,26 @@ commitments
         process.exit(1);
     }
 });
+// ── Template I/O helpers ───────────────────────────────────
+function allSteps(definition) {
+    const steps = [];
+    for (const phase of definition?.phases || []) {
+        for (const step of phase.steps || []) {
+            steps.push(step);
+        }
+    }
+    return steps;
+}
+function findStepById(definition, stepId) {
+    return allSteps(definition).find((s) => s.id === stepId);
+}
+const VALID_IO_TYPES = ['text', 'markdown', 'number', 'boolean', 'url', 'json', 'object', 'array'];
+function requireDraftStatus(template) {
+    if (template.status !== 'draft') {
+        console.error(chalk.yellow(`Template is "${template.status}" — edits require draft status`));
+        process.exit(1);
+    }
+}
 // ── Templates ──────────────────────────────────────────────
 const templates = program.command('templates').alias('tpl').description('Pipeline template commands');
 templates
@@ -734,11 +754,45 @@ templates
         console.log(`  ID:      ${t.id}`);
         console.log(`  Status:  ${t.status}`);
         console.log(`  Version: ${t.version}`);
+        // Pipeline-level inputs
+        if (t.definition?.inputs?.length) {
+            console.log(chalk.cyan('\n  Pipeline Inputs:'));
+            for (const inp of t.definition.inputs) {
+                const req = inp.required === false ? 'optional' : 'required';
+                const desc = inp.description ? ` — ${inp.description}` : '';
+                const def = inp.default_value != null ? ` [default: ${inp.default_value}]` : '';
+                console.log(`    ${inp.name} (${inp.type}, ${req})${desc}${def}`);
+            }
+        }
         if (t.definition?.phases) {
             for (const phase of t.definition.phases) {
                 console.log(chalk.cyan(`\n  Phase: ${phase.name}`));
                 for (const step of phase.steps || []) {
-                    console.log(`    ${step.name} (${step.stepType || 'human'}) — role: ${step.role || 'unassigned'}`);
+                    console.log(`    Step: ${step.name} [${step.role || 'unassigned'}] (${step.step_type || step.stepType || 'human'})`);
+                    if (step.outputs?.length) {
+                        console.log('      Outputs:');
+                        for (const o of step.outputs) {
+                            const req = o.required === false ? 'optional' : 'required';
+                            const desc = o.description ? ` — ${o.description}` : '';
+                            console.log(`        → ${o.name} (${o.type}, ${req})${desc}`);
+                        }
+                    }
+                    if (step.inputs?.length) {
+                        console.log('      Inputs:');
+                        for (const inp of step.inputs) {
+                            if (inp.pipeline_input) {
+                                console.log(`        ← ${inp.name} ← pipeline.${inp.pipeline_input}`);
+                            }
+                            else {
+                                const srcStep = findStepById(t.definition, inp.source_step_id);
+                                const srcName = srcStep ? srcStep.name : inp.source_step_id;
+                                console.log(`        ← ${inp.name} ← ${srcName}.${inp.source_output_name}`);
+                            }
+                        }
+                    }
+                    else if (step.outputs?.length) {
+                        console.log('      Inputs: none');
+                    }
                 }
             }
         }
@@ -774,26 +828,48 @@ templates
     .argument('<file>', 'Path to JOE template JSON file')
     .action(async (file) => {
     try {
-        const { readFileSync } = await import('fs');
-        const { resolve } = await import('path');
         const raw = JSON.parse(readFileSync(resolve(file), 'utf-8'));
         // Map JOE template to Fazemos format
-        const steps = raw.steps || [];
-        // Group sequential steps into a single phase for now
+        const joeSteps = raw.steps || [];
+        // Build ID mapping so input source_step_id references survive UUID reassignment
+        const idMap = new Map();
+        for (const s of joeSteps) {
+            if (s.id)
+                idMap.set(s.id, crypto.randomUUID());
+        }
         const definition = {
+            inputs: (raw.inputs || []).map((i) => ({
+                name: i.name,
+                type: i.type || 'text',
+                required: i.required !== false,
+                ...(i.description ? { description: i.description } : {}),
+                ...(i.default_value != null ? { default_value: i.default_value } : {}),
+            })),
             phases: [{
                     id: crypto.randomUUID(),
                     name: raw.name || 'Main',
                     description: raw.description || '',
                     deliverables: [],
-                    steps: steps.map((s, i) => ({
-                        id: crypto.randomUUID(),
+                    steps: joeSteps.map((s, i) => ({
+                        id: idMap.get(s.id) || crypto.randomUUID(),
                         name: s.name,
                         description: s.description || '',
                         step_type: s.executionMode === 'script' ? 'script' : (s.agent ? 'agent' : 'human'),
                         role: s.role || s.agent || 'unassigned',
-                        inputs: [],
-                        outputs: [],
+                        inputs: (s.inputs || []).map((inp) => ({
+                            name: inp.name,
+                            ...(inp.source_step_id ? { source_step_id: idMap.get(inp.source_step_id) || inp.source_step_id, source_output_name: inp.source_output_name } : {}),
+                            ...(inp.pipeline_input ? { pipeline_input: inp.pipeline_input } : {}),
+                            ...(inp.description ? { description: inp.description } : {}),
+                            required: inp.required !== false,
+                        })),
+                        outputs: (s.outputs || []).map((o) => ({
+                            name: o.name,
+                            type: o.type || 'text',
+                            ...(o.description ? { description: o.description } : {}),
+                            required: o.required !== false,
+                            ...(o.format ? { format: o.format } : {}),
+                        })),
                         sections: s.sections || '',
                         reviewer: s.reviewer || null,
                         max_review_cycles: s.maxReviewCycles || 0,
@@ -813,7 +889,7 @@ templates
         };
         const data = await api('POST', '/api/pipeline-templates', body);
         const t = data.template;
-        console.log(chalk.green(`Imported: ${t.name} (${steps.length} steps)`));
+        console.log(chalk.green(`Imported: ${t.name} (${joeSteps.length} steps)`));
         console.log(`  ID: ${t.id}`);
     }
     catch (err) {
@@ -835,6 +911,438 @@ templates
         process.exit(1);
     }
 });
+// ── Template I/O commands ──────────────────────────────────
+templates
+    .command('steps')
+    .description('List step IDs and names in a template')
+    .argument('<id>', 'Template ID')
+    .action(async (id) => {
+    try {
+        const data = await api('GET', `/api/pipeline-templates/${id}`);
+        const steps = allSteps(data.template.definition);
+        if (!steps.length) {
+            console.log(chalk.yellow('No steps'));
+            return;
+        }
+        for (const s of steps) {
+            console.log(`  ${chalk.dim(s.id)}  ${s.name} [${s.role || 'unassigned'}]`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('add-output')
+    .description('Add an output declaration to a step')
+    .argument('<templateId>', 'Template ID')
+    .requiredOption('--step <stepId>', 'Step ID')
+    .requiredOption('--name <name>', 'Output name')
+    .requiredOption('--type <type>', `Output type: ${VALID_IO_TYPES.join(', ')}`)
+    .option('--description <desc>', 'Description')
+    .option('--optional', 'Mark as not required')
+    .option('--format <format>', 'Format hint (file_path, commit_sha, semver, date, etc.)')
+    .action(async (templateId, opts) => {
+    try {
+        if (!VALID_IO_TYPES.includes(opts.type)) {
+            console.error(chalk.red(`Invalid type "${opts.type}". Valid: ${VALID_IO_TYPES.join(', ')}`));
+            process.exit(1);
+        }
+        const data = await api('GET', `/api/pipeline-templates/${templateId}`);
+        const t = data.template;
+        requireDraftStatus(t);
+        const step = findStepById(t.definition, opts.step);
+        if (!step) {
+            console.error(chalk.red(`Step "${opts.step}" not found`));
+            process.exit(1);
+        }
+        if (!step.outputs)
+            step.outputs = [];
+        if (step.outputs.find((o) => o.name === opts.name)) {
+            console.error(chalk.red(`Output "${opts.name}" already exists on step "${step.name}"`));
+            process.exit(1);
+        }
+        const output = { name: opts.name, type: opts.type, required: !opts.optional };
+        if (opts.description)
+            output.description = opts.description;
+        if (opts.format)
+            output.format = opts.format;
+        step.outputs.push(output);
+        await api('PUT', `/api/pipeline-templates/${templateId}`, { definition: t.definition });
+        console.log(chalk.green(`Added output → ${opts.name} (${opts.type}) to ${step.name}`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('remove-output')
+    .description('Remove an output declaration from a step')
+    .argument('<templateId>', 'Template ID')
+    .requiredOption('--step <stepId>', 'Step ID')
+    .requiredOption('--name <name>', 'Output name')
+    .option('--force', 'Remove even if downstream steps reference this output')
+    .action(async (templateId, opts) => {
+    try {
+        const data = await api('GET', `/api/pipeline-templates/${templateId}`);
+        const t = data.template;
+        requireDraftStatus(t);
+        const step = findStepById(t.definition, opts.step);
+        if (!step) {
+            console.error(chalk.red(`Step "${opts.step}" not found`));
+            process.exit(1);
+        }
+        const idx = (step.outputs || []).findIndex((o) => o.name === opts.name);
+        if (idx === -1) {
+            console.error(chalk.red(`Output "${opts.name}" not found on step "${step.name}"`));
+            process.exit(1);
+        }
+        // Check for downstream references
+        const refs = allSteps(t.definition).filter((s) => (s.inputs || []).some((inp) => inp.source_step_id === step.id && inp.source_output_name === opts.name));
+        if (refs.length && !opts.force) {
+            console.error(chalk.yellow(`Output "${opts.name}" is referenced by: ${refs.map((r) => r.name).join(', ')}`));
+            console.error(chalk.yellow('Use --force to remove anyway'));
+            process.exit(1);
+        }
+        step.outputs.splice(idx, 1);
+        await api('PUT', `/api/pipeline-templates/${templateId}`, { definition: t.definition });
+        console.log(chalk.green(`Removed output → ${opts.name} from ${step.name}`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('add-input')
+    .description('Add an input declaration to a step')
+    .argument('<templateId>', 'Template ID')
+    .requiredOption('--step <stepId>', 'Step ID')
+    .requiredOption('--name <name>', 'Input name')
+    .option('--source-step <stepId>', 'Source step ID (for step-sourced inputs)')
+    .option('--source-output <name>', 'Source output name (for step-sourced inputs)')
+    .option('--pipeline-input <name>', 'Pipeline-level input name (for pipeline-sourced inputs)')
+    .option('--description <desc>', 'Description')
+    .option('--optional', 'Mark as not required')
+    .action(async (templateId, opts) => {
+    try {
+        const hasSrc = opts.sourceStep || opts.sourceOutput;
+        const hasPipeline = opts.pipelineInput;
+        if (!hasSrc && !hasPipeline) {
+            console.error(chalk.red('Provide either --source-step + --source-output or --pipeline-input'));
+            process.exit(1);
+        }
+        if (hasSrc && hasPipeline) {
+            console.error(chalk.red('Cannot use both --source-step and --pipeline-input'));
+            process.exit(1);
+        }
+        if (hasSrc && (!opts.sourceStep || !opts.sourceOutput)) {
+            console.error(chalk.red('Both --source-step and --source-output are required for step-sourced inputs'));
+            process.exit(1);
+        }
+        const data = await api('GET', `/api/pipeline-templates/${templateId}`);
+        const t = data.template;
+        requireDraftStatus(t);
+        const step = findStepById(t.definition, opts.step);
+        if (!step) {
+            console.error(chalk.red(`Step "${opts.step}" not found`));
+            process.exit(1);
+        }
+        if (!step.inputs)
+            step.inputs = [];
+        if (step.inputs.find((i) => i.name === opts.name)) {
+            console.error(chalk.red(`Input "${opts.name}" already exists on step "${step.name}"`));
+            process.exit(1);
+        }
+        // Validate references
+        if (opts.sourceStep) {
+            if (opts.sourceStep === step.id) {
+                console.error(chalk.red('Cannot reference own step (self-reference)'));
+                process.exit(1);
+            }
+            const srcStep = findStepById(t.definition, opts.sourceStep);
+            if (!srcStep) {
+                console.error(chalk.red(`Source step "${opts.sourceStep}" not found`));
+                process.exit(1);
+            }
+            if (!(srcStep.outputs || []).find((o) => o.name === opts.sourceOutput)) {
+                console.error(chalk.red(`Output "${opts.sourceOutput}" not declared on step "${srcStep.name}"`));
+                process.exit(1);
+            }
+        }
+        if (opts.pipelineInput) {
+            const pInputs = t.definition.inputs || [];
+            if (!pInputs.find((i) => i.name === opts.pipelineInput)) {
+                console.error(chalk.red(`Pipeline input "${opts.pipelineInput}" not found. Add it first with tpl add-pipeline-input`));
+                process.exit(1);
+            }
+        }
+        const input = { name: opts.name, required: !opts.optional };
+        if (opts.sourceStep) {
+            input.source_step_id = opts.sourceStep;
+            input.source_output_name = opts.sourceOutput;
+        }
+        else {
+            input.pipeline_input = opts.pipelineInput;
+        }
+        if (opts.description)
+            input.description = opts.description;
+        step.inputs.push(input);
+        await api('PUT', `/api/pipeline-templates/${templateId}`, { definition: t.definition });
+        if (opts.sourceStep) {
+            const srcStep = findStepById(t.definition, opts.sourceStep);
+            console.log(chalk.green(`Added input ← ${opts.name} ← ${srcStep.name}.${opts.sourceOutput} to ${step.name}`));
+        }
+        else {
+            console.log(chalk.green(`Added input ← ${opts.name} ← pipeline.${opts.pipelineInput} to ${step.name}`));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('remove-input')
+    .description('Remove an input declaration from a step')
+    .argument('<templateId>', 'Template ID')
+    .requiredOption('--step <stepId>', 'Step ID')
+    .requiredOption('--name <name>', 'Input name')
+    .action(async (templateId, opts) => {
+    try {
+        const data = await api('GET', `/api/pipeline-templates/${templateId}`);
+        const t = data.template;
+        requireDraftStatus(t);
+        const step = findStepById(t.definition, opts.step);
+        if (!step) {
+            console.error(chalk.red(`Step "${opts.step}" not found`));
+            process.exit(1);
+        }
+        const idx = (step.inputs || []).findIndex((i) => i.name === opts.name);
+        if (idx === -1) {
+            console.error(chalk.red(`Input "${opts.name}" not found on step "${step.name}"`));
+            process.exit(1);
+        }
+        step.inputs.splice(idx, 1);
+        await api('PUT', `/api/pipeline-templates/${templateId}`, { definition: t.definition });
+        console.log(chalk.green(`Removed input ← ${opts.name} from ${step.name}`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('add-pipeline-input')
+    .description('Add a pipeline-level input to the template')
+    .argument('<templateId>', 'Template ID')
+    .requiredOption('--name <name>', 'Input name')
+    .requiredOption('--type <type>', `Input type: ${VALID_IO_TYPES.join(', ')}`)
+    .option('--description <desc>', 'Description')
+    .option('--optional', 'Not required at instance creation')
+    .option('--default <value>', 'Default value')
+    .action(async (templateId, opts) => {
+    try {
+        if (!VALID_IO_TYPES.includes(opts.type)) {
+            console.error(chalk.red(`Invalid type "${opts.type}". Valid: ${VALID_IO_TYPES.join(', ')}`));
+            process.exit(1);
+        }
+        const data = await api('GET', `/api/pipeline-templates/${templateId}`);
+        const t = data.template;
+        requireDraftStatus(t);
+        if (!t.definition.inputs)
+            t.definition.inputs = [];
+        if (t.definition.inputs.find((i) => i.name === opts.name)) {
+            console.error(chalk.red(`Pipeline input "${opts.name}" already exists`));
+            process.exit(1);
+        }
+        const input = { name: opts.name, type: opts.type, required: !opts.optional };
+        if (opts.description)
+            input.description = opts.description;
+        if (opts.default != null)
+            input.default_value = opts.default;
+        t.definition.inputs.push(input);
+        await api('PUT', `/api/pipeline-templates/${templateId}`, { definition: t.definition });
+        console.log(chalk.green(`Added pipeline input: ${opts.name} (${opts.type})`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('remove-pipeline-input')
+    .description('Remove a pipeline-level input from the template')
+    .argument('<templateId>', 'Template ID')
+    .requiredOption('--name <name>', 'Input name')
+    .option('--force', 'Remove even if steps reference this input')
+    .action(async (templateId, opts) => {
+    try {
+        const data = await api('GET', `/api/pipeline-templates/${templateId}`);
+        const t = data.template;
+        requireDraftStatus(t);
+        const inputs = t.definition.inputs || [];
+        const idx = inputs.findIndex((i) => i.name === opts.name);
+        if (idx === -1) {
+            console.error(chalk.red(`Pipeline input "${opts.name}" not found`));
+            process.exit(1);
+        }
+        // Block if steps reference it unless --force
+        const refs = allSteps(t.definition).filter((s) => (s.inputs || []).some((inp) => inp.pipeline_input === opts.name));
+        if (refs.length && !opts.force) {
+            console.error(chalk.yellow(`Pipeline input "${opts.name}" is referenced by: ${refs.map((r) => r.name).join(', ')}`));
+            console.error(chalk.yellow('Use --force to remove anyway'));
+            process.exit(1);
+        }
+        inputs.splice(idx, 1);
+        await api('PUT', `/api/pipeline-templates/${templateId}`, { definition: t.definition });
+        console.log(chalk.green(`Removed pipeline input: ${opts.name}`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('validate')
+    .description('Validate template I/O contracts')
+    .argument('<id>', 'Template ID')
+    .action(async (id) => {
+    try {
+        const data = await api('GET', `/api/pipeline-templates/${id}`);
+        const t = data.template;
+        const steps = allSteps(t.definition);
+        const pipelineInputs = t.definition.inputs || [];
+        console.log(`Validating: ${chalk.cyan(t.name)} (${id})\n`);
+        let passed = 0, warnings = 0, infos = 0, errors = 0;
+        // Check for duplicate input names per step
+        let hasDupes = false;
+        for (const step of steps) {
+            const names = (step.inputs || []).map((i) => i.name);
+            const dupes = names.filter((n, i) => names.indexOf(n) !== i);
+            if (dupes.length) {
+                console.log(chalk.red(`  ✗ Step "${step.name}" has duplicate input names: ${[...new Set(dupes)].join(', ')}`));
+                hasDupes = true;
+                errors++;
+            }
+        }
+        if (!hasDupes) {
+            console.log(chalk.green('  ✓ No duplicate input names'));
+            passed++;
+        }
+        // Check self-references
+        let hasSelfRef = false;
+        for (const step of steps) {
+            for (const inp of step.inputs || []) {
+                if (inp.source_step_id === step.id) {
+                    console.log(chalk.red(`  ✗ Step "${step.name}" input "${inp.name}" references itself`));
+                    hasSelfRef = true;
+                    errors++;
+                }
+            }
+        }
+        if (!hasSelfRef) {
+            console.log(chalk.green('  ✓ No self-references'));
+            passed++;
+        }
+        // Check all input references resolve
+        let hasUnresolved = false;
+        for (const step of steps) {
+            for (const inp of step.inputs || []) {
+                if (inp.source_step_id) {
+                    const src = findStepById(t.definition, inp.source_step_id);
+                    if (!src) {
+                        console.log(chalk.red(`  ✗ Step "${step.name}" input "${inp.name}" references missing step "${inp.source_step_id}"`));
+                        hasUnresolved = true;
+                        errors++;
+                    }
+                    else if (!(src.outputs || []).find((o) => o.name === inp.source_output_name)) {
+                        console.log(chalk.red(`  ✗ Step "${step.name}" input "${inp.name}" references missing output "${inp.source_output_name}" on step "${src.name}"`));
+                        hasUnresolved = true;
+                        errors++;
+                    }
+                }
+                if (inp.pipeline_input) {
+                    if (!pipelineInputs.find((p) => p.name === inp.pipeline_input)) {
+                        console.log(chalk.red(`  ✗ Step "${step.name}" input "${inp.name}" references missing pipeline input "${inp.pipeline_input}"`));
+                        hasUnresolved = true;
+                        errors++;
+                    }
+                }
+            }
+        }
+        if (!hasUnresolved) {
+            console.log(chalk.green('  ✓ All input references resolve'));
+            passed++;
+        }
+        // Cycle detection via topological sort (Kahn's algorithm)
+        const stepIds = steps.map((s) => s.id);
+        const adj = new Map();
+        const inDeg = new Map();
+        for (const sid of stepIds) {
+            adj.set(sid, []);
+            inDeg.set(sid, 0);
+        }
+        for (const step of steps) {
+            for (const inp of step.inputs || []) {
+                if (inp.source_step_id && stepIds.includes(inp.source_step_id)) {
+                    adj.get(inp.source_step_id).push(step.id);
+                    inDeg.set(step.id, (inDeg.get(step.id) || 0) + 1);
+                }
+            }
+        }
+        const queue = [];
+        for (const [id, deg] of inDeg) {
+            if (deg === 0)
+                queue.push(id);
+        }
+        let visited = 0;
+        while (queue.length) {
+            const cur = queue.shift();
+            visited++;
+            for (const next of adj.get(cur) || []) {
+                const nd = inDeg.get(next) - 1;
+                inDeg.set(next, nd);
+                if (nd === 0)
+                    queue.push(next);
+            }
+        }
+        if (visited < stepIds.length) {
+            console.log(chalk.red('  ✗ Cycle detected in step dependencies'));
+            errors++;
+        }
+        else {
+            console.log(chalk.green('  ✓ No cycles detected'));
+            passed++;
+        }
+        // Unreferenced outputs (warning)
+        for (const step of steps) {
+            for (const output of step.outputs || []) {
+                const referenced = steps.some((s) => (s.inputs || []).some((inp) => inp.source_step_id === step.id && inp.source_output_name === output.name));
+                if (!referenced) {
+                    console.log(chalk.yellow(`  ⚠ Step "${step.name}" output "${output.name}" is not consumed by any downstream step`));
+                    warnings++;
+                }
+            }
+        }
+        // Steps with no outputs (info)
+        for (const step of steps) {
+            if (!step.outputs?.length) {
+                console.log(chalk.dim(`  ℹ Step "${step.name}" has no outputs declared`));
+                infos++;
+            }
+        }
+        console.log(`\n${passed} check${passed !== 1 ? 's' : ''} passed${errors ? `, ${errors} error${errors !== 1 ? 's' : ''}` : ''}${warnings ? `, ${warnings} warning${warnings !== 1 ? 's' : ''}` : ''}${infos ? `, ${infos} info` : ''}`);
+        if (errors)
+            process.exit(1);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
 // ── Pipelines ──────────────────────────────────────────────
 const pipelines = program.command('pipelines').alias('pl').description('Pipeline instance commands');
 pipelines
@@ -1535,6 +2043,88 @@ executions
         process.exit(1);
     }
 });
+executions
+    .command('cloudwatch-logs')
+    .alias('cw')
+    .description('Show container logs from CloudWatch')
+    .argument('<id>', 'Execution ID')
+    .option('-l, --limit <n>', 'Max log lines', parseNumber, 100)
+    .option('-f, --follow', 'Poll for new lines until execution completes')
+    .option('--since <duration>', 'Show logs since (e.g., 5m, 1h)')
+    .action(async (id, opts) => {
+    try {
+        const isTerminal = (status) => ['completed', 'failed', 'cancelled'].includes(status);
+        const parseSince = (since) => {
+            const match = since.match(/^(\d+)(m|h|d)$/);
+            if (!match)
+                throw new Error('Invalid --since format. Use e.g. 5m, 1h, 2d');
+            const val = parseInt(match[1], 10);
+            const unit = match[2];
+            const multipliers = { m: 60000, h: 3600000, d: 86400000 };
+            return Date.now() - val * multipliers[unit];
+        };
+        const startTime = opts.since ? String(parseSince(opts.since)) : undefined;
+        const fetchLogs = async (nextToken) => {
+            const params = new URLSearchParams();
+            params.set('limit', String(opts.limit));
+            if (startTime)
+                params.set('startTime', startTime);
+            if (nextToken)
+                params.set('nextToken', nextToken);
+            return await api('GET', `/api/executions/${id}/cloudwatch-logs?${params}`);
+        };
+        const formatLine = (event) => {
+            const ts = new Date(event.timestamp);
+            const hh = String(ts.getHours()).padStart(2, '0');
+            const mm = String(ts.getMinutes()).padStart(2, '0');
+            const ss = String(ts.getSeconds()).padStart(2, '0');
+            return `${chalk.gray(`[${hh}:${mm}:${ss}]`)} ${event.message}`;
+        };
+        // Initial fetch
+        let data = await fetchLogs();
+        if (!data.logs?.length && !opts.follow) {
+            console.log(chalk.yellow(data.message || 'No log events'));
+            return;
+        }
+        for (const event of data.logs || []) {
+            console.log(formatLine(event));
+        }
+        if (!opts.follow)
+            return;
+        // Poll loop
+        let token = data.nextToken;
+        while (true) {
+            await new Promise(r => setTimeout(r, 2000));
+            // Check execution status
+            const exData = await api('GET', `/api/executions/${id}`);
+            const status = exData.execution?.status;
+            // Fetch new logs
+            data = await fetchLogs(token);
+            for (const event of data.logs || []) {
+                console.log(formatLine(event));
+            }
+            token = data.nextToken;
+            if (isTerminal(status)) {
+                // Drain remaining log pages
+                let prevToken;
+                while (token && token !== prevToken) {
+                    prevToken = token;
+                    data = await fetchLogs(token);
+                    for (const event of data.logs || []) {
+                        console.log(formatLine(event));
+                    }
+                    token = data.nextToken;
+                }
+                console.log(chalk.gray(`\n[${status}]`));
+                break;
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
 // ── My Work ─────────────────────────────────────────────────
 program
     .command('my-work')
@@ -1958,14 +2548,18 @@ agentsCmd
         let skipped = 0;
         const norm = (s) => s.toLowerCase().replace(/[-_\s]+/g, ' ').trim();
         for (const file of files) {
-            const name = basename(file, '.md');
+            const raw = readFileSync(resolve(resolvedDir, file), 'utf-8');
+            // Extract name from frontmatter (name: field), fall back to filename
+            const frontmatterMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+            const frontmatter = frontmatterMatch ? frontmatterMatch[1] : '';
+            const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+            const name = nameMatch ? nameMatch[1].trim() : basename(file, '.md');
             const agent = agents.find((a) => norm(a.display_name) === norm(name));
             if (!agent) {
                 console.log(chalk.yellow(`  ⊘ ${name} — no matching agent`));
                 skipped++;
                 continue;
             }
-            const raw = readFileSync(resolve(resolvedDir, file), 'utf-8');
             const body = raw.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '').trim();
             await api('PATCH', `/api/members/${agent.id}/agent-config`, { systemPrompt: body });
             console.log(chalk.green(`  ✓ ${agent.display_name} (${body.length} chars)`));
@@ -2059,5 +2653,25 @@ apiKeys
         process.exit(1);
     }
 });
+// ── Monitor ─────────────────────────────────────────────────
+program
+    .command('monitor')
+    .description('Launch web-based execution monitor (live logs, status)')
+    .option('-p, --port <port>', 'Port to listen on', '4600')
+    .action(async (opts) => {
+    try {
+        const port = parseInt(opts.port, 10);
+        const { startMonitor } = await import('./monitor.js');
+        await startMonitor(port);
+        console.log(chalk.green(`\n  ◆ Fazemos Execution Monitor`));
+        console.log(`  ${chalk.cyan(`http://localhost:${port}`)}`);
+        console.log(chalk.gray(`\n  Proxying API calls with your current auth session`));
+        console.log(chalk.gray(`  Press Ctrl+C to stop\n`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
 program.parse();
 //# sourceMappingURL=index.js.map