run-aws-code

Instructions

Implementation Reference

• index.ts:132-165 (handler)

  Executes the 'run-aws-code' tool by validating input, configuring AWS credentials and region, wrapping the provided code to ensure it returns a value, executing it in a secure VM context with AWS SDK injected, and returning the JSON-stringified result.

  if (name === "run-aws-code") {
    const { reasoning, code, profileName, region } =
      RunAwsCodeSchema.parse(args);
    if (!selectedProfile && !profileName) {
      return createTextResponse(
        `Please select a profile first using the 'select-profile' tool! Available profiles: ${Object.keys(
          profiles
        ).join(", ")}`
      );
    }
  
    if (profileName) {
      selectedProfileCredentials = await getCredentials(
        profiles[profileName],
        profileName,
        profiles
      );
      selectedProfile = profileName;
      selectedProfileRegion = region || "us-east-1";
    }
  
    AWS.config.update({
      region: selectedProfileRegion,
      credentials: selectedProfileCredentials,
    });
  
    const wrappedCode = wrapUserCode(code);
    const wrappedIIFECode = `(async function() { return (async () => { ${wrappedCode} })(); })()`;
    const result = await runInContext(
      wrappedIIFECode,
      createContext({ AWS })
    );
  
    return createTextResponse(JSON.stringify(result));

• index.ts:55-80 (registration)

  Registers the 'run-aws-code' tool in the ListTools response, defining its name, description, and input schema (including required reasoning and code fields, optional profile and region).

  {
    name: "run-aws-code",
    description: "Run AWS code",
    inputSchema: {
      type: "object",
      properties: {
        reasoning: {
          type: "string",
          description: "The reasoning behind the code",
        },
        code: {
          type: "string",
          description: codePrompt,
        },
        profileName: {
          type: "string",
          description: "Name of the AWS profile to use",
        },
        region: {
          type: "string",
          description: "Region to use (if not provided, us-east-1 is used)",
        },
      },
      required: ["reasoning", "code"],
    },
  },

• index.ts:114-119 (schema)

  Zod validation schema for 'run-aws-code' tool inputs, matching the registered inputSchema.

  const RunAwsCodeSchema = z.object({
    reasoning: z.string(),
    code: z.string(),
    profileName: z.string().optional(),
    region: z.string().optional(),
  });

• index.ts:196-218 (helper)

  Helper function to wrap user-provided code: uses ts-morph to parse TypeScript AST, converts the last expression statement into a return statement if needed, ensuring the code always returns a value.

  function wrapUserCode(userCode: string) {
    const project = new Project({
      useInMemoryFileSystem: true,
    });
    const sourceFile = project.createSourceFile("userCode.ts", userCode);
    const lastStatement = sourceFile.getStatements().pop();
  
    if (
      lastStatement &&
      lastStatement.getKind() === SyntaxKind.ExpressionStatement
    ) {
      const returnStatement = lastStatement.asKind(
        SyntaxKind.ExpressionStatement
      );
      if (returnStatement) {
        const expression = returnStatement.getExpression();
        sourceFile.addStatements(`return ${expression.getText()};`);
        returnStatement.remove();
      }
    }
  
    return sourceFile.getFullText();
  }

• index.ts:16-34 (helper)

  Prompt template assigned to the 'code' input schema's description, providing detailed instructions for generating valid AWS SDK V2 JavaScript code.

  const codePrompt = `Your job is to answer questions about AWS environment by writing Javascript code using AWS SDK V2. The code must be adhering to a few rules:
  - Must be preferring promises over callbacks
  - Think step-by-step before writing the code, approach it logically
  - MUST written in Javascript (NodeJS) using AWS-SDK V2
  - Avoid hardcoded values like ARNs
  - Code written should be as parallel as possible enabling the fastest and the most optimal execution
  - Code should be handling errors gracefully, especially when doing multiple SDK calls (e.g. when mapping over an array). Each error should be handled and logged with a reason, script should continue to run despite errors
  - DO NOT require or import "aws-sdk", it is already available as "AWS" variable
  - Access to 3rd party libraries apart from "aws-sdk" is not allowed or possible
  - For base64 encoding, use btoa() function instead of Buffer (Buffer is not available in this environment)
  - Data returned from AWS-SDK must be returned as JSON containing only the minimal amount of data that is needed to answer the question. All extra data must be filtered out
  - Code MUST "return" a value: string, number, boolean or JSON object. If code does not return anything, it will be considered as FAILED
  - Whenever tool/function call fails, retry it 3 times before giving up with an improved version of the code based on the returned feedback
  - When listing resources, ensure pagination is handled correctly so that all resources are returned
  - Do not include any comments in the code
  - When doing reduce, don't forget to provide an initial value
  - Try to write code that returns as few data as possible to answer without any additional processing required after the code is run
  - This tool can ONLY write code that interacts with AWS. It CANNOT generate charts, tables, graphs, etc. Please use artifacts for that instead
  Be concise, professional and to the point. Do not give generic advice, always reply with detailed & contextual data sourced from the current AWS environment. Assume user always wants to proceed, do not ask for confirmation. I'll tip you $200 if you do this right.`;