@slates-integrations/aws-lambda 0.2.0-rc.6

package/src/tools/manage-runtime-management.ts

@@ -0,0 +1,85 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { lambdaServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let manageRuntimeManagement = SlateTool.create(spec, {
+  name: 'Manage Runtime Management',
+  key: 'manage_runtime_management',
+  description: `Get or set the runtime update mode for a Lambda function version. Runtime management controls whether Lambda applies runtime patches automatically, on function updates, or pins a manual runtime version ARN.`,
+  instructions: [
+    'Use action "get" to read the current runtime update mode.',
+    'Use action "set" with updateRuntimeOn. Manual mode also requires runtimeVersionArn.'
+  ]
+})
+  .input(
+    z.object({
+      action: z.enum(['get', 'set']).describe('Operation to perform'),
+      functionName: z.string().describe('Function name or ARN'),
+      qualifier: z
+        .string()
+        .optional()
+        .describe('Function version. Defaults to $LATEST when omitted'),
+      updateRuntimeOn: z
+        .enum(['Auto', 'Manual', 'FunctionUpdate'])
+        .optional()
+        .describe('Runtime update mode to set'),
+      runtimeVersionArn: z
+        .string()
+        .optional()
+        .describe('Runtime version ARN required when updateRuntimeOn is Manual')
+    })
+  )
+  .output(
+    z.object({
+      functionArn: z.string().optional().describe('Function ARN'),
+      updateRuntimeOn: z.string().optional().describe('Runtime update mode'),
+      runtimeVersionArn: z
+        .string()
+        .nullable()
+        .optional()
+        .describe('Pinned runtime version ARN when manual mode is configured')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action, functionName, qualifier } = ctx.input;
+
+    if (action === 'get') {
+      let result = await client.getRuntimeManagementConfig(functionName, qualifier);
+      return {
+        output: {
+          functionArn: result.FunctionArn,
+          updateRuntimeOn: result.UpdateRuntimeOn,
+          runtimeVersionArn: result.RuntimeVersionArn ?? null
+        },
+        message: `Runtime management for **${functionName}** is **${result.UpdateRuntimeOn}**.`
+      };
+    }
+
+    if (!ctx.input.updateRuntimeOn) {
+      throw lambdaServiceError('updateRuntimeOn is required for set.');
+    }
+    if (ctx.input.updateRuntimeOn === 'Manual' && !ctx.input.runtimeVersionArn) {
+      throw lambdaServiceError('runtimeVersionArn is required when updateRuntimeOn is Manual.');
+    }
+
+    let params: Record<string, any> = {
+      UpdateRuntimeOn: ctx.input.updateRuntimeOn
+    };
+    if (ctx.input.runtimeVersionArn) {
+      params['RuntimeVersionArn'] = ctx.input.runtimeVersionArn;
+    }
+
+    let result = await client.putRuntimeManagementConfig(functionName, params, qualifier);
+    return {
+      output: {
+        functionArn: result.FunctionArn,
+        updateRuntimeOn: result.UpdateRuntimeOn,
+        runtimeVersionArn: result.RuntimeVersionArn ?? null
+      },
+      message: `Set runtime management for **${functionName}** to **${result.UpdateRuntimeOn}**.`
+    };
+  })
+  .build();

package/src/tools/manage-tags.ts

@@ -0,0 +1,72 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { lambdaServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let manageTags = SlateTool.create(spec, {
+  name: 'Manage Tags',
+  key: 'manage_tags',
+  description: `List, add, or remove tags on a Lambda function. Tags are key-value pairs used for organization, cost allocation, and access control. Provide the full function ARN for tag operations.`,
+  instructions: [
+    'Use **action** "list" to view tags, "add" to set tags, or "remove" to delete tag keys.',
+    'The resourceArn must be the full function ARN (e.g., arn:aws:lambda:us-east-1:123456789012:function:my-func).'
+  ]
+})
+  .input(
+    z.object({
+      action: z.enum(['list', 'add', 'remove']).describe('Operation to perform'),
+      resourceArn: z.string().describe('Full ARN of the Lambda resource'),
+      tags: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Tags to add as key-value pairs (for add action)'),
+      tagKeys: z
+        .array(z.string())
+        .optional()
+        .describe('Tag keys to remove (for remove action)')
+    })
+  )
+  .output(
+    z.object({
+      tags: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Current tags on the resource'),
+      updated: z.boolean().optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action, resourceArn } = ctx.input;
+
+    if (action === 'list') {
+      let result = await client.listTags(resourceArn);
+      return {
+        output: { tags: result.Tags || {} },
+        message: `Found **${Object.keys(result.Tags || {}).length}** tag(s).`
+      };
+    }
+
+    if (action === 'add') {
+      if (!ctx.input.tags || Object.keys(ctx.input.tags).length === 0) {
+        throw lambdaServiceError('tags are required for the add action');
+      }
+      await client.tagResource(resourceArn, ctx.input.tags);
+      return {
+        output: { updated: true, tags: ctx.input.tags },
+        message: `Added **${Object.keys(ctx.input.tags).length}** tag(s) to the resource.`
+      };
+    }
+
+    // remove
+    if (!ctx.input.tagKeys || ctx.input.tagKeys.length === 0) {
+      throw lambdaServiceError('tagKeys are required for the remove action');
+    }
+    await client.untagResource(resourceArn, ctx.input.tagKeys);
+    return {
+      output: { updated: true },
+      message: `Removed **${ctx.input.tagKeys.length}** tag(s) from the resource.`
+    };
+  })
+  .build();

package/src/tools/publish-version.ts

@@ -0,0 +1,83 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let publishVersion = SlateTool.create(spec, {
+  name: 'Publish Version',
+  key: 'publish_version',
+  description: `Publish an immutable version from the current \`$LATEST\` code and configuration. Optionally list all published versions of a function by setting **listOnly** to true.`,
+  instructions: [
+    'Use codeSha256 to ensure you are publishing the expected code revision.',
+    'Published versions are immutable and can be referenced by aliases.'
+  ]
+})
+  .input(
+    z.object({
+      functionName: z.string().describe('Function name or ARN'),
+      listOnly: z
+        .boolean()
+        .optional()
+        .describe('Set to true to only list versions without publishing'),
+      description: z.string().optional().describe('Version description'),
+      codeSha256: z
+        .string()
+        .optional()
+        .describe('Expected SHA256 hash of the code to publish (validation)')
+    })
+  )
+  .output(
+    z.object({
+      version: z.string().optional().describe('Published version number'),
+      functionArn: z.string().optional().describe('Version-specific ARN'),
+      description: z.string().optional().describe('Version description'),
+      codeSha256: z.string().optional().describe('SHA256 of the published code'),
+      versions: z
+        .array(
+          z.object({
+            version: z.string().optional(),
+            functionArn: z.string().optional(),
+            description: z.string().optional(),
+            lastModified: z.string().optional(),
+            runtime: z.string().optional()
+          })
+        )
+        .optional()
+        .describe('List of versions (when listOnly is true)')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+
+    if (ctx.input.listOnly) {
+      let result = await client.listVersionsByFunction(ctx.input.functionName);
+      let versions = (result.Versions || []).map((v: any) => ({
+        version: v.Version,
+        functionArn: v.FunctionArn,
+        description: v.Description,
+        lastModified: v.LastModified,
+        runtime: v.Runtime
+      }));
+      return {
+        output: { versions },
+        message: `Found **${versions.length}** version(s) for **${ctx.input.functionName}**.`
+      };
+    }
+
+    let params: Record<string, any> = {};
+    if (ctx.input.description) params['Description'] = ctx.input.description;
+    if (ctx.input.codeSha256) params['CodeSha256'] = ctx.input.codeSha256;
+
+    let result = await client.publishVersion(ctx.input.functionName, params);
+
+    return {
+      output: {
+        version: result.Version,
+        functionArn: result.FunctionArn,
+        description: result.Description,
+        codeSha256: result.CodeSha256
+      },
+      message: `Published version **${result.Version}** for **${ctx.input.functionName}**.`
+    };
+  })
+  .build();

package/src/tools/update-function.ts

@@ -0,0 +1,156 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { lambdaServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let updateFunction = SlateTool.create(spec, {
+  name: 'Update Function',
+  key: 'update_function',
+  description: `Update a Lambda function's code and/or configuration. Provide **code** fields to update the deployment package, or **configuration** fields to modify settings like runtime, handler, memory, timeout, environment variables, layers, and VPC. Both can be updated in a single call.`,
+  instructions: [
+    'Code and configuration updates are applied separately via two API calls if both are provided.',
+    'Environment variables replace the entire set — provide all variables you want to keep.'
+  ]
+})
+  .input(
+    z.object({
+      functionName: z.string().describe('Function name or ARN'),
+      code: z
+        .object({
+          s3Bucket: z
+            .string()
+            .optional()
+            .describe('S3 bucket containing the new code package'),
+          s3Key: z.string().optional().describe('S3 object key'),
+          s3ObjectVersion: z.string().optional().describe('S3 object version'),
+          imageUri: z.string().optional().describe('Container image URI from ECR'),
+          zipFile: z.string().optional().describe('Base64-encoded ZIP file content'),
+          publish: z
+            .boolean()
+            .optional()
+            .describe('Publish a new version after updating code'),
+          architectures: z
+            .array(z.enum(['x86_64', 'arm64']))
+            .optional()
+            .describe('Target architecture')
+        })
+        .optional()
+        .describe('New function code'),
+      configuration: z
+        .object({
+          role: z.string().optional().describe('New execution role ARN'),
+          runtime: z.string().optional().describe('New runtime'),
+          handler: z.string().optional().describe('New handler'),
+          description: z.string().optional().describe('New description'),
+          timeout: z.number().optional().describe('New timeout in seconds'),
+          memorySize: z.number().optional().describe('New memory size in MB'),
+          environment: z
+            .record(z.string(), z.string())
+            .optional()
+            .describe('New environment variables (replaces existing)'),
+          layers: z
+            .array(z.string())
+            .optional()
+            .describe('New layer ARNs (replaces existing)'),
+          ephemeralStorageSize: z.number().optional().describe('New /tmp storage in MB'),
+          tracingMode: z
+            .enum(['Active', 'PassThrough'])
+            .optional()
+            .describe('X-Ray tracing mode'),
+          vpcSubnetIds: z.array(z.string()).optional().describe('VPC subnet IDs'),
+          vpcSecurityGroupIds: z
+            .array(z.string())
+            .optional()
+            .describe('VPC security group IDs')
+        })
+        .optional()
+        .describe('Configuration changes')
+    })
+  )
+  .output(
+    z.object({
+      functionName: z.string().describe('Name of the updated function'),
+      functionArn: z.string().describe('ARN of the updated function'),
+      runtime: z.string().optional().describe('Runtime after update'),
+      state: z.string().optional().describe('Function state after update'),
+      version: z.string().optional().describe('Published version (if code was published)'),
+      lastModified: z.string().optional().describe('Last modified timestamp'),
+      codeUpdated: z.boolean().describe('Whether the code was updated'),
+      configUpdated: z.boolean().describe('Whether the configuration was updated')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let codeUpdated = false;
+    let configUpdated = false;
+    let lastResult: any = {};
+
+    if (!ctx.input.code && !ctx.input.configuration) {
+      throw lambdaServiceError('Provide code, configuration, or both to update a function.');
+    }
+
+    if (ctx.input.code) {
+      let codeParams: Record<string, any> = {};
+      if (ctx.input.code.s3Bucket) codeParams['S3Bucket'] = ctx.input.code.s3Bucket;
+      if (ctx.input.code.s3Key) codeParams['S3Key'] = ctx.input.code.s3Key;
+      if (ctx.input.code.s3ObjectVersion)
+        codeParams['S3ObjectVersion'] = ctx.input.code.s3ObjectVersion;
+      if (ctx.input.code.imageUri) codeParams['ImageUri'] = ctx.input.code.imageUri;
+      if (ctx.input.code.zipFile) codeParams['ZipFile'] = ctx.input.code.zipFile;
+      if (ctx.input.code.publish !== undefined) codeParams['Publish'] = ctx.input.code.publish;
+      if (ctx.input.code.architectures)
+        codeParams['Architectures'] = ctx.input.code.architectures;
+
+      lastResult = await client.updateFunctionCode(ctx.input.functionName, codeParams);
+      codeUpdated = true;
+    }
+
+    if (ctx.input.configuration) {
+      let configParams: Record<string, any> = {};
+      let cfg = ctx.input.configuration;
+
+      if (cfg.role) configParams['Role'] = cfg.role;
+      if (cfg.runtime) configParams['Runtime'] = cfg.runtime;
+      if (cfg.handler) configParams['Handler'] = cfg.handler;
+      if (cfg.description !== undefined) configParams['Description'] = cfg.description;
+      if (cfg.timeout) configParams['Timeout'] = cfg.timeout;
+      if (cfg.memorySize) configParams['MemorySize'] = cfg.memorySize;
+      if (cfg.environment) configParams['Environment'] = { Variables: cfg.environment };
+      if (cfg.layers) configParams['Layers'] = cfg.layers;
+      if (cfg.ephemeralStorageSize)
+        configParams['EphemeralStorage'] = { Size: cfg.ephemeralStorageSize };
+      if (cfg.tracingMode) configParams['TracingConfig'] = { Mode: cfg.tracingMode };
+      if (cfg.vpcSubnetIds || cfg.vpcSecurityGroupIds) {
+        configParams['VpcConfig'] = {
+          SubnetIds: cfg.vpcSubnetIds || [],
+          SecurityGroupIds: cfg.vpcSecurityGroupIds || []
+        };
+      }
+
+      lastResult = await client.updateFunctionConfiguration(
+        ctx.input.functionName,
+        configParams
+      );
+      configUpdated = true;
+    }
+
+    let parts: string[] = [];
+    if (codeUpdated) parts.push('code');
+    if (configUpdated) parts.push('configuration');
+
+    return {
+      output: {
+        functionName: lastResult.FunctionName || ctx.input.functionName,
+        functionArn: lastResult.FunctionArn || '',
+        runtime: lastResult.Runtime,
+        state: lastResult.State,
+        version: lastResult.Version,
+        lastModified: lastResult.LastModified,
+        codeUpdated,
+        configUpdated
+      },
+      message: `Updated ${parts.join(' and ')} for function **${lastResult.FunctionName || ctx.input.functionName}**.`
+    };
+  })
+  .build();

package/src/triggers/function-changes.ts

@@ -0,0 +1,113 @@
+import { SlateTrigger, SlateDefaultPollingIntervalSeconds } from 'slates';
+import { createClient } from '../lib/helpers';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let functionChanges = SlateTrigger.create(spec, {
+  name: 'Function Changes',
+  key: 'function_changes',
+  description:
+    'Polls for new, updated, or deleted Lambda functions by comparing snapshots of the function list. Detects when functions are created, modified (code or configuration changes), or removed.'
+})
+  .input(
+    z.object({
+      changeType: z
+        .enum(['created', 'updated', 'deleted'])
+        .describe('Type of change detected'),
+      functionName: z.string().describe('Name of the affected function'),
+      functionArn: z.string().describe('ARN of the affected function'),
+      runtime: z.string().optional().describe('Function runtime'),
+      lastModified: z.string().optional().describe('Last modified timestamp'),
+      state: z.string().optional().describe('Function state'),
+      codeSha256: z.string().optional().describe('SHA256 of the deployment package'),
+      version: z.string().optional().describe('Function version')
+    })
+  )
+  .output(
+    z.object({
+      functionName: z.string().describe('Name of the affected function'),
+      functionArn: z.string().describe('ARN of the affected function'),
+      runtime: z.string().optional().describe('Function runtime'),
+      lastModified: z.string().optional().describe('Last modified timestamp'),
+      state: z.string().optional().describe('Function state'),
+      codeSha256: z.string().optional().describe('SHA256 of the deployment package'),
+      version: z.string().optional().describe('Function version')
+    })
+  )
+  .polling({
+    options: {
+      intervalInSeconds: SlateDefaultPollingIntervalSeconds
+    },
+
+    pollEvents: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+
+      let allFunctions: any[] = [];
+      let marker: string | undefined;
+      do {
+        let result = await client.listFunctions(marker, 50);
+        allFunctions.push(...(result.Functions || []));
+        marker = result.NextMarker;
+      } while (marker);
+
+      let currentMap: Record<string, any> = {};
+      for (let fn of allFunctions) {
+        currentMap[fn.FunctionArn] = {
+          functionName: fn.FunctionName,
+          functionArn: fn.FunctionArn,
+          runtime: fn.Runtime,
+          lastModified: fn.LastModified,
+          state: fn.State,
+          codeSha256: fn.CodeSha256,
+          version: fn.Version
+        };
+      }
+
+      let previousMap: Record<string, any> = ctx.state?.functionMap || {};
+      let inputs: any[] = [];
+
+      // Detect new and updated functions
+      for (let [arn, current] of Object.entries(currentMap)) {
+        let previous = previousMap[arn];
+        if (!previous) {
+          inputs.push({ changeType: 'created' as const, ...current });
+        } else if (
+          previous.lastModified !== current.lastModified ||
+          previous.codeSha256 !== current.codeSha256
+        ) {
+          inputs.push({ changeType: 'updated' as const, ...current });
+        }
+      }
+
+      // Detect deleted functions
+      for (let [arn, previous] of Object.entries(previousMap)) {
+        if (!currentMap[arn]) {
+          inputs.push({ changeType: 'deleted' as const, ...previous });
+        }
+      }
+
+      return {
+        inputs,
+        updatedState: {
+          functionMap: currentMap
+        }
+      };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: `function.${ctx.input.changeType}`,
+        id: `${ctx.input.functionArn}-${ctx.input.changeType}-${ctx.input.lastModified || Date.now()}`,
+        output: {
+          functionName: ctx.input.functionName,
+          functionArn: ctx.input.functionArn,
+          runtime: ctx.input.runtime,
+          lastModified: ctx.input.lastModified,
+          state: ctx.input.state,
+          codeSha256: ctx.input.codeSha256,
+          version: ctx.input.version
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/inbound-webhook.ts

@@ -0,0 +1,67 @@
+import { SlateTrigger } from 'slates';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+/**
+ * Generic inbound webhook for providers without a tailored webhook trigger yet.
+ * POST JSON is parsed into `payload` (non-objects are wrapped as { _value }).
+ * Refine in the workflow mapper or replace with a provider-specific trigger.
+ */
+export let inboundWebhook = SlateTrigger.create(spec, {
+  name: 'Inbound Webhook',
+  key: 'inbound_webhook',
+  description:
+    'Receives HTTP POST at the Slates webhook URL. Parses JSON into payload (or stores raw body if not JSON). Configure your provider to POST here when supported.'
+})
+  .input(
+    z.object({
+      payload: z
+        .record(z.string(), z.any())
+        .describe('Parsed JSON object from the request body'),
+      rawBody: z.string().optional().describe('Raw body when JSON parsing failed'),
+      contentType: z.string().optional().describe('Content-Type header')
+    })
+  )
+  .output(
+    z.object({
+      payload: z.record(z.string(), z.any()),
+      rawBody: z.string().optional()
+    })
+  )
+  .webhook({
+    handleRequest: async ctx => {
+      let contentType = ctx.request.headers.get('content-type') ?? '';
+      let text = await ctx.request.text();
+      if (!text || !text.trim()) {
+        return {
+          inputs: [{ payload: {}, contentType }]
+        };
+      }
+      try {
+        let parsed = JSON.parse(text);
+        let payload =
+          parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : { _value: parsed };
+        return {
+          inputs: [{ payload, contentType }]
+        };
+      } catch {
+        return {
+          inputs: [{ payload: {}, rawBody: text, contentType }]
+        };
+      }
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: 'webhook.inbound',
+        id: `inbound-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+        output: {
+          payload: ctx.input.payload,
+          rawBody: ctx.input.rawBody
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/index.ts

@@ -0,0 +1,2 @@
+export { functionChanges } from './function-changes';
+export * from './inbound-webhook';

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "types": ["node"],
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "moduleResolution": "bundler",
+
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["src"]
+}