feat(multi-environment-deploy): Target-to-environment assignment + write environments on create

agent · agent · commit fdaa0fa616e8 · 2026-05-08T21:16:06.000Z
diff --git a/src/cli/tui/screens/create/AssignTargetsPanel.tsx b/src/cli/tui/screens/create/AssignTargetsPanel.tsx
@@ -0,0 +1,170 @@
+import type { AwsDeploymentTarget, Environments } from '../../../../schema';
+import { AwsTargetsSchema } from '../../../../schema';
+import { Box, Text, useInput } from 'ink';
+import React, { useState } from 'react';
+
+/** Assignment matrix: environment name → set of selected target names. */
+export type EnvironmentAssignments = Record<string, Set<string>>;
+
+export interface AssignTargetsPanelProps {
+  targets: AwsDeploymentTarget[];
+  envNames: string[];
+  /** Optional initial assignments (defaults to empty for every env). */
+  initial?: EnvironmentAssignments;
+  /** Called with the final assignments when the user confirms. */
+  onConfirm: (assignments: EnvironmentAssignments) => void;
+  /** Called when the user backs out of this step. */
+  onCancel: () => void;
+  isActive?: boolean;
+}
+
+/**
+ * Interactive panel: cursor moves through an env-major / target-minor grid.
+ * Space toggles the cell. Enter confirms. Esc cancels. The panel never writes
+ * to disk; the parent wires the resulting matrix into aws-targets.json.
+ */
+export function AssignTargetsPanel({
+  targets,
+  envNames,
+  initial,
+  onConfirm,
+  onCancel,
+  isActive = true,
+}: AssignTargetsPanelProps) {
+  const [assignments, setAssignments] = useState<EnvironmentAssignments>(() => {
+    const seed: EnvironmentAssignments = {};
+    for (const env of envNames) {
+      seed[env] = new Set(initial?.[env] ?? []);
+    }
+    return seed;
+  });
+  const [envCursor, setEnvCursor] = useState(0);
+  const [targetCursor, setTargetCursor] = useState(0);
+
+  const noEnvs = envNames.length === 0;
+  const noTargets = targets.length === 0;
+
+  useInput(
+    (input, key) => {
+      if (noEnvs || noTargets) {
+        if (key.return || key.escape) onCancel();
+        return;
+      }
+      if (key.upArrow) {
+        setTargetCursor(c => (c - 1 + targets.length) % targets.length);
+      } else if (key.downArrow) {
+        setTargetCursor(c => (c + 1) % targets.length);
+      } else if (key.leftArrow) {
+        setEnvCursor(c => (c - 1 + envNames.length) % envNames.length);
+      } else if (key.rightArrow) {
+        setEnvCursor(c => (c + 1) % envNames.length);
+      } else if (input === ' ' || input === 'x' || input === 'X') {
+        const env = envNames[envCursor]!;
+        const target = targets[targetCursor]!;
+        setAssignments(prev => {
+          const next = { ...prev };
+          const current = new Set(next[env] ?? []);
+          if (current.has(target.name)) current.delete(target.name);
+          else current.add(target.name);
+          next[env] = current;
+          return next;
+        });
+      } else if (key.return) {
+        onConfirm(assignments);
+      } else if (key.escape) {
+        onCancel();
+      }
+    },
+    { isActive }
+  );
+
+  if (noEnvs) {
+    return (
+      <Box flexDirection="column">
+        <Text dimColor>(No environments to assign — skipping target assignment.)</Text>
+        <Text dimColor>Press Enter to continue.</Text>
+      </Box>
+    );
+  }
+  if (noTargets) {
+    return (
+      <Box flexDirection="column">
+        <Text dimColor>(No targets defined yet — environments will be created without target assignments.)</Text>
+        <Text dimColor>Add targets later via aws-targets.json. Press Enter to continue.</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Assign targets to environments:</Text>
+      <Box flexDirection="row" marginTop={1}>
+        <Box width={20} flexDirection="column">
+          <Text bold>Target \\ Env</Text>
+          {targets.map((t, idx) => (
+            <Text key={t.name} color={idx === targetCursor ? 'cyan' : undefined}>
+              {idx === targetCursor ? '> ' : '  '}
+              {t.name}
+            </Text>
+          ))}
+        </Box>
+        {envNames.map((env, envIdx) => {
+          const assigned = assignments[env] ?? new Set<string>();
+          return (
+            <Box key={env} width={12} flexDirection="column">
+              <Text bold color={envIdx === envCursor ? 'cyan' : undefined}>
+                {env}
+              </Text>
+              {targets.map((t, tIdx) => {
+                const isCursor = envIdx === envCursor && tIdx === targetCursor;
+                const checked = assigned.has(t.name);
+                return (
+                  <Text key={t.name} color={isCursor ? 'cyan' : undefined}>
+                    {isCursor ? '> ' : '  '}
+                    {checked ? '[x]' : '[ ]'}
+                  </Text>
+                );
+              })}
+            </Box>
+          );
+        })}
+      </Box>
+      <Box marginTop={1}>
+        <Text dimColor>↑/↓ row · ←/→ env · Space toggle · Enter confirm · Esc cancel</Text>
+      </Box>
+    </Box>
+  );
+}
+
+/**
+ * Build the `environments` section of aws-targets.json from an assignment
+ * matrix. Drops environments with zero targets so the resulting object always
+ * passes EnvironmentSchema's `min(1)` rule. Returns `undefined` when no
+ * environment ends up with any targets — that signals the caller should omit
+ * the `environments` field entirely.
+ */
+export function buildEnvironmentsSection(assignments: EnvironmentAssignments): Environments | undefined {
+  const result: Environments = {};
+  for (const [name, members] of Object.entries(assignments)) {
+    const targets = Array.from(members).filter(Boolean);
+    if (targets.length === 0) continue;
+    result[name] = { targets };
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+/**
+ * Build a complete AwsTargets payload (object form) from a target list and an
+ * assignment matrix, validated against AwsTargetsSchema (incl. cross-validation
+ * that every environment target ref exists in `targets[]`). Throws ZodError
+ * when invalid.
+ */
+export function buildAwsTargetsConfig(
+  targets: AwsDeploymentTarget[],
+  assignments: EnvironmentAssignments
+): { targets: AwsDeploymentTarget[]; environments?: Environments } {
+  const environments = buildEnvironmentsSection(assignments);
+  const candidate = { targets, ...(environments ? { environments } : {}) };
+  // Run the schema (incl. superRefine) so callers get a guaranteed-valid object.
+  return AwsTargetsSchema.parse(candidate);
+}
diff --git a/src/cli/tui/screens/create/__tests__/AssignTargetsPanel.test.tsx b/src/cli/tui/screens/create/__tests__/AssignTargetsPanel.test.tsx
@@ -0,0 +1,187 @@
+import type { AwsDeploymentTarget } from '../../../../../schema';
+import { AwsTargetsSchema } from '../../../../../schema';
+import {
+  AssignTargetsPanel,
+  type EnvironmentAssignments,
+  buildAwsTargetsConfig,
+  buildEnvironmentsSection,
+} from '../AssignTargetsPanel';
+import { render } from 'ink-testing-library';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import React from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const flush = (ms = 50) => new Promise(resolve => setTimeout(resolve, ms));
+
+const targetA: AwsDeploymentTarget = { name: 'dev-a', account: '111111111111', region: 'us-west-2' };
+const targetB: AwsDeploymentTarget = { name: 'dev-b', account: '222222222222', region: 'us-east-1' };
+const targetC: AwsDeploymentTarget = { name: 'prod-a', account: '333333333333', region: 'us-east-1' };
+
+describe('AssignTargetsPanel (UI)', () => {
+  it('renders header columns for each environment and rows for each target', () => {
+    const { lastFrame } = render(
+      <AssignTargetsPanel
+        targets={[targetA, targetB, targetC]}
+        envNames={['dev', 'prod']}
+        onConfirm={() => undefined}
+        onCancel={() => undefined}
+      />
+    );
+    const frame = lastFrame() ?? '';
+    expect(frame).toMatch(/Assign targets to environments:/);
+    expect(frame).toMatch(/dev/);
+    expect(frame).toMatch(/prod/);
+    expect(frame).toMatch(/dev-a/);
+    expect(frame).toMatch(/dev-b/);
+    expect(frame).toMatch(/prod-a/);
+  });
+
+  it('toggles the cell at the cursor with Space and surfaces it to onConfirm', async () => {
+    const onConfirm = vi.fn();
+    const { stdin } = render(
+      <AssignTargetsPanel
+        targets={[targetA, targetB]}
+        envNames={['dev', 'prod']}
+        onConfirm={onConfirm}
+        onCancel={() => undefined}
+      />
+    );
+    // Cursor starts at (env=dev, target=dev-a). Toggle on.
+    stdin.write(' ');
+    await flush();
+    // ↓ to dev-b, toggle on.
+    stdin.write('\u001B[B');
+    await flush();
+    stdin.write(' ');
+    await flush();
+    // → to prod, ↑ back to dev-a... easier: from dev-b, → to prod (still at dev-b row), toggle on.
+    stdin.write('\u001B[C');
+    await flush();
+    stdin.write(' ');
+    await flush();
+    stdin.write('\r');
+    await flush();
+    expect(onConfirm).toHaveBeenCalledTimes(1);
+    const result = onConfirm.mock.calls[0]![0] as EnvironmentAssignments;
+    expect(Array.from(result.dev ?? [])).toEqual(['dev-a', 'dev-b']);
+    expect(Array.from(result.prod ?? [])).toEqual(['dev-b']);
+  });
+
+  it('cancels via Esc', async () => {
+    const onCancel = vi.fn();
+    const onConfirm = vi.fn();
+    const { stdin } = render(
+      <AssignTargetsPanel targets={[targetA]} envNames={['dev']} onConfirm={onConfirm} onCancel={onCancel} />
+    );
+    stdin.write('\u001B');
+    await flush();
+    expect(onCancel).toHaveBeenCalledTimes(1);
+    expect(onConfirm).not.toHaveBeenCalled();
+  });
+
+  it('renders an empty-targets fallback message when no targets are defined', () => {
+    const { lastFrame } = render(
+      <AssignTargetsPanel
+        targets={[]}
+        envNames={['dev', 'prod']}
+        onConfirm={() => undefined}
+        onCancel={() => undefined}
+      />
+    );
+    expect(lastFrame() ?? '').toMatch(/No targets defined yet/);
+  });
+
+  it('renders a no-environments fallback when envNames is empty', () => {
+    const { lastFrame } = render(
+      <AssignTargetsPanel targets={[targetA]} envNames={[]} onConfirm={() => undefined} onCancel={() => undefined} />
+    );
+    expect(lastFrame() ?? '').toMatch(/No environments to assign/);
+  });
+});
+
+describe('buildEnvironmentsSection (serialization)', () => {
+  it('serializes assignments into the schema-shaped environments map', () => {
+    const assignments: EnvironmentAssignments = {
+      dev: new Set(['dev-a', 'dev-b']),
+      prod: new Set(['prod-a']),
+    };
+    expect(buildEnvironmentsSection(assignments)).toEqual({
+      dev: { targets: ['dev-a', 'dev-b'] },
+      prod: { targets: ['prod-a'] },
+    });
+  });
+
+  it('drops environments with zero assigned targets', () => {
+    const assignments: EnvironmentAssignments = {
+      dev: new Set(['dev-a']),
+      empty: new Set(),
+    };
+    expect(buildEnvironmentsSection(assignments)).toEqual({
+      dev: { targets: ['dev-a'] },
+    });
+  });
+
+  it('returns undefined when every environment is empty', () => {
+    const assignments: EnvironmentAssignments = { dev: new Set(), prod: new Set() };
+    expect(buildEnvironmentsSection(assignments)).toBeUndefined();
+  });
+});
+
+describe('buildAwsTargetsConfig (schema-validated)', () => {
+  it('produces an object that AwsTargetsSchema accepts (incl. cross-validation)', () => {
+    const config = buildAwsTargetsConfig([targetA, targetB, targetC], {
+      dev: new Set(['dev-a', 'dev-b']),
+      prod: new Set(['prod-a']),
+    });
+    // buildAwsTargetsConfig internally calls AwsTargetsSchema.parse, so we
+    // re-validate here as a sanity check that the returned object is stable.
+    const reparsed = AwsTargetsSchema.parse(config);
+    expect(reparsed.targets).toHaveLength(3);
+    expect(reparsed.environments?.dev?.targets).toEqual(['dev-a', 'dev-b']);
+    expect(reparsed.environments?.prod?.targets).toEqual(['prod-a']);
+  });
+
+  it('omits the environments field when no env has any targets', () => {
+    const config = buildAwsTargetsConfig([targetA], { dev: new Set() });
+    expect(config.environments).toBeUndefined();
+    expect(() => AwsTargetsSchema.parse(config)).not.toThrow();
+  });
+
+  it('throws on cross-validation when an environment references an unknown target', () => {
+    expect(() =>
+      buildAwsTargetsConfig([targetA], {
+        dev: new Set(['dev-a', 'missing-target']),
+      })
+    ).toThrowError(/unknown target "missing-target"/);
+  });
+
+  it('round-trips through aws-targets.json on disk and re-validates with AwsTargetsSchema', async () => {
+    const tmpDir = path.join(os.tmpdir(), `assign-targets-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await mkdir(tmpDir, { recursive: true });
+    try {
+      const filePath = path.join(tmpDir, 'aws-targets.json');
+      const config = buildAwsTargetsConfig([targetA, targetB, targetC], {
+        dev: new Set(['dev-a', 'dev-b']),
+        prod: new Set(['prod-a']),
+      });
+      await writeFile(filePath, JSON.stringify(config, null, 2));
+
+      const raw = await readFile(filePath, 'utf8');
+      const parsed = AwsTargetsSchema.parse(JSON.parse(raw));
+      expect(parsed.targets.map(t => t.name)).toEqual(['dev-a', 'dev-b', 'prod-a']);
+      expect(Object.keys(parsed.environments ?? {})).toEqual(['dev', 'prod']);
+    } finally {
+      await rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+beforeEach(() => {
+  // No-op; placeholder for symmetry with other test files.
+});
diff --git a/src/cli/tui/screens/create/index.ts b/src/cli/tui/screens/create/index.ts
@@ -6,3 +6,10 @@ export {
   type EnvironmentPreset,
   type EnvironmentStepProps,
 } from './EnvironmentStep';
+export {
+  AssignTargetsPanel,
+  buildAwsTargetsConfig,
+  buildEnvironmentsSection,
+  type AssignTargetsPanelProps,
+  type EnvironmentAssignments,
+} from './AssignTargetsPanel';
