thinkwork-cli 0.13.1 → 1.0.0

package/dist/terraform/modules/app/agentcore-code-interpreter/sandbox/sitecustomize.py

@@ -1,227 +0,0 @@
-"""sitecustomize — primary R13 token redactor for the AgentCore sandbox base image.
-
-Python auto-imports any module named ``sitecustomize`` during interpreter
-startup (before user code, before the preamble, before framework tracebacks on
-cold start). This file installs a stdio write-wrapper keyed on a session-scoped
-set of token values so no token leaks to stdout / stderr via Python-stdio
-writes.
-
-The invariant is honestly scoped per the brainstorm's R13 (as aligned in
-docs/brainstorms/2026-04-22-agentcore-code-sandbox-requirements.md):
-
-  "no token value reaches a persisted log ... via Python-stdio-mediated writes"
-
-Bytes that bypass Python stdio (``os.write(fd, ...)``, subprocesses inheriting
-fds, C extensions, multiprocessing children) are the named residual class
-covered by the Unit 12 CloudWatch subscription-filter backstop for known
-OAuth prefixes, not by this module.
-
-Public API, callable from the sandbox preamble:
-  register_token(value: str) -> None
-  register_tokens(values: Iterable[str]) -> None
-  clear_tokens() -> None
-  installed() -> bool
-"""
-
-from __future__ import annotations
-
-import base64
-import binascii
-import os
-import sys
-import urllib.parse
-from collections.abc import Iterable
-from typing import Any
-
-# ---------------------------------------------------------------------------
-# Module state
-# ---------------------------------------------------------------------------
-
-# Every unique byte-sequence we redact. Populated by ``register_token`` — each
-# registered token expands into its cleartext, standard base64, URL-safe
-# base64, URL-encoded, and hex forms (only the forms whose length is at least
-# MIN_TOKEN_LEN, to avoid redacting short accidental matches like "AQ").
-_redactions: set[bytes] = set()
-
-# Redaction placeholder. Length unimportant — stream layout survives because
-# writes stay synchronous.
-_REDACTION = b"<redacted>"
-
-# Forms shorter than this are rejected — redacting 3-character strings is the
-# shape of a wildcard bug, not a security control.
-MIN_TOKEN_LEN = 12
-
-# Rolling-suffix buffer size. Set at ``register_token`` time to
-# max(existing, 2 * len(new_token_form)). The wrapper keeps this many bytes
-# from the previous write and prepends them to the current write before
-# searching, so a token split across two ``write()`` calls is caught as long
-# as neither split half exceeds the buffer. Adversarial fragmentation at
-# arbitrary positions is a named residual (see R13).
-_rolling_buffer_size: int = 0
-
-
-def _expand(value: str) -> list[bytes]:
-    """Return the encoded forms of a token value we treat as equivalent.
-
-    Each form is added to the redaction set so ``print(base64.b64encode(token))``
-    and the cleartext ``print(token)`` are both scrubbed.
-    """
-    if not value:
-        return []
-    raw = value.encode("utf-8")
-    forms: list[bytes] = []
-
-    def maybe_add(candidate: bytes) -> None:
-        if len(candidate) >= MIN_TOKEN_LEN:
-            forms.append(candidate)
-
-    maybe_add(raw)
-    maybe_add(base64.b64encode(raw).rstrip(b"="))
-    maybe_add(base64.b64encode(raw))
-    maybe_add(base64.urlsafe_b64encode(raw).rstrip(b"="))
-    maybe_add(base64.urlsafe_b64encode(raw))
-    maybe_add(urllib.parse.quote(value, safe="").encode("ascii"))
-    maybe_add(binascii.hexlify(raw))
-    return forms
-
-
-def register_token(value: str) -> None:
-    """Add a token (and its derived encodings) to the redaction set.
-
-    Safe to call multiple times with the same value. No-op for empty values.
-    """
-    global _rolling_buffer_size
-    for form in _expand(value):
-        _redactions.add(form)
-        required = 2 * len(form)
-        if required > _rolling_buffer_size:
-            _rolling_buffer_size = required
-
-
-def register_tokens(values: Iterable[str]) -> None:
-    for v in values:
-        register_token(v)
-
-
-def clear_tokens() -> None:
-    """Drop every registered token. Called at session teardown by the container."""
-    global _rolling_buffer_size
-    _redactions.clear()
-    _rolling_buffer_size = 0
-
-
-# ---------------------------------------------------------------------------
-# Stdio wrapper
-# ---------------------------------------------------------------------------
-
-
-def _redact(chunk: bytes, tail_buffer: bytearray) -> tuple[bytes, bytearray]:
-    """Return (scrubbed_output_chunk, new_tail_buffer).
-
-    The tail buffer holds the trailing N bytes of the previous write so we can
-    catch tokens split across write boundaries. The output we emit is the part
-    of ``tail_buffer + chunk`` that is safely past the trailing window; the
-    suffix stays in the new tail for the next call.
-    """
-    if not _redactions:
-        return chunk, tail_buffer
-
-    combined = bytes(tail_buffer) + chunk
-    for form in _redactions:
-        combined = combined.replace(form, _REDACTION)
-
-    if _rolling_buffer_size and len(combined) > _rolling_buffer_size:
-        emit = combined[:-_rolling_buffer_size]
-        new_tail = bytearray(combined[-_rolling_buffer_size:])
-    else:
-        emit = b""
-        new_tail = bytearray(combined)
-
-    return emit, new_tail
-
-
-class _RedactingStream:
-    """Wraps sys.stdout / sys.stderr's underlying buffer with a redactor.
-
-    Intercepts both ``write(str)`` (TextIOBase) and ``.buffer.write(bytes)``
-    paths so ``print(...)``, ``sys.stdout.write(...)``, and
-    ``sys.stdout.buffer.write(...)`` all flow through the scrubber.
-    """
-
-    def __init__(self, wrapped: Any, name: str) -> None:
-        self._wrapped = wrapped
-        self._name = name
-        self._tail = bytearray()
-        # AgentCore writes to stdout/stderr line-buffered; we flush our tail
-        # on every newline-terminated write so output appears promptly.
-
-    def write(self, data: Any) -> int:
-        if isinstance(data, str):
-            payload = data.encode("utf-8", errors="replace")
-            wrote_str = True
-        elif isinstance(data, (bytes, bytearray, memoryview)):
-            payload = bytes(data)
-            wrote_str = False
-        else:
-            # Defer unknown types to the wrapped object — let it raise.
-            return self._wrapped.write(data)
-
-        emit, self._tail = _redact(payload, self._tail)
-        # A newline forces a tail flush so output doesn't lag arbitrarily when
-        # no new writes arrive. This is a UX concession, not a security one —
-        # redaction is complete whether we flush or not.
-        if b"\n" in payload:
-            emit = emit + bytes(self._tail)
-            self._tail = bytearray()
-
-        if not emit:
-            return len(data) if wrote_str else len(payload)
-
-        if wrote_str:
-            self._wrapped.write(emit.decode("utf-8", errors="replace"))
-        else:
-            # TextIOWrapper.write raises on bytes; prefer the underlying buffer.
-            buf = getattr(self._wrapped, "buffer", None)
-            if buf is not None:
-                buf.write(emit)
-            else:
-                self._wrapped.write(emit)
-        return len(data) if wrote_str else len(payload)
-
-    def flush(self) -> None:
-        if self._tail:
-            data = bytes(self._tail)
-            self._tail = bytearray()
-            buf = getattr(self._wrapped, "buffer", None)
-            if buf is not None:
-                buf.write(data)
-            else:
-                self._wrapped.write(data.decode("utf-8", errors="replace"))
-        self._wrapped.flush()
-
-    # Forward any other attribute access (fileno, isatty, encoding, etc.) so
-    # libraries that introspect the stream still see what they expect.
-    def __getattr__(self, item: str) -> Any:
-        return getattr(self._wrapped, item)
-
-
-_installed = False
-
-
-def installed() -> bool:
-    return _installed
-
-
-def _install() -> None:
-    global _installed
-    if _installed:
-        return
-    sys.stdout = _RedactingStream(sys.stdout, "stdout")
-    sys.stderr = _RedactingStream(sys.stderr, "stderr")
-    _installed = True
-
-
-# Install unconditionally on import. Disable only for a pytest diagnostic
-# marker the test suite can opt out of (set THINKWORK_SANDBOX_SCRUBBER=off).
-if os.environ.get("THINKWORK_SANDBOX_SCRUBBER", "on") != "off":
-    _install()

