@codyswann/lisa 2.225.5 → 2.226.1

package/plugins/lisa-agy/scripts/install-remote-agent-aws.mjs

@@ -0,0 +1,347 @@
+#!/usr/bin/env node
+/**
+ * Install Lisa's vendor-neutral remote AWS bootstrap into a host project.
+ *
+ * This installer writes only non-secret repository artifacts. The bootstrap
+ * SecretString is configured directly in each remote-agent platform.
+ * @module install-remote-agent-aws
+ */
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SCRIPT_NAME = "remote-agent-aws-setup.sh";
+const INSTALL_COMMAND = `bash scripts/${SCRIPT_NAME}`;
+const VALID_PLATFORMS = new Set([
+  "all",
+  "claude",
+  "codex",
+  "cursor",
+  "copilot",
+  "agy",
+  "opencode",
+]);
+
+function parseArguments(arguments_) {
+  let project = process.cwd();
+  let platform = "all";
+  let secretName = "remote-agent-credentials";
+  for (const argument of arguments_) {
+    if (argument.startsWith("--project=")) {
+      project = path.resolve(argument.slice("--project=".length));
+    } else if (argument.startsWith("--platform=")) {
+      platform = argument.slice("--platform=".length).toLowerCase();
+    } else if (argument.startsWith("--secret-name=")) {
+      secretName = argument.slice("--secret-name=".length);
+    } else {
+      throw new Error(`Unknown argument: ${argument}`);
+    }
+  }
+  if (!VALID_PLATFORMS.has(platform)) {
+    throw new Error(
+      `Unsupported platform '${platform}'. Expected one of: ${[...VALID_PLATFORMS].join(", ")}`
+    );
+  }
+  if (!/^[A-Za-z0-9/_+=.@-]+$/.test(secretName)) {
+    throw new Error("--secret-name must be a valid Secrets Manager name");
+  }
+  return { project, platform, secretName };
+}
+
+function writeSetupScript(project) {
+  const source = path.join(
+    path.dirname(fileURLToPath(import.meta.url)),
+    SCRIPT_NAME
+  );
+  const destination = path.join(project, "scripts", SCRIPT_NAME);
+  mkdirSync(path.dirname(destination), { recursive: true });
+  writeFileSync(destination, readFileSync(source));
+  chmodSync(destination, 0o700);
+  return path.relative(project, destination);
+}
+
+function installCursorAdapter(project) {
+  const environmentPath = path.join(project, ".cursor", "environment.json");
+  mkdirSync(path.dirname(environmentPath), { recursive: true });
+
+  const environment = existsSync(environmentPath)
+    ? JSON.parse(readFileSync(environmentPath, "utf8"))
+    : {};
+  const existingInstall = environment.install;
+  if (existingInstall !== undefined && typeof existingInstall !== "string") {
+    throw new Error(
+      `.cursor/environment.json install must be a string before Lisa can merge ${INSTALL_COMMAND}`
+    );
+  }
+  const lisaInstall = `LISA_REMOTE_AGENT=cursor ${INSTALL_COMMAND}`;
+  if (!existingInstall?.includes(SCRIPT_NAME)) {
+    environment.install = existingInstall
+      ? `${lisaInstall} && ${existingInstall}`
+      : lisaInstall;
+  }
+  writeFileSync(environmentPath, `${JSON.stringify(environment, null, 2)}\n`);
+  return path.relative(project, environmentPath);
+}
+
+function installCopilotAdapter(project) {
+  const workflowPath = path.join(
+    project,
+    ".github",
+    "workflows",
+    "copilot-setup-steps.yml"
+  );
+  mkdirSync(path.dirname(workflowPath), { recursive: true });
+  const marker = "Lisa remote AWS bootstrap";
+  const secretEnvironment =
+    "          LISA_AWS_BOOTSTRAP_JSON: ${{ secrets.LISA_AWS_BOOTSTRAP_JSON }}";
+  const checkoutStep = [
+    "      - uses: actions/checkout@v4",
+    "        with:",
+    "          persist-credentials: false",
+  ].join("\n");
+  const step = [
+    `      - name: ${marker}`,
+    "        env:",
+    secretEnvironment,
+    "          LISA_REMOTE_AGENT: copilot",
+    `        run: ${INSTALL_COMMAND}`,
+  ].join("\n");
+
+  if (!existsSync(workflowPath)) {
+    writeFileSync(
+      workflowPath,
+      [
+        'name: "Copilot Setup Steps"',
+        "on:",
+        "  workflow_dispatch:",
+        "jobs:",
+        "  copilot-setup-steps:",
+        "    runs-on: ubuntu-latest",
+        "    permissions:",
+        "      contents: read",
+        "    steps:",
+        checkoutStep,
+        step,
+        "",
+      ].join("\n")
+    );
+    return path.relative(project, workflowPath);
+  }
+
+  const current = readFileSync(workflowPath, "utf8");
+  const lines = current.split("\n");
+  const jobIndex = lines.findIndex(line =>
+    /^\s{2}copilot-setup-steps:\s*$/.test(line)
+  );
+  const jobEndIndex = lines.findIndex(
+    (line, index) => index > jobIndex && /^\s{2}\S[^:]*:\s*$/.test(line)
+  );
+  const stepsIndex = lines.findIndex(
+    (line, index) =>
+      index > jobIndex &&
+      (jobEndIndex < 0 || index < jobEndIndex) &&
+      /^\s{4}steps:\s*$/.test(line)
+  );
+  if (jobIndex < 0 || stepsIndex < 0) {
+    throw new Error(
+      "Existing copilot-setup-steps.yml must contain jobs.copilot-setup-steps.steps before Lisa can merge the AWS bootstrap step"
+    );
+  }
+
+  let changed = false;
+  const checkoutIndex = lines.findIndex(
+    (line, index) =>
+      index > stepsIndex &&
+      (jobEndIndex < 0 || index < jobEndIndex) &&
+      /^\s{6}-\s+uses:\s+actions\/checkout@/.test(line)
+  );
+  if (checkoutIndex >= 0) {
+    const nextStepIndex = lines.findIndex(
+      (line, index) => index > checkoutIndex && /^\s{6}-\s/.test(line)
+    );
+    const checkoutEnd = nextStepIndex < 0 ? lines.length : nextStepIndex;
+    const withIndex = lines.findIndex(
+      (line, index) =>
+        index > checkoutIndex &&
+        index < checkoutEnd &&
+        /^\s{8}with:\s*$/.test(line)
+    );
+    const persistenceIndex = lines.findIndex(
+      (line, index) =>
+        index > checkoutIndex &&
+        index < checkoutEnd &&
+        /^\s{10}persist-credentials:\s*/.test(line)
+    );
+    if (persistenceIndex >= 0) {
+      if (lines[persistenceIndex] !== "          persist-credentials: false") {
+        lines[persistenceIndex] = "          persist-credentials: false";
+        changed = true;
+      }
+    } else if (withIndex >= 0) {
+      lines.splice(withIndex + 1, 0, "          persist-credentials: false");
+      changed = true;
+    } else {
+      lines.splice(
+        checkoutIndex + 1,
+        0,
+        "        with:",
+        "          persist-credentials: false"
+      );
+      changed = true;
+    }
+  }
+
+  const markerIndex = lines.findIndex(line => line.includes(marker));
+  if (markerIndex >= 0) {
+    const nextStepIndex = lines.findIndex(
+      (line, index) => index > markerIndex && /^\s{6}-\s/.test(line)
+    );
+    const managedStepEnd = nextStepIndex < 0 ? lines.length : nextStepIndex;
+    const managedStep = lines.slice(markerIndex, managedStepEnd);
+    if (!managedStep.includes(secretEnvironment)) {
+      const environmentIndex = lines.findIndex(
+        (line, index) =>
+          index > markerIndex &&
+          index < managedStepEnd &&
+          /^\s{8}env:\s*$/.test(line)
+      );
+      if (environmentIndex < 0) {
+        throw new Error(
+          "Existing Lisa remote AWS bootstrap step must contain an env block"
+        );
+      }
+      lines.splice(environmentIndex + 1, 0, secretEnvironment);
+      changed = true;
+    }
+    if (checkoutIndex < 0) {
+      lines.splice(stepsIndex + 1, 0, ...checkoutStep.split("\n"));
+      changed = true;
+    }
+    if (changed) writeFileSync(workflowPath, lines.join("\n"));
+    return path.relative(project, workflowPath);
+  }
+  const additions = checkoutIndex >= 0 ? [step] : [checkoutStep, step];
+  const nextCheckoutStepIndex = lines.findIndex(
+    (line, index) => index > checkoutIndex && /^\s{6}-\s/.test(line)
+  );
+  const updatedJobEndIndex = lines.findIndex(
+    (line, index) => index > jobIndex && /^\s{2}\S[^:]*:\s*$/.test(line)
+  );
+  const additionIndex =
+    checkoutIndex < 0
+      ? stepsIndex + 1
+      : nextCheckoutStepIndex >= 0
+        ? nextCheckoutStepIndex
+        : updatedJobEndIndex >= 0
+          ? updatedJobEndIndex
+          : lines.length;
+  lines.splice(additionIndex, 0, ...additions);
+  writeFileSync(workflowPath, lines.join("\n"));
+  return path.relative(project, workflowPath);
+}
+
+function writeGuide(project, platform, secretName) {
+  const guidePath = path.join(project, "docs", "remote-agent-aws.md");
+  mkdirSync(path.dirname(guidePath), { recursive: true });
+  writeFileSync(
+    guidePath,
+    `# Remote coding-agent AWS access
+
+## Context
+
+This repository uses Lisa's vendor-neutral AWS bootstrap. Configure the complete
+Secrets Manager SecretString as the secret \`LISA_AWS_BOOTSTRAP_JSON\`; do not
+split it into \`AWS_ACCESS_KEY_ID\` and \`AWS_SECRET_ACCESS_KEY\` environment
+variables. The setup script writes a named source profile whose only permission
+is \`sts:AssumeRole\`, then creates automatically refreshed role profiles.
+
+## Goal
+
+Give supported remote coding agents renewable, least-privilege AWS CLI access
+without borrowing a developer identity or granting direct production repair.
+
+## Changes
+
+| Runtime | Setup |
+|---|---|
+| Claude | Add \`LISA_AWS_BOOTSTRAP_JSON\` to the cloud environment, set \`LISA_REMOTE_AGENT=claude\`, and run \`${INSTALL_COMMAND}\` in the setup script. |
+| Codex | Add \`LISA_AWS_BOOTSTRAP_JSON\` as a setup secret, set \`LISA_REMOTE_AGENT=codex\`, and run \`${INSTALL_COMMAND}\` in the setup script. Permit required AWS endpoints during the agent phase. |
+| Cursor | Add the secret to the selected cloud environment. \`.cursor/environment.json\` runs the setup script with \`LISA_REMOTE_AGENT=cursor\`. |
+| Copilot | Add the value as an organization-level **Agents** secret. \`copilot-setup-steps.yml\` runs the setup script with \`LISA_REMOTE_AGENT=copilot\`. |
+| Antigravity | Direct AWS CLI is supported only on a user-managed remote host. Google's managed preview currently documents proxy-injected HTTP credentials, not arbitrary AWS credential files. |
+| OpenCode | Run the setup script on the VPS/container that hosts \`opencode serve\`, with \`LISA_REMOTE_AGENT=opencode\`. OpenCode does not supply the host. |
+
+Generated for: \`${platform}\`.
+
+## Implementation
+
+The bootstrap bundle defines the available profile names. \`dev\` is the
+default when present. Select another account explicitly, for example:
+
+\`\`\`bash
+aws --profile staging sts get-caller-identity
+aws --profile production cloudformation describe-stacks
+\`\`\`
+
+Production and shared profiles are observer-only. Production repair remains a
+human-driven local-workstation operation.
+
+After the infrastructure pipeline deploys the remote-agent IAM stacks, retrieve
+the complete bundle from the shared account. Do not extract or distribute its
+individual access-key fields:
+
+\`\`\`bash
+aws --profile shared secretsmanager get-secret-value \\
+  --secret-id ${secretName} \\
+  --query SecretString \\
+  --output text
+\`\`\`
+
+Store that exact output as the masked secret \`LISA_AWS_BOOTSTRAP_JSON\` on each
+remote-agent platform. Run the setup command and require its live
+\`sts:GetCallerIdentity\` check to pass before considering the platform ready.
+
+## Notes
+
+Rotate by replacing the bootstrap IAM access key through infrastructure and
+then updating this one secret on every configured platform. Disabling or
+deleting the bootstrap user immediately prevents new role sessions.
+`
+  );
+  return path.relative(project, guidePath);
+}
+
+export function installRemoteAgentAws(arguments_ = process.argv.slice(2)) {
+  const { project, platform, secretName } = parseArguments(arguments_);
+  if (!existsSync(project))
+    throw new Error(`Project does not exist: ${project}`);
+
+  const written = [writeSetupScript(project)];
+  if (platform === "all" || platform === "cursor") {
+    written.push(installCursorAdapter(project));
+  }
+  if (platform === "all" || platform === "copilot") {
+    written.push(installCopilotAdapter(project));
+  }
+  written.push(writeGuide(project, platform, secretName));
+  return { project, platform, secretName, written };
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  try {
+    process.stdout.write(
+      `${JSON.stringify(installRemoteAgentAws(), null, 2)}\n`
+    );
+  } catch (error) {
+    process.stderr.write(
+      `install-remote-agent-aws: ${error instanceof Error ? error.message : String(error)}\n`
+    );
+    process.exitCode = 1;
+  }
+}

