Skip to content

Automate browser based workflows with AI

fix(SKY-10347): resolve embedded multi-placeholder secrets in workflow credentials (#6245)

LawyZhenga9a09ee5afbc
diff --git a/skyvern/forge/sdk/workflow/context_manager.py b/skyvern/forge/sdk/workflow/context_manager.py
index 59ff89e0c..ee77da171 100644
--- a/skyvern/forge/sdk/workflow/context_manager.py
+++ b/skyvern/forge/sdk/workflow/context_manager.py
@@ -412,13 +412,76 @@ class WorkflowRunContext:
return None
if isinstance(secret_id_or_value, str):
if secret_id_or_value.startswith(RANDOM_SECRET_ID_PREFIX):
- if secret_id_or_value not in self.secrets:
- raise ImaginarySecretValue(secret_id_or_value)
- return self.secrets[secret_id_or_value]
+ if secret_id_or_value in self.secrets:
+ return self.secrets[secret_id_or_value]
+ resolved = self._resolve_embedded_placeholders(secret_id_or_value)
+ if resolved is not None:
+ return resolved
+ raise ImaginarySecretValue(secret_id_or_value)
else:
- return self.secrets.get(secret_id_or_value)
+ direct = self.secrets.get(secret_id_or_value)
+ if direct is not None:
+ return direct
+ if RANDOM_SECRET_ID_PREFIX in secret_id_or_value:
+ resolved = self._resolve_embedded_placeholders(secret_id_or_value)
+ if resolved is not None:
+ return resolved
+ remaining = secret_id_or_value
+ for key in self.secrets:
+ remaining = remaining.replace(key, "")
+ if RANDOM_SECRET_ID_PREFIX in remaining:
+ raise ImaginarySecretValue(secret_id_or_value)
+ return None
return None
+ def _scan_placeholder_tokens(self, text: str) -> list[str]:
+ """Scan *text* for registered placeholder keys, longest-first.
+
+ TODO: Define placeholder token boundaries before changing this to
+ reject prefix matches such as ``placeholder_AAAA_month_extra``; cases
+ like ``placeholder_AAAA_month-extra`` need an explicit grammar.
+ """
+ known_keys = sorted(
+ (k for k in self.secrets if k.startswith(RANDOM_SECRET_ID_PREFIX)),
+ key=len,
+ reverse=True,
+ )
+ tokens: list[str] = []
+ scan = text
+ while scan:
+ matched = False
+ for key in known_keys:
+ if scan.startswith(key):
+ tokens.append(key)
+ scan = scan[len(key) :]
+ matched = True
+ break
+ if not matched:
+ scan = scan[1:]
+ return tokens
+
+ def _resolve_embedded_placeholders(self, text: str) -> str | None:
+ """Resolve a string containing multiple embedded placeholder tokens.
+
+ Returns the substituted string, or None if fewer than 2 registered
+ tokens were found. Raises ImaginarySecretValue if any ``placeholder_``
+ substring remains after substitution (unknown token).
+ """
+ tokens_found = self._scan_placeholder_tokens(text)
+ if len(tokens_found) < 2:
+ return None
+
+ result = text
+ for token in tokens_found:
+ result = result.replace(token, self.secrets[token], 1)
+ if RANDOM_SECRET_ID_PREFIX in result:
+ raise ImaginarySecretValue(text)
+ return result
+
+ def find_embedded_placeholder_tokens(self, text: str) -> list[str]:
+ """Extract registered placeholder tokens found in *text*, longest-first."""
+ return self._scan_placeholder_tokens(text)
+
def mask_secrets_in_data(self, data: Any, mask: str = "*****") -> Any:
"""
Recursively replace any real secret values in data with a mask.
diff --git a/skyvern/webeye/actions/handler.py b/skyvern/webeye/actions/handler.py
index 3f1614ebf..6b3cb5ccb 100644
--- a/skyvern/webeye/actions/handler.py
+++ b/skyvern/webeye/actions/handler.py
@@ -3083,6 +3083,8 @@ def get_actual_value_of_parameter_if_secret(workflow_run_id: str, parameter: str
secret_value = workflow_run_context.get_original_secret_value_or_none(parameter)
if secret_value is not None:
credential_parameter_key = workflow_run_context.find_credential_parameter_key_for_secret(parameter)
+ if credential_parameter_key is None and secret_value != parameter:
+ credential_parameter_key = _find_credential_key_for_embedded_placeholders(workflow_run_context, parameter)
if credential_parameter_key is not None:
current_context = skyvern_context.current()
if current_context is not None:
@@ -3090,6 +3092,18 @@ def get_actual_value_of_parameter_if_secret(workflow_run_id: str, parameter: str
return secret_value if secret_value is not None else parameter
+def _find_credential_key_for_embedded_placeholders(workflow_run_context: Any, parameter: str) -> str | None:
+ tokens = workflow_run_context.find_embedded_placeholder_tokens(parameter)
+ if not tokens:
+ return None
+ keys: set[str | None] = set()
+ for token in tokens:
+ key = workflow_run_context.find_credential_parameter_key_for_secret(token)
+ keys.add(key)
+ keys.discard(None)
+ return keys.pop() if len(keys) == 1 else None
+
+
def get_actual_value_of_parameter_if_secret_with_task(task: Task, parameter: str) -> Any:
"""
Get the actual value of a parameter if it's a secret. If it's not a secret, return the parameter value as is.
diff --git a/tests/unit/test_multi_placeholder_secret_resolution.py b/tests/unit/test_multi_placeholder_secret_resolution.py
new file mode 100644
index 000000000..fd33d4026
--- /dev/null
+++ b/tests/unit/test_multi_placeholder_secret_resolution.py
@@ -0,0 +1,212 @@
+"""Tests for multi-placeholder secret resolution in WorkflowRunContext."""
+
+from __future__ import annotations
+
+import pytest
+
+from skyvern.exceptions import ImaginarySecretValue
+from skyvern.forge.sdk.workflow.context_manager import WorkflowRunContext
+
+
+def _make_context(secrets: dict[str, str]) -> WorkflowRunContext:
+ ctx = WorkflowRunContext.__new__(WorkflowRunContext)
+ ctx.secrets = dict(secrets)
+ ctx.values = {}
+ ctx.parameters = {}
+ ctx.credential_totp_identifiers = {}
+ return ctx
+
+
+class TestSinglePlaceholderRegression:
+ def test_exact_match_resolves(self) -> None:
+ ctx = _make_context({"placeholder_VAZA_card_number": "4111111111111111"})
+ assert ctx.get_original_secret_value_or_none("placeholder_VAZA_card_number") == "4111111111111111"
+
+ def test_unknown_single_placeholder_raises(self) -> None:
+ ctx = _make_context({"placeholder_VAZA_card_number": "4111111111111111"})
+ with pytest.raises(ImaginarySecretValue):
+ ctx.get_original_secret_value_or_none("placeholder_XXXX_unknown")
+
+ def test_non_placeholder_string_returns_none(self) -> None:
+ ctx = _make_context({"placeholder_VAZA_card_number": "4111111111111111"})
+ assert ctx.get_original_secret_value_or_none("some_regular_text") is None
+
+ def test_empty_secrets_returns_none(self) -> None:
+ ctx = _make_context({})
+ assert ctx.get_original_secret_value_or_none("placeholder_VAZA_card_number") is None
+
+
+class TestMultiPlaceholderResolution:
+ def test_combined_month_year_resolves_with_separator(self) -> None:
+ ctx = _make_context(
+ {
+ "placeholder_zqHf_card_exp_month": "05",
+ "placeholder_CDFg_card_exp_year": "29",
+ }
+ )
+ result = ctx.get_original_secret_value_or_none(
+ "placeholder_zqHf_card_exp_month / placeholder_CDFg_card_exp_year"
+ )
+ assert result == "05 / 29"
+
+ def test_combined_without_spaces(self) -> None:
+ ctx = _make_context(
+ {
+ "placeholder_aaaa_month": "12",
+ "placeholder_bbbb_year": "2027",
+ }
+ )
+ result = ctx.get_original_secret_value_or_none("placeholder_aaaa_month/placeholder_bbbb_year")
+ assert result == "12/2027"
+
+ def test_repeated_placeholder_replaced_consistently(self) -> None:
+ ctx = _make_context({"placeholder_aaaa_val": "hello"})
+ result = ctx.get_original_secret_value_or_none("placeholder_aaaa_val and placeholder_aaaa_val")
+ assert result == "hello and hello"
+
+ def test_overlapping_keys_chooses_longest(self) -> None:
+ ctx = _make_context(
+ {
+ "placeholder_ab_x": "short",
+ "placeholder_ab_x_extended": "long",
+ }
+ )
+ result = ctx.get_original_secret_value_or_none("placeholder_ab_x_extended")
+ assert result == "long"
+
+ def test_mixed_known_unknown_starting_with_placeholder_raises(self) -> None:
+ ctx = _make_context({"placeholder_aaaa_month": "05"})
+ with pytest.raises(ImaginarySecretValue):
+ ctx.get_original_secret_value_or_none("placeholder_aaaa_month / placeholder_XXXX_unknown")
+
+ def test_mixed_known_unknown_with_prefix_text_raises(self) -> None:
+ ctx = _make_context({"placeholder_aaaa_month": "05"})
+ with pytest.raises(ImaginarySecretValue):
+ ctx.get_original_secret_value_or_none("Prefix placeholder_aaaa_month / placeholder_XXXX_unknown")
+
+ def test_preserves_separator_and_trailing_text(self) -> None:
+ ctx = _make_context(
+ {
+ "placeholder_aaaa_first": "John",
+ "placeholder_bbbb_last": "Doe",
+ }
+ )
+ result = ctx.get_original_secret_value_or_none("placeholder_aaaa_first - placeholder_bbbb_last")
+ assert result == "John - Doe"
+
+ def test_preserves_surrounding_text(self) -> None:
+ ctx = _make_context(
+ {
+ "placeholder_aaaa_first": "John",
+ "placeholder_bbbb_last": "Doe",
+ }
+ )
+ result = ctx.get_original_secret_value_or_none("Name: placeholder_aaaa_first placeholder_bbbb_last (verified)")
+ assert result == "Name: John Doe (verified)"
+
+
+class TestActiveCredentialParameterKey:
+ def test_single_credential_sets_key(self) -> None:
+ from unittest.mock import MagicMock, patch
+
+ from skyvern.forge.sdk.core import skyvern_context
+ from skyvern.forge.sdk.core.skyvern_context import SkyvernContext
+
+ ctx = _make_context(
+ {
+ "placeholder_aaaa_month": "05",
+ "placeholder_bbbb_year": "29",
+ }
+ )
+ ctx.values = {
+ "credit_card_cred": {
+ "card_exp_month": "placeholder_aaaa_month",
+ "card_exp_year": "placeholder_bbbb_year",
+ },
+ }
+ ctx.parameters = {"credit_card_cred": MagicMock()}
+
+ from skyvern.forge.sdk.workflow.models.parameter import CredentialParameter
+
+ ctx.parameters["credit_card_cred"].__class__ = CredentialParameter
+
+ sky_ctx = SkyvernContext()
+ skyvern_context.set(sky_ctx)
+ try:
+ with patch("skyvern.webeye.actions.handler.app") as mock_app:
+ mock_app.WORKFLOW_CONTEXT_MANAGER.get_workflow_run_context.return_value = ctx
+
+ from skyvern.webeye.actions.handler import get_actual_value_of_parameter_if_secret
+
+ result = get_actual_value_of_parameter_if_secret(
+ "wr_test", "placeholder_aaaa_month / placeholder_bbbb_year"
+ )
+ assert result == "05 / 29"
+ assert sky_ctx.active_credential_parameter_key == "credit_card_cred"
+ finally:
+ skyvern_context.reset()
+
+ def test_cross_credential_does_not_set_key(self) -> None:
+ from unittest.mock import MagicMock, patch
+
+ from skyvern.forge.sdk.core import skyvern_context
+ from skyvern.forge.sdk.core.skyvern_context import SkyvernContext
+ from skyvern.forge.sdk.workflow.models.parameter import CredentialParameter
+
+ ctx = _make_context(
+ {
+ "placeholder_aaaa_month": "05",
+ "placeholder_bbbb_year": "29",
+ }
+ )
+ ctx.values = {
+ "cred_A": {"card_exp_month": "placeholder_aaaa_month"},
+ "cred_B": {"card_exp_year": "placeholder_bbbb_year"},
+ }
+ ctx.parameters = {
+ "cred_A": MagicMock(),
+ "cred_B": MagicMock(),
+ }
+ ctx.parameters["cred_A"].__class__ = CredentialParameter
+ ctx.parameters["cred_B"].__class__ = CredentialParameter
+
+ sky_ctx = SkyvernContext()
+ skyvern_context.set(sky_ctx)
+ try:
+ with patch("skyvern.webeye.actions.handler.app") as mock_app:
+ mock_app.WORKFLOW_CONTEXT_MANAGER.get_workflow_run_context.return_value = ctx
+
+ from skyvern.webeye.actions.handler import get_actual_value_of_parameter_if_secret
+
+ result = get_actual_value_of_parameter_if_secret(
+ "wr_test", "placeholder_aaaa_month / placeholder_bbbb_year"
+ )
+ assert result == "05 / 29"
+ assert sky_ctx.active_credential_parameter_key is None
+ finally:
+ skyvern_context.reset()
+
+
+class TestTaskV1Guard:
+ def test_task_v1_does_not_use_embedded_resolver(self) -> None:
+ from dataclasses import dataclass
+
+ from skyvern.forge.sdk.core import skyvern_context
+ from skyvern.forge.sdk.core.skyvern_context import SkyvernContext
+ from skyvern.webeye.actions.handler import get_actual_value_of_parameter_if_secret_with_task
+
+ @dataclass
+ class _FakeTask:
+ workflow_run_id: str | None = None
+
+ task = _FakeTask(workflow_run_id=None)
+ ctx = SkyvernContext()
+ skyvern_context.set(ctx)
+ try:
+ result = get_actual_value_of_parameter_if_secret_with_task(
+ task, # type: ignore[arg-type]
+ "placeholder_aaaa_month / placeholder_bbbb_year",
+ )
+ assert result == "placeholder_aaaa_month / placeholder_bbbb_year"
+ finally:
+ skyvern_context.reset()