package/dist/terraform/modules/app/agentcore-code-interpreter/sandbox/test_sitecustomize.py

@@ -1,277 +0,0 @@
-"""Unit tests for the AgentCore sandbox base-image stdio token redactor.
-
-Tests hit ``_RedactingStream`` directly with a test-owned stream instead of
-mutating ``sys.stdout`` — that side-steps pytest's capture machinery, which
-owns sys.stdout at test time and would otherwise see writes before the
-wrapper does. Correctness of the sys.stdout replacement path is proven by
-a separate end-to-end test that runs the module as a subprocess with its
-auto-install path active.
-"""
-
-from __future__ import annotations
-
-import base64
-import binascii
-import importlib.util
-import io
-import os
-import subprocess
-import sys
-import urllib.parse
-
-import pytest
-
-os.environ["THINKWORK_SANDBOX_SCRUBBER"] = "off"
-
-_HERE = os.path.dirname(os.path.abspath(__file__))
-_SPEC = importlib.util.spec_from_file_location(
-    "sandbox_base_sitecustomize",
-    os.path.join(_HERE, "sitecustomize.py"),
-)
-assert _SPEC is not None and _SPEC.loader is not None
-sc = importlib.util.module_from_spec(_SPEC)
-_SPEC.loader.exec_module(sc)
-
-
-class _StringSink:
-    """Minimal sys.stdout-shaped target: the wrapper writes strings into us,
-    we collect them as UTF-8 bytes. Also exposes ``.buffer`` so bytes-path
-    writes have a path through the wrapper."""
-
-    def __init__(self) -> None:
-        self.str_bytes = bytearray()
-        self.buffer = io.BytesIO()
-        self.name = "test-sink"
-        self.encoding = "utf-8"
-        self.errors = "strict"
-
-    def write(self, s: str) -> int:
-        self.str_bytes.extend(s.encode("utf-8", errors="replace"))
-        return len(s)
-
-    def flush(self) -> None:
-        pass
-
-    def captured(self) -> str:
-        combined = bytes(self.str_bytes) + self.buffer.getvalue()
-        return combined.decode("utf-8", errors="replace")
-
-
-@pytest.fixture
-def wrapper() -> tuple:
-    """A fresh redactor wrapping a new sink, with an empty token set."""
-    sc.clear_tokens()
-    sink = _StringSink()
-    stream = sc._RedactingStream(sink, "test-stdout")  # type: ignore[attr-defined]
-    yield stream, sink
-    stream.flush()
-    sc.clear_tokens()
-
-
-def test_cleartext_is_redacted(wrapper):
-    stream, sink = wrapper
-    token = "ghp_abc123abc123abc123"
-    sc.register_token(token)
-    stream.write(f"the token was {token} and not noticeable\n")
-    stream.flush()
-    text = sink.captured()
-    assert token not in text
-    assert "<redacted>" in text
-    assert "the token was" in text
-
-
-def test_base64_form_is_redacted(wrapper):
-    stream, sink = wrapper
-    token = "ghp_abc123abc123abc123"
-    sc.register_token(token)
-    encoded = base64.b64encode(token.encode()).decode()
-    stream.write(f"encoded={encoded}\n")
-    stream.flush()
-    text = sink.captured()
-    assert encoded not in text
-    assert "<redacted>" in text
-
-
-def test_urlsafe_base64_form_is_redacted(wrapper):
-    stream, sink = wrapper
-    token = "some_opaque_secret_for_urlsafe"
-    sc.register_token(token)
-    encoded = base64.urlsafe_b64encode(token.encode()).decode()
-    stream.write(f"encoded={encoded}\n")
-    stream.flush()
-    text = sink.captured()
-    assert encoded not in text
-    assert "<redacted>" in text
-
-
-def test_url_encoded_form_is_redacted(wrapper):
-    stream, sink = wrapper
-    token = "token with spaces & special=chars"
-    sc.register_token(token)
-    encoded = urllib.parse.quote(token, safe="")
-    stream.write(f"in_url={encoded}\n")
-    stream.flush()
-    text = sink.captured()
-    assert encoded not in text
-    assert "<redacted>" in text
-
-
-def test_hex_form_is_redacted(wrapper):
-    stream, sink = wrapper
-    token = "0123456789abcdef01234567"
-    sc.register_token(token)
-    encoded = binascii.hexlify(token.encode()).decode()
-    stream.write(f"hex={encoded}\n")
-    stream.flush()
-    text = sink.captured()
-    assert encoded not in text
-    assert "<redacted>" in text
-
-
-def test_register_after_first_write_still_redacts_subsequent(wrapper):
-    stream, sink = wrapper
-    stream.write("before registration\n")
-    token = "late_registered_token_value"
-    sc.register_token(token)
-    stream.write(f"after {token} registration\n")
-    stream.flush()
-    text = sink.captured()
-    assert "before registration" in text
-    assert token not in text
-    assert "<redacted>" in text
-
-
-def test_split_write_across_boundary_is_caught(wrapper):
-    stream, sink = wrapper
-    token = "ghp_splitfragmenttokenvalue"
-    sc.register_token(token)
-    stream.write(token[:10])
-    stream.write(token[10:])
-    stream.write("\n")
-    stream.flush()
-    text = sink.captured()
-    assert token not in text
-    assert "<redacted>" in text
-
-
-def test_short_token_below_min_len_is_ignored(wrapper):
-    """Redacting 3-char strings would produce wildcard false-positives."""
-    stream, sink = wrapper
-    sc.register_token("AQ")
-    stream.write("AQ should appear unchanged because AQ is too short to redact\n")
-    stream.flush()
-    text = sink.captured()
-    assert "AQ" in text
-    assert "<redacted>" not in text
-
-
-def test_bytes_path_through_buffer(wrapper):
-    stream, sink = wrapper
-    token = "some_token_value_we_registered"
-    sc.register_token(token)
-    # Write bytes through the wrapper — it routes into sink.buffer.
-    stream.write(b"\x00\x01\x02binary with " + token.encode() + b" embedded\n")
-    stream.flush()
-    text = sink.captured()
-    assert token not in text
-    assert "<redacted>" in text
-    assert "binary with" in text
-
-
-def test_clear_tokens_disables_redaction_for_later_writes(wrapper):
-    stream, sink = wrapper
-    token = "a_token_that_will_be_cleared_soon"
-    sc.register_token(token)
-    stream.write(f"before clear: {token}\n")
-    sc.clear_tokens()
-    stream.write(f"after clear: {token}\n")
-    stream.flush()
-    text = sink.captured()
-    assert text.count("<redacted>") == 1
-    assert text.count(token) == 1
-
-
-def test_register_tokens_plural_is_equivalent(wrapper):
-    stream, sink = wrapper
-    sc.register_tokens(["first_registered_token_abc", "second_registered_token_def"])
-    stream.write("first_registered_token_abc / second_registered_token_def\n")
-    stream.flush()
-    text = sink.captured()
-    assert "first_registered_token_abc" not in text
-    assert "second_registered_token_def" not in text
-    assert text.count("<redacted>") >= 2
-
-
-def test_empty_token_is_ignored(wrapper):
-    stream, sink = wrapper
-    sc.register_token("")
-    stream.write("nothing to redact here\n")
-    stream.flush()
-    text = sink.captured()
-    assert "nothing to redact here" in text
-    assert "<redacted>" not in text
-
-
-def test_no_crash_on_raw_bytes_without_matching_token(wrapper):
-    stream, sink = wrapper
-    sc.register_token("something_registered_but_not_present")
-    stream.write(b"\x00\x01\x02binary bytes\n")
-    stream.flush()
-    text = sink.captured()
-    assert "binary bytes" in text
-
-
-# --- End-to-end: the auto-install path ---------------------------------------
-#
-# Tests above exercise _RedactingStream directly, which is fine for the
-# redaction logic itself but bypasses the sitecustomize auto-install step
-# that replaces sys.stdout on interpreter startup. This subprocess test
-# proves that step works — a fresh Python process, with PYTHONPATH pointed
-# at the module directory and THINKWORK_SANDBOX_SCRUBBER unset, installs
-# the wrapper on its own and redacts a registered token before stdout is
-# flushed.
-
-
-def test_auto_install_redacts_on_fresh_interpreter(tmp_path):
-    script = tmp_path / "run.py"
-    script.write_text(
-        """
-import sys, sitecustomize
-sitecustomize.register_token("ghp_autoInstallValueTokenX")
-print("auto-install redacts ghp_autoInstallValueTokenX mid-line here")
-""".strip()
-    )
-    env = os.environ.copy()
-    # Strip our opt-out so sitecustomize installs on import.
-    env.pop("THINKWORK_SANDBOX_SCRUBBER", None)
-    # Prepend the module dir so Python's startup hook finds our
-    # sitecustomize.py before any installed one.
-    env["PYTHONPATH"] = _HERE + os.pathsep + env.get("PYTHONPATH", "")
-    out = subprocess.run(
-        [sys.executable, str(script)],
-        env=env,
-        check=True,
-        capture_output=True,
-        text=True,
-    )
-    assert "ghp_autoInstallValueTokenX" not in out.stdout
-    assert "<redacted>" in out.stdout
-    assert "auto-install redacts" in out.stdout
-
-
-def test_installed_reports_true_after_auto_install(tmp_path):
-    """Probe ``installed()`` from a fresh interpreter — confirms the startup
-    hook ran (and set the flag)."""
-    script = tmp_path / "run.py"
-    script.write_text("import sitecustomize; print(sitecustomize.installed())")
-    env = os.environ.copy()
-    env.pop("THINKWORK_SANDBOX_SCRUBBER", None)
-    env["PYTHONPATH"] = _HERE + os.pathsep + env.get("PYTHONPATH", "")
-    out = subprocess.run(
-        [sys.executable, str(script)],
-        env=env,
-        check=True,
-        capture_output=True,
-        text=True,
-    )
-    assert out.stdout.strip() == "True"