package/plugins/lisa-agy/scripts/remote-agent-aws-setup.sh

@@ -0,0 +1,204 @@
+#!/usr/bin/env bash
+# Vendor-neutral AWS CLI bootstrap for remote coding environments. This is the
+# source copied into every generated Lisa agent plugin.
+#
+# Required secret:
+#   LISA_AWS_BOOTSTRAP_JSON  Complete SecretString emitted by cdkstarter's
+#                            remote-agent IAM kit.
+# Optional plain variables:
+#   LISA_REMOTE_AGENT       claude | codex | cursor | copilot | agy | opencode
+#   LISA_AWS_DEFAULT_PROFILE  Defaults to dev, then the first available profile.
+#   LISA_AWS_SKIP_VERIFY    Set to 1 only for an offline image build.
+
+set -euo pipefail
+umask 077
+
+BOOTSTRAP_PROFILE="lisa-remote-agent-bootstrap"
+AWS_CLI_VERSION="2.36.2"
+
+fail() {
+  echo "remote-agent-aws-setup: $*" >&2
+  exit 1
+}
+
+need() {
+  command -v "$1" >/dev/null 2>&1
+}
+
+as_root() {
+  if [ "$(id -u)" = "0" ]; then
+    "$@"
+  elif need sudo; then
+    sudo "$@"
+  else
+    fail "root access is required to install $1"
+  fi
+}
+
+install_base_tools() {
+  need curl && need unzip && need jq && need gpg && return 0
+
+  if need apt-get; then
+    as_root apt-get update -y
+    as_root apt-get install -y curl unzip jq gnupg
+  elif need dnf; then
+    as_root dnf install -y curl unzip jq gnupg2
+  elif need yum; then
+    as_root yum install -y curl unzip jq gnupg2
+  else
+    fail "install curl, unzip, jq, and gpg in the remote image before running this script"
+  fi
+}
+
+install_aws_cli() {
+  need aws && return 0
+
+  local architecture aws_architecture temporary_directory
+  architecture="$(uname -m)"
+  case "$architecture" in
+    x86_64 | amd64) aws_architecture="x86_64" ;;
+    aarch64 | arm64) aws_architecture="aarch64" ;;
+    *) fail "unsupported AWS CLI architecture: $architecture" ;;
+  esac
+
+  temporary_directory="$(mktemp -d)"
+  trap 'rm -rf "${temporary_directory:-}"' EXIT
+  local installer_url
+  installer_url="https://awscli.amazonaws.com/awscli-exe-linux-${aws_architecture}-${AWS_CLI_VERSION}.zip"
+  curl -fsSL \
+    "$installer_url" \
+    -o "$temporary_directory/awscliv2.zip"
+  curl -fsSL "$installer_url.sig" -o "$temporary_directory/awscliv2.sig"
+  cat >"$temporary_directory/aws-cli-public-key.asc" <<'AWS_CLI_PUBLIC_KEY'
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mQINBF2Cr7UBEADJZHcgusOJl7ENSyumXh85z0TRV0xJorM2B/JL0kHOyigQluUG
+ZMLhENaG0bYatdrKP+3H91lvK050pXwnO/R7fB/FSTouki4ciIx5OuLlnJZIxSzx
+PqGl0mkxImLNbGWoi6Lto0LYxqHN2iQtzlwTVmq9733zd3XfcXrZ3+LblHAgEt5G
+TfNxEKJ8soPLyWmwDH6HWCnjZ/aIQRBTIQ05uVeEoYxSh6wOai7ss/KveoSNBbYz
+gbdzoqI2Y8cgH2nbfgp3DSasaLZEdCSsIsK1u05CinE7k2qZ7KgKAUIcT/cR/grk
+C6VwsnDU0OUCideXcQ8WeHutqvgZH1JgKDbznoIzeQHJD238GEu+eKhRHcz8/jeG
+94zkcgJOz3KbZGYMiTh277Fvj9zzvZsbMBCedV1BTg3TqgvdX4bdkhf5cH+7NtWO
+lrFj6UwAsGukBTAOxC0l/dnSmZhJ7Z1KmEWilro/gOrjtOxqRQutlIqG22TaqoPG
+fYVN+en3Zwbt97kcgZDwqbuykNt64oZWc4XKCa3mprEGC3IbJTBFqglXmZ7l9ywG
+EEUJYOlb2XrSuPWml39beWdKM8kzr1OjnlOm6+lpTRCBfo0wa9F8YZRhHPAkwKkX
+XDeOGpWRj4ohOx0d2GWkyV5xyN14p2tQOCdOODmz80yUTgRpPVQUtOEhXQARAQAB
+tCFBV1MgQ0xJIFRlYW0gPGF3cy1jbGlAYW1hem9uLmNvbT6JAlQEEwEIAD4CGwMF
+CwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQT7Xbd/1cEYuAURraimMQrMRnJHXAUC
+akV0ygUJDqP4lQAKCRCmMQrMRnJHXFHjD/9eyZLYcKuQOlLvtqSDtUBiEZf6ZZjM
+i3ygYH8rJNtuToUH+HvSpe819urJCquXhDrlK6N+aqW0hCLtNABJG/vsafIgvIYJ
+hSGgpgtNnQyMV1jViRWqPjbouw8OkYKBThUfT1i2Y+wn58ifs6ODBCmTexWtXspA
+Si+Gt49xDOW0APmbOPnI+a4HJW6tVEo6MWS0WjzpiBayR3d1A4pt4YrPfSdDgpLo
+h2SLQqlRqvvVZJaWBjhkErNFpfsBA06sDcPEOb0G8LBUbR4WOcdvhe5LubJbZuxC
+AG9kNPCVeQP1ixwjgjXKysaxeQ6rv0VzIQgRp6tLVLWhy6AKDNvLjFSsmXZ1Wl08
+Y/RlOHXlzLuQMRE6sR1wOdRxc9TsrNWTGiBK65cvSWOy03JeBkQQ8pesqltiyxI9
+U21kkgiXtTSKNGfKK8pO27D81YANhRqPK7iTp6kuFiY2WtOg90KTMNlIT+Ff85Y2
+b1rHj6Z0SrCkJujhWk3IBPic/wJgz01LEc/OAdUPlby90RJZcIBhSlWhT7mXnXIO
+c0HWlNQrns2s3CTyYwZSiSlYe9ApeLwhjDo8NhbFuCAy61l6O5UsR4AfZxx/rGKv
+2wFb1/RN/P4gNe6vmxZAPjR0AQcwD3tc2McimOLr/22kmPz8IH3I0X7WoSFr0Biz
+E91G7bb0hOb/cA==
+=knv7
+-----END PGP PUBLIC KEY BLOCK-----
+AWS_CLI_PUBLIC_KEY
+  mkdir -m 700 "$temporary_directory/gnupg"
+  gpg --batch --homedir "$temporary_directory/gnupg" \
+    --import "$temporary_directory/aws-cli-public-key.asc" >/dev/null 2>&1
+  gpg --batch --homedir "$temporary_directory/gnupg" \
+    --verify "$temporary_directory/awscliv2.sig" \
+    "$temporary_directory/awscliv2.zip"
+  unzip -q "$temporary_directory/awscliv2.zip" -d "$temporary_directory"
+  as_root "$temporary_directory/aws/install" \
+    --install-dir /usr/local/aws-cli \
+    --bin-dir /usr/local/bin
+  rm -rf "$temporary_directory"
+  trap - EXIT
+}
+
+sanitize_session_name() {
+  local candidate
+  candidate="$(printf '%s' "${LISA_REMOTE_AGENT:-remote-agent}" \
+    | sed 's/[^A-Za-z0-9_+=,.@-]/-/g' \
+    | cut -c1-64)"
+  [ "${#candidate}" -ge 2 ] || candidate="remote-agent"
+  printf '%s\n' "$candidate"
+}
+
+install_base_tools
+install_aws_cli
+
+[ -z "${AWS_ACCESS_KEY_ID:-}" ] || fail \
+  "do not set AWS_ACCESS_KEY_ID directly; set only LISA_AWS_BOOTSTRAP_JSON so role profiles cannot be bypassed"
+[ -z "${AWS_SECRET_ACCESS_KEY:-}" ] || fail \
+  "do not set AWS_SECRET_ACCESS_KEY directly; set only LISA_AWS_BOOTSTRAP_JSON so role profiles cannot be bypassed"
+
+bootstrap_json="${LISA_AWS_BOOTSTRAP_JSON:-}"
+[ -n "$bootstrap_json" ] || fail "LISA_AWS_BOOTSTRAP_JSON is required"
+
+printf '%s' "$bootstrap_json" | jq -e '
+  type == "object" and
+  (.accessKeyId | type == "string" and length > 0) and
+  (.secretAccessKey | type == "string" and length > 0) and
+  (.externalId | type == "string" and length > 0) and
+  (.profiles | (type == "object" or type == "string"))
+' >/dev/null || fail "LISA_AWS_BOOTSTRAP_JSON is not a valid remote-agent bootstrap bundle"
+
+access_key_id="$(printf '%s' "$bootstrap_json" | jq -er '.accessKeyId')"
+secret_access_key="$(printf '%s' "$bootstrap_json" | jq -er '.secretAccessKey')"
+external_id="$(printf '%s' "$bootstrap_json" | jq -er '.externalId')"
+session_token="$(printf '%s' "$bootstrap_json" | jq -r '.sessionToken // empty')"
+profiles_json="$(printf '%s' "$bootstrap_json" | jq -c '
+  if (.profiles | type) == "string" then
+    .profiles | fromjson
+  else
+    .profiles
+  end
+')"
+
+printf '%s' "$profiles_json" | jq -e '
+  type == "object" and length > 0 and
+  all(to_entries[];
+    (.key | test("^[A-Za-z0-9_-]+$")) and
+    (.value.roleArn | type == "string" and startswith("arn:aws:iam::")) and
+    (.value.region | type == "string" and length > 0)
+  )
+' >/dev/null || fail "bootstrap profiles must map safe names to roleArn and region"
+
+mkdir -p "$HOME/.aws"
+chmod 700 "$HOME/.aws"
+
+aws configure set aws_access_key_id "$access_key_id" --profile "$BOOTSTRAP_PROFILE"
+aws configure set aws_secret_access_key "$secret_access_key" --profile "$BOOTSTRAP_PROFILE"
+if [ -n "$session_token" ]; then
+  aws configure set aws_session_token "$session_token" --profile "$BOOTSTRAP_PROFILE"
+fi
+
+session_name="$(sanitize_session_name)"
+while IFS=$'\t' read -r profile_name role_arn region; do
+  aws configure set role_arn "$role_arn" --profile "$profile_name"
+  aws configure set source_profile "$BOOTSTRAP_PROFILE" --profile "$profile_name"
+  aws configure set external_id "$external_id" --profile "$profile_name"
+  aws configure set role_session_name "$session_name" --profile "$profile_name"
+  aws configure set region "$region" --profile "$profile_name"
+done < <(printf '%s' "$profiles_json" | jq -r 'to_entries[] | [.key, .value.roleArn, .value.region] | @tsv')
+
+default_profile="${LISA_AWS_DEFAULT_PROFILE:-dev}"
+if ! printf '%s' "$profiles_json" | jq -e --arg profile "$default_profile" 'has($profile)' >/dev/null; then
+  default_profile="$(printf '%s' "$profiles_json" | jq -r 'keys[0]')"
+fi
+
+default_role_arn="$(printf '%s' "$profiles_json" | jq -er --arg profile "$default_profile" '.[$profile].roleArn')"
+default_region="$(printf '%s' "$profiles_json" | jq -er --arg profile "$default_profile" '.[$profile].region')"
+aws configure set role_arn "$default_role_arn" --profile default
+aws configure set source_profile "$BOOTSTRAP_PROFILE" --profile default
+aws configure set external_id "$external_id" --profile default
+aws configure set role_session_name "$session_name" --profile default
+aws configure set region "$default_region" --profile default
+
+chmod 600 "$HOME/.aws/credentials" "$HOME/.aws/config"
+
+if [ "${LISA_AWS_SKIP_VERIFY:-0}" != "1" ]; then
+  AWS_PAGER="" aws sts get-caller-identity --profile "$default_profile" >/dev/null
+fi
+
+profile_names="$(printf '%s' "$profiles_json" | jq -r 'keys | join(", ")')"
+echo "remote-agent-aws-setup: ready (${session_name}; default=${default_profile}; profiles=${profile_names})"

