chore: merge main into preview

notgitika · notgitika · commit de28f218c139 · 2026-05-13T14:34:15.000-04:00
# Conflicts:
#	src/cli/commands/deploy/command.tsx
diff --git a/src/cli/commands/deploy/__tests__/utils.test.ts b/src/cli/commands/deploy/__tests__/utils.test.ts
@@ -0,0 +1,54 @@
+import type { AgentCoreProjectSpec } from '../../../../schema';
+import { computeDeployAttrs } from '../utils.js';
+import { describe, expect, it } from 'vitest';
+
+describe('computeDeployAttrs', () => {
+  it('computes counts from a populated spec', () => {
+    const projectSpec = {
+      runtimes: [{}, {}],
+      memories: [{}],
+      credentials: [{}, {}, {}],
+      evaluators: [{}],
+      onlineEvalConfigs: [{}, {}],
+      agentCoreGateways: [{ targets: [{}, {}] }, { targets: [{}] }],
+      policyEngines: [{ policies: [{}, {}] }, { policies: [{}] }],
+    } as unknown as Partial<AgentCoreProjectSpec>;
+
+    expect(computeDeployAttrs(projectSpec, 'diff')).toEqual({
+      runtime_count: 2,
+      memory_count: 1,
+      credential_count: 3,
+      evaluator_count: 1,
+      online_eval_count: 2,
+      gateway_count: 2,
+      gateway_target_count: 3,
+      policy_engine_count: 2,
+      policy_count: 3,
+      mode: 'diff',
+    });
+  });
+
+  it('returns zeros for empty spec', () => {
+    expect(computeDeployAttrs({}, 'deploy')).toEqual({
+      runtime_count: 0,
+      memory_count: 0,
+      credential_count: 0,
+      evaluator_count: 0,
+      online_eval_count: 0,
+      gateway_count: 0,
+      gateway_target_count: 0,
+      policy_engine_count: 0,
+      policy_count: 0,
+      mode: 'deploy',
+    });
+  });
+
+  it('handles dry-run mode', () => {
+    const projectSpec = { runtimes: [{}] } as unknown as Partial<AgentCoreProjectSpec>;
+    const attrs = computeDeployAttrs(projectSpec, 'dry-run');
+
+    expect(attrs.runtime_count).toBe(1);
+    expect(attrs.memory_count).toBe(0);
+    expect(attrs.mode).toBe('dry-run');
+  });
+});
diff --git a/src/cli/commands/deploy/command.tsx b/src/cli/commands/deploy/command.tsx
@@ -1,15 +1,19 @@
+import { ConfigIO, serializeResult } from '../../../lib';
 import { getErrorMessage } from '../../errors';
+import { withCommandRunTelemetry } from '../../telemetry/cli-command-run.js';
 import { COMMAND_DESCRIPTIONS } from '../../tui/copy';
 import { requireProject, requireTTY } from '../../tui/guards';
 import { DeployScreen } from '../../tui/screens/deploy/DeployScreen';
 import { handleDeploy } from './actions';