package/dist/terraform/modules/app/agentcore-code-interpreter/scripts/build_and_push_sandbox_base.sh

@@ -1,70 +0,0 @@
-#!/usr/bin/env bash
-################################################################################
-# build_and_push_sandbox_base.sh — build + push the AgentCore sandbox base
-# image to the stage's ECR repo. Invoked by CI; also safe to run locally
-# once ``thinkwork doctor`` reports green.
-#
-# Usage (from repo root):
-#   bash terraform/modules/app/agentcore-code-interpreter/scripts/build_and_push_sandbox_base.sh \
-#        --stage dev --region us-east-1
-#
-# The script:
-#   1. Reads the ECR repo URL from ``terraform output -raw`` (must be run
-#      after ``terraform apply`` lands the agentcore-code-interpreter
-#      module for the target stage).
-#   2. docker build the Dockerfile.sandbox-base with the repo root as
-#      context (so the COPY can reach packages/).
-#   3. Tags with the current git SHA (immutable tag per the ECR repo
-#      config) and ``:latest``.
-#   4. docker push both tags after ``aws ecr get-login-password``.
-################################################################################
-set -euo pipefail
-
-STAGE=""
-REGION=""
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --stage)   STAGE="$2";   shift 2 ;;
-    --region)  REGION="$2";  shift 2 ;;
-    *)         echo "unknown arg: $1" >&2; exit 2 ;;
-  esac
-done
-
-: "${STAGE:?--stage is required}"
-: "${REGION:?--region is required}"
-
-# Resolve the repo URL from terraform state. Tolerant: if the caller runs
-# this before the module applies, fall back to the deterministic name.
-REPO_URL="$(
-  terraform -chdir="terraform/examples/greenfield" output -raw \
-    sandbox_base_ecr_repository_url 2>/dev/null \
-    || echo ""
-)"
-if [[ -z "$REPO_URL" ]]; then
-  ACCOUNT_ID="$(aws sts get-caller-identity --query Account --output text)"
-  REPO_URL="${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/thinkwork-${STAGE}-sandbox-base"
-fi
-
-GIT_SHA="$(git rev-parse --short HEAD)"
-IMAGE_TAG="${GIT_SHA}"
-
-echo "[sandbox-base] repo: ${REPO_URL}"
-echo "[sandbox-base] tag:  ${IMAGE_TAG}"
-
-# ECR login
-aws ecr get-login-password --region "${REGION}" \
-  | docker login --username AWS --password-stdin "${REPO_URL%/*}"
-
-# Build with repo root as the context so COPY can reach packages/.
-docker build \
-  --platform=linux/amd64 \
-  -f terraform/modules/app/agentcore-code-interpreter/Dockerfile.sandbox-base \
-  -t "${REPO_URL}:${IMAGE_TAG}" \
-  -t "${REPO_URL}:latest" \
-  .
-
-docker push "${REPO_URL}:${IMAGE_TAG}"
-docker push "${REPO_URL}:latest"
-
-echo "[sandbox-base] pushed ${REPO_URL}:${IMAGE_TAG}"

