@aws/agentcore 0.3.0-preview.1.0

package/package.json

@@ -0,0 +1,111 @@
+{
+  "name": "@aws/agentcore",
+  "version": "0.3.0-preview.1.0",
+  "description": "CLI for Amazon Bedrock AgentCore",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "agentcore": "dist/cli/index.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "scripts"
+  ],
+  "scripts": {
+    "preinstall": "node scripts/check-old-cli.mjs",
+    "build": "npm run build:lib && npm run build:cli && npm run build:assets",
+    "build:lib": "tsc -p tsconfig.build.json",
+    "build:cli": "node esbuild.config.mjs",
+    "build:assets": "node scripts/copy-assets.mjs",
+    "cli": "npx tsx src/cli/index.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "secrets:check": "secretlint '**/*'",
+    "security:audit": "npm audit --audit-level=high",
+    "clean": "node -e \"require('fs').rmSync('dist', {recursive: true, force: true})\"",
+    "prepare": "husky",
+    "test": "vitest run --project unit",
+    "test:all": "vitest run",
+    "test:watch": "vitest --project unit",
+    "test:integ": "vitest run --project integ",
+    "test:unit": "vitest run --project unit --coverage",
+    "test:update-snapshots": "vitest run --project unit --update"
+  },
+  "dependencies": {
+    "@aws-cdk/toolkit-lib": "^1.13.0",
+    "@aws-sdk/client-bedrock-agentcore": "^3.893.0",
+    "@aws-sdk/client-bedrock-agentcore-control": "^3.893.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.893.0",
+    "@aws-sdk/client-cloudformation": "^3.893.0",
+    "@aws-sdk/client-resource-groups-tagging-api": "^3.893.0",
+    "@aws-sdk/client-sts": "^3.893.0",
+    "@aws-sdk/credential-providers": "^3.893.0",
+    "@commander-js/extra-typings": "^14.0.0",
+    "@smithy/shared-ini-file-loader": "^4.4.2",
+    "commander": "^14.0.2",
+    "dotenv": "^17.2.3",
+    "fflate": "^0.8.2",
+    "handlebars": "^4.7.8",
+    "ink": "^6.6.0",
+    "ink-link": "5.0.0",
+    "ink-spinner": "^5.0.0",
+    "react": "^19.2.3",
+    "zod": "^4.3.5"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.234.1",
+    "constructs": "^10.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@secretlint/secretlint-rule-preset-recommend": "^11.3.0",
+    "@trivago/prettier-plugin-sort-imports": "6.0.0",
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.7",
+    "@typescript-eslint/eslint-plugin": "^8.50.0",
+    "@typescript-eslint/parser": "^8.50.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "aws-cdk-lib": "^2.234.1",
+    "constructs": "^10.4.4",
+    "esbuild": "^0.27.2",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.26",
+    "eslint-plugin-security": "^3.0.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.7.4",
+    "secretlint": "^11.3.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5",
+    "typescript-eslint": "^8.50.1",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "eslint --max-warnings=10"
+    ],
+    "*.{ts,tsx,js,jsx,json,md,css,html,yml,yaml}": [
+      "prettier --check"
+    ],
+    "*": [
+      "secretlint"
+    ]
+  }
+}

package/scripts/bump-version.ts