-import { createSpinnerProgress } from './progress';
-import type { DeployOptions } from './types';
+import type { DeployOptions, DeployResult } from './types';
+import { DEFAULT_DEPLOY_ATTRS, computeDeployAttrs } from './utils';
 import { validateDeployOptions } from './validate';
 import type { Command } from '@commander-js/extra-typings';
 import { Text, render } from 'ink';
 import React from 'react';
 
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
 function handleDeployTUI(options: { autoConfirm?: boolean; diffMode?: boolean } = {}): void {
   requireProject();
 
@@ -37,8 +41,69 @@ async function handleDeployCLI(options: DeployOptions): Promise<void> {
     process.exit(1);
   }
 
-  const progressUtil = options.progress ? createSpinnerProgress() : undefined;
-  const onProgress = progressUtil?.onProgress;
+  // Compute attrs upfront from project spec (available before deploy)
+  const mode = options.diff ? 'diff' : options.plan ? 'dry-run' : 'deploy';
+  const attrs = await new ConfigIO()
+    .readProjectSpec()
+    .then(spec => computeDeployAttrs(spec, mode))
+    .catch(() => ({ ...DEFAULT_DEPLOY_ATTRS, mode }) as const);
+
+  const { deployResult } = await withCommandRunTelemetry('deploy', attrs, async () => {
+    const result = await executeDeploy(options).catch(
+      (e): DeployResult => ({ success: false, error: e instanceof Error ? e : new Error(getErrorMessage(e)) })
+    );
+    if (!result.success) {
+      return { success: false as const, error: result.error, deployResult: result };
+    }
+    return { success: true as const, deployResult: result };
+  });
+
+  // ALL output happens here, after telemetry
+  if (!deployResult.success) {
+    if (options.json) {
+      console.log(JSON.stringify(serializeResult(deployResult)));
+    } else {
+      console.error(deployResult.error.message);
+      if (deployResult.logPath) {
+        console.error(`Log: ${deployResult.logPath}`);
+      }
+    }
+    process.exit(1);
+  }
+
+  printDeployResult(deployResult, options);
+
+  if (deployResult.postDeployWarnings && deployResult.postDeployWarnings.length > 0) {
+    process.exit(2);
+  }
+  process.exit(0);
+}
+
+async function executeDeploy(options: DeployOptions): Promise<DeployResult> {
+  let spinner: NodeJS.Timeout | undefined;
+
+  // Progress callback for --progress mode
+  const onProgress = options.progress
+    ? (step: string, status: 'start' | 'success' | 'error') => {
+        if (spinner) {
+          clearInterval(spinner);
+          process.stdout.write('\r\x1b[K'); // Clear line
+        }
+
+        if (status === 'start') {
+          let i = 0;
+          process.stdout.write(`${SPINNER_FRAMES[0]} ${step}...`);
+          spinner = setInterval(() => {
+            i = (i + 1) % SPINNER_FRAMES.length;
+            process.stdout.write(`\r${SPINNER_FRAMES[i]} ${step}...`);
+          }, 80);
+        } else if (status === 'success') {
+          console.log(`✓ ${step}`);
+        } else {
+          console.log(`✗ ${step}`);
+        }
+      }
+    : undefined;
 
   const onResourceEvent = options.verbose
     ? (message: string) => {
@@ -56,57 +121,57 @@ async function handleDeployCLI(options: DeployOptions): Promise<void> {
     onResourceEvent,
   });
 
-  progressUtil?.cleanup();
+  if (spinner) {
+    clearInterval(spinner);
+    process.stdout.write('\r\x1b[K');
+  }
+
+  return result;
+}
 