package/dist/terraform/modules/app/agentcore-harness/main.tf

@@ -1,101 +0,0 @@
-################################################################################
-# AgentCore Harness — App Module (THINK-311 U4, ship-inert)
-#
-# IAM surface for the AWS Bedrock AgentCore Harness trial: the execution role
-# Harness microVMs assume, plus (via outputs consumed by lambda-api's grouped
-# policies) the invoker grants the shared api Lambda role needs to create and
-# invoke Harness resources. Nothing reads or invokes any of this until the
-# harness-runner handler lands in U5 — this module is pure IAM.
-#
-# Trust-policy note: sibling agentcore roles (agentcore-pi, agentcore-runtime)
-# trust the bare `bedrock-agentcore.amazonaws.com` service principal with no
-# account/source-arn conditions; this role mirrors that repo pattern.
-################################################################################
-
-################################################################################
-# Harness execution role — assumed by Harness microVMs
-################################################################################
-
-resource "aws_iam_role" "harness_execution" {
-  count = var.enabled ? 1 : 0
-
-  name = "thinkwork-${var.stage}-agentcore-harness-role"
-
-  assume_role_policy = jsonencode({
-    Version = "2012-10-17"
-    Statement = [{
-      Effect    = "Allow"
-      Principal = { Service = "bedrock-agentcore.amazonaws.com" }
-      Action    = "sts:AssumeRole"
-    }]
-  })
-
-  tags = {
-    Name = "thinkwork-${var.stage}-agentcore-harness-role"
-  }
-}
-
-resource "aws_iam_role_policy" "harness_execution" {
-  count = var.enabled ? 1 : 0
-
-  name = "agentcore-harness-permissions"
-  role = aws_iam_role.harness_execution[0].id
-
-  policy = jsonencode({
-    Version = "2012-10-17"
-    Statement = [
-      {
-        # Cross-region inference profiles (us.anthropic.claude-*) require
-        # `bedrock:InvokeModel` on the *inference-profile* ARN AND on the
-        # underlying foundation-model ARN in every region the profile can
-        # route to — same resource list the api Lambda's grouped ai policy
-        # uses (see ../lambda-api/iam-grouped.tf "bedrock-invoke").
-        Sid    = "BedrockInvoke"
-        Effect = "Allow"
-        Action = ["bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream"]
-        Resource = [
-          "arn:aws:bedrock:*::foundation-model/*",
-          "arn:aws:bedrock:*:${var.account_id}:inference-profile/*",
-        ]
-      },
-      {
-        # Tenant skill catalog sources + materialized workspace skill folders
-        # live under tenants/* in the stage workspace bucket. Read-only —
-        # Harness microVMs never write back to the workspace bucket.
-        Sid      = "WorkspaceSkillSourcesRead"
-        Effect   = "Allow"
-        Action   = ["s3:GetObject"]
-        Resource = "arn:aws:s3:::${var.bucket_name}/tenants/*"
-      },
-      {
-        Sid      = "WorkspaceSkillSourcesList"
-        Effect   = "Allow"
-        Action   = ["s3:ListBucket"]
-        Resource = "arn:aws:s3:::${var.bucket_name}"
-        Condition = {
-          StringLike = {
-            "s3:prefix" = "tenants/*"
-          }
-        }
-      },
-      {
-        # Harness containers log to the service-managed bedrock-agentcore
-        # log-group namespace, mirroring the agentcore-pi role's runtimes
-        # grant.
-        Sid    = "CloudWatchLogs"
-        Effect = "Allow"
-        Action = [
-          "logs:CreateLogGroup",
-          "logs:CreateLogStream",
-          "logs:DescribeLogGroups",
-          "logs:DescribeLogStreams",
-          "logs:PutLogEvents",
-        ]
-        Resource = [
-          "arn:aws:logs:${var.region}:${var.account_id}:log-group:/aws/bedrock-agentcore/*",
-          "arn:aws:logs:${var.region}:${var.account_id}:log-group:/aws/bedrock-agentcore/*:*",
-        ]
-      },
-    ]
-  })
-}

package/dist/terraform/modules/app/agentcore-harness/outputs.tf

@@ -1,9 +0,0 @@
-output "execution_role_arn" {
-  description = "ARN of the Harness execution role (CreateHarness executionRoleArn). Empty string when the module is disabled."
-  value       = var.enabled ? aws_iam_role.harness_execution[0].arn : ""
-}
-
-output "execution_role_name" {
-  description = "Name of the Harness execution role. Empty string when the module is disabled."
-  value       = var.enabled ? aws_iam_role.harness_execution[0].name : ""
-}