package/plugins/lisa-agy/skills/lisa-analyze-claude-remote/SKILL.md

@@ -150,24 +150,27 @@ Group the findings as:
      Terraform providers).
    - `aws sso login`, `aws:signin:*`, `sso_start_url`, `sso_account_id`, `sso_role_name`, or
      `sso_session` in docs or config.
-   - `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`, `AWS_DEFAULT_REGION`,
-     `AWS_PROFILE`, role ARN, external ID, account, or CloudWatch/STS references.
+   - `LISA_AWS_BOOTSTRAP_JSON`, legacy `AWS_ACCESS_KEY_ID` /
+     `AWS_SECRET_ACCESS_KEY`, `AWS_PROFILE`, role ARN, external ID, account, or
+     CloudWatch/STS references.
 
    If AWS is present, emit an AWS credential finding and inventory entry. If the repo's current
    local path is `aws sso login` or an `aws:signin:*` script, classify that local path as a `GAP`
    for headless remote routines: it is an interactive browser/device-authorization flow and cannot
    complete in the cloud. Route to the AWS row in the Credential reference instead of suggesting
-   SSO auth. The finding must name the headless substrate: a dedicated IAM principal (user or role)
-   with only permission to `sts:AssumeRole`, environment credentials in the routine UI, and
-   `~/.aws/config` profiles using `role_arn`, `credential_source = Environment`, optional
-   `external_id`, and `region`.
+   SSO auth. The finding must name Lisa's headless substrate: one dedicated IAM
+   user with only `sts:AssumeRole`; one complete Secrets Manager SecretString
+   set as `LISA_AWS_BOOTSTRAP_JSON`; and `/lisa:setup-remote-aws`, which writes a
+   named source profile plus automatically refreshed role profiles. Explicitly
+   reject standard `AWS_ACCESS_KEY_ID` variables because they can bypass the
+   intended assume-role profile.
 
    When the repository contains concrete non-secret AWS metadata (role ARNs, account aliases,
    profile names, regions, or ExternalId values), include it in an `awsProfiles` inventory array so
    `/lisa:generate-claude-remote-build-script` can write matching `~/.aws/config` profiles. Never