+function printDeployResult(result: DeployResult & { success: true }, options: DeployOptions): void {
   if (options.json) {
     console.log(JSON.stringify(result));
-  } else if (result.success) {
-    if (options.diff) {
-      console.log(`\n✓ Diff complete for '${result.targetName}' (stack: ${result.stackName})`);
-    } else if (options.plan) {
-      console.log(`\n✓ Dry run complete for '${result.targetName}' (stack: ${result.stackName})`);
-      console.log('\nRun `agentcore deploy` to deploy.');
-    } else {
-      console.log(`\n✓ Deployed to '${result.targetName}' (stack: ${result.stackName})`);
+    return;
+  }
 
-      // Show stack outputs in non-JSON mode
-      if (result.outputs && Object.keys(result.outputs).length > 0) {
-        console.log('\nOutputs:');
-        for (const [key, value] of Object.entries(result.outputs)) {
-          console.log(`  ${key}: ${value}`);
-        }
-      }
+  if (options.diff) {
+    console.log(`\n✓ Diff complete for '${result.targetName}' (stack: ${result.stackName})`);
+  } else if (options.plan) {
+    console.log(`\n✓ Dry run complete for '${result.targetName}' (stack: ${result.stackName})`);
+    console.log('\nRun `agentcore deploy` to deploy.');
+  } else {
+    console.log(`\n✓ Deployed to '${result.targetName}' (stack: ${result.stackName})`);
 
-      if (result.postDeployWarnings && result.postDeployWarnings.length > 0) {
-        console.log('\n⚠ Post-deploy warnings:');
-        for (const warning of result.postDeployWarnings) {
-          console.log(`  ${warning}`);
-        }
+    // Show stack outputs in non-JSON mode
+    if (result.outputs && Object.keys(result.outputs).length > 0) {
+      console.log('\nOutputs:');
+      for (const [key, value] of Object.entries(result.outputs)) {
+        console.log(`  ${key}: ${value}`);
       }
+    }
 
-      if (result.notes && result.notes.length > 0) {
-        for (const note of result.notes) {
-          console.log(`\nNote: ${note}`);
-        }
+    if (result.postDeployWarnings && result.postDeployWarnings.length > 0) {
+      console.log('\n⚠ Post-deploy warnings:');
+      for (const warning of result.postDeployWarnings) {
+        console.log(`  ${warning}`);
       }
+    }
 
-      if (result.nextSteps && result.nextSteps.length > 0) {
-        console.log(`Next: ${result.nextSteps.join(' | ')}`);
+    if (result.notes && result.notes.length > 0) {
+      for (const note of result.notes) {
+        console.log(`\nNote: ${note}`);
       }
     }
 
-    if (result.logPath) {
-      console.log(`\nLog: ${result.logPath}`);
-    }
-  } else {
-    console.error(result.error);
-    if (result.logPath) {
-      console.error(`Log: ${result.logPath}`);
+    if (result.nextSteps && result.nextSteps.length > 0) {
+      console.log(`Next: ${result.nextSteps.join(' | ')}`);
     }
   }
 
-  const hasPostDeployWarnings = result.success && result.postDeployWarnings && result.postDeployWarnings.length > 0;
-  process.exit(result.success ? (hasPostDeployWarnings ? 2 : 0) : 1);
+  if (result.logPath) {
+    console.log(`\nLog: ${result.logPath}`);
+  }
 }
 
 export const registerDeploy = (program: Command) => {
diff --git a/src/cli/commands/deploy/utils.ts b/src/cli/commands/deploy/utils.ts
@@ -0,0 +1,33 @@
+import type { AgentCoreProjectSpec } from '../../../schema';
+
+export type DeployMode = 'deploy' | 'dry-run' | 'diff';
+
+export const DEFAULT_DEPLOY_ATTRS = {
+  runtime_count: 0,
+  memory_count: 0,
+  credential_count: 0,
+  evaluator_count: 0,
+  online_eval_count: 0,
+  gateway_count: 0,
+  gateway_target_count: 0,
+  policy_engine_count: 0,
+  policy_count: 0,
+  mode: 'deploy' as DeployMode,
+};
+
+export function computeDeployAttrs(projectSpec: Partial<AgentCoreProjectSpec>, mode: DeployMode) {
+  const gateways = projectSpec.agentCoreGateways ?? [];
+  const policyEngines = projectSpec.policyEngines ?? [];
+  return {
+    runtime_count: (projectSpec.runtimes ?? []).length,
+    memory_count: (projectSpec.memories ?? []).length,
+    credential_count: (projectSpec.credentials ?? []).length,
+    evaluator_count: (projectSpec.evaluators ?? []).length,
+    online_eval_count: (projectSpec.onlineEvalConfigs ?? []).length,
+    gateway_count: gateways.length,
+    gateway_target_count: gateways.reduce((sum, g) => sum + (g.targets ?? []).length, 0),
+    policy_engine_count: policyEngines.length,
+    policy_count: policyEngines.reduce((sum, pe) => sum + (pe.policies ?? []).length, 0),
+    mode,
+  };
+}
diff --git a/src/cli/telemetry/schemas/__tests__/command-run.test.ts b/src/cli/telemetry/schemas/__tests__/command-run.test.ts
@@ -47,7 +47,7 @@ describe('COMMAND_SCHEMAS', () => {
       gateway_target_count: 3,
       policy_engine_count: 0,
       policy_count: 0,
-      has_diff: true,
+      mode: 'diff',
     };
     expect(COMMAND_SCHEMAS.deploy.parse(attrs)).toEqual(attrs);
   });
@@ -64,7 +64,7 @@ describe('COMMAND_SCHEMAS', () => {
         gateway_target_count: 0,
         policy_engine_count: 0,
         policy_count: 0,
-        has_diff: false,
+        mode: 'deploy',
       })
     ).toThrow();
   });
@@ -81,7 +81,7 @@ describe('COMMAND_SCHEMAS', () => {
         gateway_target_count: 0,
         policy_engine_count: 0,
         policy_count: 0,
-        has_diff: false,
+        mode: 'deploy',
       })
     ).toThrow();
   });
diff --git a/src/cli/telemetry/schemas/command-run.ts b/src/cli/telemetry/schemas/command-run.ts
@@ -100,7 +100,7 @@ const DeployAttrs = safeSchema({
   gateway_target_count: Count,
   policy_engine_count: Count,
   policy_count: Count,
-  has_diff: z.boolean(),
+  mode: z.enum(['deploy', 'dry-run', 'diff']),
 });
 
 const DevAttrs = safeSchema({
diff --git a/src/cli/tui/screens/deploy/useDeployFlow.ts b/src/cli/tui/screens/deploy/useDeployFlow.ts
