Revert "fix(import): auto-disable online eval configs to unlock evaluators during import"

This reverts commit 5839391.

Author: jesseturner21

src/cli/aws/agentcore-control.ts

@@ -458,7 +458,6 @@ export interface GetEvaluatorResult {
   level: string;
   status: string;
   description?: string;
-  lockedForModification?: boolean;
   evaluatorConfig?: {
     llmAsAJudge?: GetEvaluatorLlmConfig;
     codeBased?: GetEvaluatorCodeBasedConfig;
@@ -531,7 +530,6 @@ export async function getEvaluator(options: GetEvaluatorOptions): Promise<GetEva
     level: response.level ?? 'SESSION',
     status: response.status ?? 'UNKNOWN',
     description: response.description,
-    lockedForModification: response.lockedForModification,
     evaluatorConfig,
     tags,
   };

src/cli/commands/import/import-evaluator.ts

@@ -1,12 +1,6 @@
 import type { Evaluator } from '../../../schema';
 import type { EvaluatorSummary, GetEvaluatorResult } from '../../aws/agentcore-control';
-import {
-  getEvaluator,
-  getOnlineEvaluationConfig,
-  listAllEvaluators,
-  listAllOnlineEvaluationConfigs,
-  updateOnlineEvalExecutionStatus,
-} from '../../aws/agentcore-control';
+import { getEvaluator, listAllEvaluators } from '../../aws/agentcore-control';
 import { ANSI } from './constants';
 import { parseAndValidateArn } from './import-utils';
 import { executeResourceImport } from './resource-import';
@@ -54,136 +48,42 @@ export function toEvaluatorSpec(detail: GetEvaluatorResult, localName: string):
   };
 }
 