@@ -0,0 +1,442 @@
+#!/usr/bin/env npx tsx
+
+/**
+ * Version bump script for AgentCore CLI
+ *
+ * Usage:
+ *   npx tsx scripts/bump-version.ts <bump_type> [options]
+ *
+ * Arguments:
+ *   bump_type: major | minor | patch | prerelease | preview
+ *
+ * Options:
+ *   --changelog <text>     Custom changelog entry
+ *   --prerelease-tag <tag> Prerelease identifier (default: beta)
+ *   --dry-run              Show what would be done without making changes
+ *
+ * Preview bumps (internal format):
+ *   - 0.3.0 -> 0.3.0-preview.1.0
+ *   - 0.3.0-preview.1.0 -> 0.3.0-preview.1.1
+ */
+import { execSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+
+// ===========================
+// Types
+// ===========================
+
+type BumpType = 'major' | 'minor' | 'patch' | 'prerelease' | 'preview';
+
+interface ParsedVersion {
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease?: string;
+  prereleaseNum?: number;
+  // For preview format: X.Y.Z-previewN.M
+  previewMajor?: number;
+  previewMinor?: number;
+}
+
+interface PackageJson {
+  version: string;
+  [key: string]: unknown;
+}
+
+interface PackageLockJson {
+  version: string;
+  packages?: {
+    ''?: { version: string };
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+// ===========================
+// Version Parsing & Bumping
+// ===========================
+
+function parseVersion(version: string): ParsedVersion {
+  // First try to match preview format: X.Y.Z-preview.N.M (e.g., 0.3.0-preview.1.0)
+  const previewMatch = /^(\d+)\.(\d+)\.(\d+)-preview\.(\d+)\.(\d+)$/.exec(version);
+  if (previewMatch) {
+    return {
+      major: parseInt(previewMatch[1]!, 10),
+      minor: parseInt(previewMatch[2]!, 10),
+      patch: parseInt(previewMatch[3]!, 10),
+      previewMajor: parseInt(previewMatch[4]!, 10),
+      previewMinor: parseInt(previewMatch[5]!, 10),
+    };
+  }
+
+  // Match standard versions like: 1.2.3, 1.2.3-beta.1, 1.2.3-rc.0
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z]+)\.(\d+))?$/.exec(version);
+
+  if (!match) {
+    throw new Error(`Invalid version format: ${version}`);
+  }
+
+  return {
+    major: parseInt(match[1]!, 10),
+    minor: parseInt(match[2]!, 10),
+    patch: parseInt(match[3]!, 10),
+    prerelease: match[4],
+    prereleaseNum: match[5] ? parseInt(match[5], 10) : undefined,
+  };
+}
+
+function formatVersion(parsed: ParsedVersion): string {
+  const base = `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+
+  // Handle preview format: X.Y.Z-preview.N.M
+  if (parsed.previewMajor !== undefined && parsed.previewMinor !== undefined) {
+    return `${base}-preview.${parsed.previewMajor}.${parsed.previewMinor}`;
+  }
+
+  // Handle standard prerelease format: X.Y.Z-tag.N
+  if (parsed.prerelease !== undefined && parsed.prereleaseNum !== undefined) {
+    return `${base}-${parsed.prerelease}.${parsed.prereleaseNum}`;
+  }
+
+  return base;
+}
+
+function bumpVersion(current: string, bumpType: BumpType, prereleaseTag = 'beta'): string {
+  const parsed = parseVersion(current);
+
+  switch (bumpType) {
+    case 'major':
+      return formatVersion({
+        major: parsed.major + 1,
+        minor: 0,
+        patch: 0,
+      });
+
+    case 'minor':
+      return formatVersion({
+        major: parsed.major,
+        minor: parsed.minor + 1,
+        patch: 0,
+      });
+
+    case 'patch':
+      // If currently a prerelease or preview, just remove the suffix
+      if (parsed.prerelease || parsed.previewMajor !== undefined) {
+        return formatVersion({
+          major: parsed.major,
+          minor: parsed.minor,
+          patch: parsed.patch,
+        });
+      }
+      return formatVersion({
+        major: parsed.major,
+        minor: parsed.minor,
+        patch: parsed.patch + 1,
+      });
+
+    case 'prerelease':
+      // If already a prerelease with same tag, increment the number
+      if (parsed.prerelease === prereleaseTag && parsed.prereleaseNum !== undefined) {
+        return formatVersion({
+          major: parsed.major,
+          minor: parsed.minor,
+          patch: parsed.patch,
+          prerelease: prereleaseTag,
+          prereleaseNum: parsed.prereleaseNum + 1,
+        });
+      }
+      // Otherwise, bump patch and start new prerelease
+      return formatVersion({
+        major: parsed.major,
+        minor: parsed.minor,
+        patch: parsed.prerelease ? parsed.patch : parsed.patch + 1,
+        prerelease: prereleaseTag,
+        prereleaseNum: 0,
+      });
+
+    case 'preview':
+      // Handle preview format: X.Y.Z-previewN.M
+      // If already a preview, increment the minor preview number
+      if (parsed.previewMajor !== undefined && parsed.previewMinor !== undefined) {
+        return formatVersion({
+          major: parsed.major,
+          minor: parsed.minor,
+          patch: parsed.patch,
+          previewMajor: parsed.previewMajor,
+          previewMinor: parsed.previewMinor + 1,
+        });
+      }
+      // Otherwise, start at preview.1.0
+      return formatVersion({
+        major: parsed.major,
+        minor: parsed.minor,
+        patch: parsed.patch,
+        previewMajor: 1,
+        previewMinor: 0,
+      });
+
+    default: {
+      const exhaustiveCheck: never = bumpType;
+      throw new Error(`Unknown bump type: ${exhaustiveCheck as string}`);
+    }
+  }
+}
+
+// ===========================
+// File Operations
+// ===========================
+
+function getCurrentVersion(): string {
+  const packageJson = JSON.parse(readFileSync('package.json', 'utf-8')) as PackageJson;
+  return packageJson.version;
+}
+
+function updatePackageJson(newVersion: string): void {
+  const packageJson = JSON.parse(readFileSync('package.json', 'utf-8')) as PackageJson;
+  packageJson.version = newVersion;
+  writeFileSync('package.json', JSON.stringify(packageJson, null, 2) + '\n');
+  console.log('✓ Updated package.json');
+}
+
+function updatePackageLockJson(newVersion: string): void {
+  if (!existsSync('package-lock.json')) {
+    return;
+  }
+
+  const packageLock = JSON.parse(readFileSync('package-lock.json', 'utf-8')) as PackageLockJson;
+  packageLock.version = newVersion;
+
+  // Also update the root package in packages
+  if (packageLock.packages?.['']) {
+    packageLock.packages[''].version = newVersion;
+  }
+
+  writeFileSync('package-lock.json', JSON.stringify(packageLock, null, 2) + '\n');
+  console.log('✓ Updated package-lock.json');
+}
+
+// ===========================
+// Git Log & Changelog
+// ===========================
+
+function getGitLog(sinceTag?: string): string {
+  try {
+    let cmd = 'git log --pretty=format:"- %s (%h)"';
+
+    if (sinceTag) {
+      cmd += ` ${sinceTag}..HEAD`;
+    } else {
+      // Try to get the last tag
+      try {
+        const lastTag = execSync('git describe --tags --abbrev=0', { encoding: 'utf-8' }).trim();
+        cmd += ` ${lastTag}..HEAD`;
+      } catch {
+        // No tags exist, get last 20 commits
+        cmd += ' -n 20';
+      }
+    }
+
+    return execSync(cmd, { encoding: 'utf-8' });
+  } catch {
+    return '';
+  }
+}
+
+interface CategorizedChanges {
+  features: string[];
+  fixes: string[];
+  docs: string[];
+  other: string[];
+}
+
+function categorizeCommits(gitLog: string): CategorizedChanges {
+  const result: CategorizedChanges = {
+    features: [],
+    fixes: [],
+    docs: [],
+    other: [],
+  };
+
+  for (const line of gitLog.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed?.startsWith('-')) continue;
+
+    const msg = trimmed.slice(2).trim();
+
+    if (msg.startsWith('feat:') || msg.startsWith('feature:')) {
+      result.features.push(msg);
+    } else if (msg.startsWith('fix:') || msg.startsWith('bugfix:')) {
+      result.fixes.push(msg);
+    } else if (msg.startsWith('docs:') || msg.startsWith('doc:')) {
+      result.docs.push(msg);
+    } else {
+      result.other.push(msg);
+    }
+  }
+
+  return result;
+}
+
+function formatChangelog(changes: CategorizedChanges): string {
+  const sections: string[] = [];
+
+  if (changes.features.length > 0) {
+    sections.push('### Added\n' + changes.features.map(m => `- ${m}`).join('\n'));
+  }
+
+  if (changes.fixes.length > 0) {
+    sections.push('### Fixed\n' + changes.fixes.map(m => `- ${m}`).join('\n'));
+  }
+
+  if (changes.docs.length > 0) {
+    sections.push('### Documentation\n' + changes.docs.map(m => `- ${m}`).join('\n'));
+  }
+
+  if (changes.other.length > 0) {
+    sections.push('### Other Changes\n' + changes.other.map(m => `- ${m}`).join('\n'));
+  }
+
+  return sections.join('\n\n');
+}
+
+function updateChangelog(newVersion: string, customChanges?: string): void {
+  const changelogPath = 'CHANGELOG.md';
+  const date = new Date().toISOString().split('T')[0];
+
+  // Build the new entry
+  let entryContent = '';
+  if (customChanges) {
+    entryContent = `### Changes\n\n${customChanges}`;
+  } else {
+    console.log('\n⚠️  No changelog provided. Auto-generating from commits.');
+    console.log('💡 Tip: Use --changelog to provide meaningful release notes');
+
+    const gitLog = getGitLog();
+    if (gitLog) {
+      const categorized = categorizeCommits(gitLog);
+      const formatted = formatChangelog(categorized);
+      entryContent = formatted || `### Changes\n\n${gitLog}`;
+    }
+  }
+
+  const entry = `## [${newVersion}] - ${date}\n\n${entryContent}`;
+
+  let content: string;
+  if (existsSync(changelogPath)) {
+    content = readFileSync(changelogPath, 'utf-8');
+
+    // Find where to insert (after # Changelog header line)
+    const lines = content.split('\n');
+    const headerIndex = lines.findIndex(line => line.startsWith('# Changelog'));
+
+    if (headerIndex !== -1) {
+      // Find the next ## or end of preamble (first non-empty line after a blank line)
+      let insertAt = headerIndex + 1;
+
+      // Skip blank lines and description text until we hit an existing ## or end
+      while (insertAt < lines.length && !lines[insertAt]?.startsWith('## ')) {
+        insertAt++;
+      }
+
+      // Insert the new entry
+      lines.splice(insertAt, 0, '', entry, '');
+      content = lines.join('\n');
+    } else {
+      // No header found, prepend everything
+      content = `# Changelog\n\n${entry}\n\n${content}`;
+    }
+  } else {
+    content = `# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n${entry}\n`;
+  }
+
+  // Clean up multiple consecutive blank lines
+  content = content.replace(/\n{3,}/g, '\n\n');
+
+  // Ensure single trailing newline
+  content = content.trimEnd() + '\n';
+
+  writeFileSync(changelogPath, content);
+  console.log('✓ Updated CHANGELOG.md');
+}
+
+// ===========================
+// CLI
+// ===========================
+
+function parseArgs(): { bumpType: BumpType; changelog?: string; prereleaseTag: string; dryRun: boolean } {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log(`
+Usage: npx tsx scripts/bump-version.ts <bump_type> [options]
+
+Arguments:
+  bump_type: major | minor | patch | prerelease | preview
+
+Options:
+  --changelog <text>        Custom changelog entry
+  --prerelease-tag <tag>    Prerelease identifier (default: beta)
+  --dry-run                 Show what would be done without making changes
+  --help, -h                Show this help message
+
+Preview bumps:
+  - 0.3.0 -> 0.3.0-preview.1.0
+  - 0.3.0-preview.1.0 -> 0.3.0-preview.1.1
+`);
+    process.exit(0);
+  }
+
+  const bumpType = args[0] as BumpType;
+  if (!['major', 'minor', 'patch', 'prerelease', 'preview'].includes(bumpType)) {
+    console.error(`Error: Invalid bump type '${bumpType}'. Must be one of: major, minor, patch, prerelease, preview`);
+    process.exit(1);
+  }
+
+  let changelog: string | undefined;
+  let prereleaseTag = 'beta';
+  let dryRun = false;
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--changelog' && args[i + 1]) {
+      changelog = args[++i];
+    } else if (args[i] === '--prerelease-tag' && args[i + 1]) {
+      prereleaseTag = args[++i]!;
+    } else if (args[i] === '--dry-run') {
+      dryRun = true;
+    }
+  }
+
+  return { bumpType, changelog, prereleaseTag, dryRun };
+}
+
+function main(): void {
+  const { bumpType, changelog, prereleaseTag, dryRun } = parseArgs();
+
+  try {
+    const currentVersion = getCurrentVersion();
+    const newVersion = bumpVersion(currentVersion, bumpType, prereleaseTag);
+
+    console.log(`Current version: ${currentVersion}`);
+    console.log(`New version: ${newVersion}`);
+
+    if (dryRun) {
+      console.log('\nDry run - no changes made');
+      return;
+    }
+
+    updatePackageJson(newVersion);
+    updatePackageLockJson(newVersion);
+    updateChangelog(newVersion, changelog);
+
+    console.log(`\n✓ Version bumped from ${currentVersion} to ${newVersion}`);
+    console.log('\nNext steps:');
+    console.log('1. Review changes: git diff');
+    console.log(`2. Commit: git add -A && git commit -m 'chore: bump version to ${newVersion}'`);
+    console.log('3. Create PR or push to trigger release workflow');
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/check-old-cli.mjs

@@ -0,0 +1,26 @@
+import { execSync } from 'node:child_process';
+import { platform } from 'node:os';
+
+try {
+  // Check if an `agentcore` binary exists on PATH
+  const whichCmd = platform() === 'win32' ? 'where agentcore' : 'command -v agentcore';
+  execSync(whichCmd, { stdio: 'ignore' });
+
+  // Binary exists — check if it supports --version (the new CLI does, the old Python one does not)
+  try {
+    execSync('agentcore --version', { stdio: 'ignore' });
+  } catch {
+    // --version failed → likely the old Python CLI
+    console.warn(
+      [
+        '',
+        '\x1b[33m⚠ WARNING: We detected an older version of the AgentCore CLI.\x1b[0m',
+        '\x1b[33mFor the best experience, we recommend uninstalling it using:\x1b[0m',
+        '\x1b[33m  pip uninstall bedrock-agentcore-starter-toolkit\x1b[0m',
+        '',
+      ].join('\n')
+    );
+  }
+} catch {
+  // No agentcore binary found or unexpected error — nothing to do
+}

package/scripts/copy-assets.mjs

@@ -0,0 +1,50 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const srcDir = path.join(__dirname, '..', 'src', 'assets');
+const destDir = path.join(__dirname, '..', 'dist', 'assets');
+
+/**
+ * Recursively copy directory contents, excluding specified files at root level only
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ * @param {string[]} excludeAtRoot - Files to exclude only at the root level (e.g., 'AGENTS.md')
+ * @param {boolean} isRoot - Whether this is the root level call
+ */
+function copyDir(src, dest, excludeAtRoot = [], isRoot = true) {
+  // Create destination directory if it doesn't exist
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    // Skip excluded files only at root level
+    if (isRoot && excludeAtRoot.includes(entry.name)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, excludeAtRoot, false);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+try {
+  console.log('Copying assets...');
+  copyDir(srcDir, destDir, ['AGENTS.md']);
+  console.log('Assets copied successfully!');
+} catch (error) {
+  console.error('Error copying assets:', error);
+  process.exit(1);
+}