-   invent account IDs, ExternalIds, role names, or regions. If AWS is detected but profile metadata
-   is absent, emit the required AWS secret names plus an action to add project-specific profile
-   metadata to the generated artifact or environment notes.
+   invent account IDs, ExternalIds, role names, or regions. If AWS is detected
+   but profile metadata is absent, require a cdkstarter bootstrap bundle rather
+   than asking the repository to reconstruct account metadata by hand.
 
 5. **MCP servers** — read every committed `.mcp.json`. For each server report transport and auth.
    Project-scoped HTTP/SSE servers with no interactive auth are `OK`. Flag stdio servers as
@@ -276,14 +279,14 @@ unsuffixed `…_TOKEN`/`…_KEY` is the simplest to set in a single-account rout
 - Access: the personal API key inherits the user's workspace permissions — the user must be able to read/create/update Issues in the destination team.
 
 ### AWS — host-project operations, logs, deploys, CDK/Serverless/SST, or AWS SDK usage
-- Headless substrate: a dedicated IAM principal (user or role) with long-lived bootstrap credentials
-  stored in the routine environment, used only to call `sts:AssumeRole` into per-account operational
-  roles. The routine writes `~/.aws/config` profiles with `role_arn`, `credential_source =
-  Environment`, optional `external_id`, and `region`; agents use `aws --profile <profile> ...`.
-- Env: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`; optional `AWS_SESSION_TOKEN` for temporary
-  bootstrap credentials; `AWS_DEFAULT_REGION` when no profile region is provided. Role ARNs,
-  ExternalIds, profile names, and regions are non-secret project metadata and belong in generated
-  artifacts or project docs, not in the skill's global guidance.
+- Headless substrate: cdkstarter's vendor-neutral remote-agent kit. Its single
+  Secrets Manager SecretString contains the assume-only access key, ExternalId,
+  and per-account role metadata. `/lisa:setup-remote-aws` writes a private named
+  source profile and renewable role profiles; agents use
+  `aws --profile <profile> ...`.
+- Env: `LISA_AWS_BOOTSTRAP_JSON` (secret, required) and
+  `LISA_REMOTE_AGENT` (plain platform label). Do not set `AWS_ACCESS_KEY_ID` or
+  `AWS_SECRET_ACCESS_KEY` in the remote environment.
 - Allowlist: `*.amazonaws.com`, or narrower service hosts such as `sts.amazonaws.com`,
   `logs.<region>.amazonaws.com`, `cloudwatch.<region>.amazonaws.com`,
   `xray.<region>.amazonaws.com`, `ssm.<region>.amazonaws.com`, and service-specific endpoints the
@@ -366,7 +369,7 @@ so the generator can render acquisition comments into its template:
     {
       "name": "dev",
       "roleArn": "arn:aws:iam::<account-id>:role/<role-name>",
-      "credentialSource": "Environment",
+      "credentialSource": "lisa-remote-agent-bootstrap",
       "externalId": "<project-external-id>",
       "region": "us-east-1"
     }