-/**
- * Create an evaluator descriptor with closed-over state for tracking
- * online eval configs that were temporarily disabled to unlock the evaluator.
- */
-function createEvaluatorDescriptor(): {
-  descriptor: ResourceImportDescriptor<GetEvaluatorResult, EvaluatorSummary>;
-  getDisabledConfigs: () => { configId: string; configName: string }[];
-  getRegion: () => string | undefined;
-} {
-  const disabledConfigs: { configId: string; configName: string }[] = [];
-  let resolvedRegion: string | undefined;
-
-  const descriptor: ResourceImportDescriptor<GetEvaluatorResult, EvaluatorSummary> = {
-    resourceType: 'evaluator',
-    displayName: 'evaluator',
-    logCommand: 'import-evaluator',
-
-    listResources: region => listAllEvaluators({ region }),
-    getDetail: (region, id) => getEvaluator({ region, evaluatorId: id }),
-    parseResourceId: (arn, target) => parseAndValidateArn(arn, 'evaluator', target).resourceId,
-
-    extractSummaryId: s => s.evaluatorId,
-    formatListItem: (s, i) =>
-      `  ${ANSI.dim}[${i + 1}]${ANSI.reset} ${s.evaluatorName} — ${s.status}\n       ${ANSI.dim}${s.evaluatorArn}${ANSI.reset}`,
-    formatAutoSelectMessage: s => `Found 1 evaluator: ${s.evaluatorName} (${s.evaluatorId}). Auto-selecting.`,
-
-    extractDetailName: d => d.evaluatorName,
-    extractDetailArn: d => d.evaluatorArn,
-    readyStatus: 'ACTIVE',
-    extractDetailStatus: d => d.status,
+const evaluatorDescriptor: ResourceImportDescriptor<GetEvaluatorResult, EvaluatorSummary> = {
+  resourceType: 'evaluator',
+  displayName: 'evaluator',
+  logCommand: 'import-evaluator',
 
-    getExistingNames: spec => (spec.evaluators ?? []).map(e => e.name),
-    addToProjectSpec: (detail, localName, spec) => {
-      (spec.evaluators ??= []).push(toEvaluatorSpec(detail, localName));
-    },
+  listResources: region => listAllEvaluators({ region }),
+  getDetail: (region, id) => getEvaluator({ region, evaluatorId: id }),
+  parseResourceId: (arn, target) => parseAndValidateArn(arn, 'evaluator', target).resourceId,
 
-    cfnResourceType: 'AWS::BedrockAgentCore::Evaluator',
-    cfnNameProperty: 'EvaluatorName',
-    cfnIdentifierKey: 'EvaluatorId',
+  extractSummaryId: s => s.evaluatorId,
+  formatListItem: (s, i) =>
+    `  ${ANSI.dim}[${i + 1}]${ANSI.reset} ${s.evaluatorName} — ${s.status}\n       ${ANSI.dim}${s.evaluatorArn}${ANSI.reset}`,
+  formatAutoSelectMessage: s => `Found 1 evaluator: ${s.evaluatorName} (${s.evaluatorId}). Auto-selecting.`,
 
-    buildDeployedStateEntry: (name, id, d) => ({ type: 'evaluator', name, id, arn: d.evaluatorArn }),
-
-    beforeConfigWrite: async ({ detail, target, onProgress, logger }) => {
-      resolvedRegion = target.region;
-      if (!detail.lockedForModification) return;
-
-      logger.startStep('Unlock evaluator');
-      onProgress('Evaluator is locked. Finding referencing online eval configs...');
-
-      const allConfigs = await listAllOnlineEvaluationConfigs({ region: target.region });
-      const enabledConfigs = allConfigs.filter(c => c.executionStatus === 'ENABLED');
-
-      for (const config of enabledConfigs) {
-        const configDetail = await getOnlineEvaluationConfig({
-          region: target.region,
-          configId: config.onlineEvaluationConfigId,
-        });
-        if (configDetail.evaluatorIds?.includes(detail.evaluatorId)) {
-          onProgress(`Disabling online eval config: ${config.onlineEvaluationConfigName}`);
-          await updateOnlineEvalExecutionStatus({
-            region: target.region,
-            onlineEvaluationConfigId: config.onlineEvaluationConfigId,
-            executionStatus: 'DISABLED',
-          });
-          disabledConfigs.push({
-            configId: config.onlineEvaluationConfigId,
-            configName: config.onlineEvaluationConfigName,
-          });
-        }
-      }
+  extractDetailName: d => d.evaluatorName,
+  extractDetailArn: d => d.evaluatorArn,
+  readyStatus: 'ACTIVE',
+  extractDetailStatus: d => d.status,
 
-      if (disabledConfigs.length > 0) {
-        onProgress(`Disabled ${disabledConfigs.length} online eval config(s) to unlock evaluator`);
-      } else {
-        onProgress('Evaluator is locked but no enabled online eval configs reference it');
-      }
-      logger.endStep('success');
-    },
-  };
+  getExistingNames: spec => (spec.evaluators ?? []).map(e => e.name),
+  addToProjectSpec: (detail, localName, spec) => {
+    (spec.evaluators ??= []).push(toEvaluatorSpec(detail, localName));
+  },
 
-  return {
-    descriptor,
-    getDisabledConfigs: () => [...disabledConfigs],
-    getRegion: () => resolvedRegion,
-  };
-}
+  cfnResourceType: 'AWS::BedrockAgentCore::Evaluator',
+  cfnNameProperty: 'EvaluatorName',
+  cfnIdentifierKey: 'EvaluatorId',
 
-/**
- * Re-enable online eval configs that were temporarily disabled during import.
- */
-async function reEnableConfigs(
-  configs: { configId: string; configName: string }[],
-  region: string,
-  onWarn: (msg: string) => void
-): Promise<void> {
-  for (const config of configs) {
-    try {
-      await updateOnlineEvalExecutionStatus({
-        region,
-        onlineEvaluationConfigId: config.configId,
-        executionStatus: 'ENABLED',
-      });
-    } catch (err) {
-      onWarn(
-        `Warning: Could not re-enable online eval config "${config.configName}" (${config.configId}): ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-}
+  buildDeployedStateEntry: (name, id, d) => ({ type: 'evaluator', name, id, arn: d.evaluatorArn }),
+};
 
 /**
  * Handle `agentcore import evaluator`.
  */
 export async function handleImportEvaluator(options: ImportResourceOptions): Promise<ImportResourceResult> {
-  const { descriptor, getDisabledConfigs, getRegion } = createEvaluatorDescriptor();
-
-  try {
-    const result = await executeResourceImport(descriptor, options);
-    return result;
-  } finally {
-    const disabled = getDisabledConfigs();
-    const region = getRegion();
-    if (disabled.length > 0 && region) {
-      await reEnableConfigs(disabled, region, msg => console.warn(msg));
-      const names = disabled.map(c => c.configName).join(', ');
-      console.warn(
-        `\n${ANSI.yellow}Warning:${ANSI.reset} ${disabled.length} online eval config(s) were temporarily disabled to unlock this evaluator and have been re-enabled: ${names}`
-      );
-    }
-  }
+  return executeResourceImport(evaluatorDescriptor, options);
 }
 
 /**