Skip to content

Automate browser based workflows with AI

add azure blob storage (#4338)

Shuchang Zheng55f366ba930e
diff --git a/skyvern-frontend/src/routes/tasks/detail/Artifact.tsx b/skyvern-frontend/src/routes/tasks/detail/Artifact.tsx
index f90985f43..6367d3f18 100644
--- a/skyvern-frontend/src/routes/tasks/detail/Artifact.tsx
+++ b/skyvern-frontend/src/routes/tasks/detail/Artifact.tsx
@@ -54,6 +54,9 @@ type Props = {
function Artifact({ type, artifacts }: Props) {
function fetchArtifact(artifact: ArtifactApiResponse) {
+ if (artifact.signed_url) {
+ return axios.get(artifact.signed_url).then((response) => response.data);
+ }
if (artifact.uri.startsWith("file://")) {
const endpoint = getEndpoint(type);
return artifactApiClient
@@ -64,9 +67,6 @@ function Artifact({ type, artifacts }: Props) {
})
.then((response) => response.data);
}
- if (artifact.uri.startsWith("s3://") && artifact.signed_url) {
- return axios.get(artifact.signed_url).then((response) => response.data);
- }
}
const results = useQueries({
diff --git a/skyvern-frontend/src/routes/tasks/detail/artifactUtils.ts b/skyvern-frontend/src/routes/tasks/detail/artifactUtils.ts
index f3760f293..9ce246777 100644
--- a/skyvern-frontend/src/routes/tasks/detail/artifactUtils.ts
+++ b/skyvern-frontend/src/routes/tasks/detail/artifactUtils.ts
@@ -2,10 +2,11 @@ import { ArtifactApiResponse, TaskApiResponse } from "@/api/types";
import { artifactApiBaseUrl } from "@/util/env";
export function getImageURL(artifact: ArtifactApiResponse): string {
+ if (artifact.signed_url) {
+ return artifact.signed_url;
+ }
if (artifact.uri.startsWith("file://")) {
return `${artifactApiBaseUrl}/artifact/image?path=${artifact.uri.slice(7)}`;
- } else if (artifact.uri.startsWith("s3://") && artifact.signed_url) {
- return artifact.signed_url;
}
return artifact.uri;
}
diff --git a/skyvern-frontend/src/routes/workflows/editor/nodes/HttpRequestNode/HttpRequestNode.tsx b/skyvern-frontend/src/routes/workflows/editor/nodes/HttpRequestNode/HttpRequestNode.tsx
index f3324db03..2a322189f 100644
--- a/skyvern-frontend/src/routes/workflows/editor/nodes/HttpRequestNode/HttpRequestNode.tsx
+++ b/skyvern-frontend/src/routes/workflows/editor/nodes/HttpRequestNode/HttpRequestNode.tsx
@@ -63,7 +63,7 @@ const headersTooltip =
const bodyTooltip =
"Request body as JSON object. Only used for POST, PUT, PATCH methods.";
const filesTooltip =
- 'Files to upload as multipart/form-data. Dictionary mapping field names to file paths/URLs. Supports HTTP/HTTPS URLs, S3 URIs (s3://), or limited local file access. Example: {"file": "https://example.com/file.pdf"} or {"document": "s3://bucket/path/file.pdf"}';
+ 'Files to upload as multipart/form-data. Dictionary mapping field names to file paths/URLs. Supports HTTP/HTTPS URLs, S3 URIs (s3://), Azure blob URIs (azure://), or limited local file access. Example: {"file": "https://example.com/file.pdf"} or {"document": "s3://bucket/path/file.pdf"}';
const timeoutTooltip = "Request timeout in seconds.";
const followRedirectsTooltip =
"Whether to automatically follow HTTP redirects.";
diff --git a/skyvern/config.py b/skyvern/config.py
index b9ec07608..c3de4b02f 100644
--- a/skyvern/config.py
+++ b/skyvern/config.py
@@ -87,23 +87,26 @@ class Settings(BaseSettings):
# Artifact storage settings
ARTIFACT_STORAGE_PATH: str = f"{SKYVERN_DIR}/artifacts"
- GENERATE_PRESIGNED_URLS: bool = False
- AWS_S3_BUCKET_ARTIFACTS: str = "skyvern-artifacts"
- AWS_S3_BUCKET_SCREENSHOTS: str = "skyvern-screenshots"
- AWS_S3_BUCKET_BROWSER_SESSIONS: str = "skyvern-browser-sessions"
- # Supported storage types: local, s3
+ # Supported storage types: local, s3cloud, azureblob
SKYVERN_STORAGE_TYPE: str = "local"
- # S3 bucket settings
+ # S3/AWS settings
AWS_REGION: str = "us-east-1"
- AWS_S3_BUCKET_UPLOADS: str = "skyvern-uploads"
MAX_UPLOAD_FILE_SIZE: int = 10 * 1024 * 1024 # 10 MB
PRESIGNED_URL_EXPIRATION: int = 60 * 60 * 24 # 24 hours
+ AWS_S3_BUCKET_ARTIFACTS: str = "skyvern-artifacts"
+ AWS_S3_BUCKET_SCREENSHOTS: str = "skyvern-screenshots"
+ AWS_S3_BUCKET_BROWSER_SESSIONS: str = "skyvern-browser-sessions"
+ AWS_S3_BUCKET_UPLOADS: str = "skyvern-uploads"
# Azure Blob Storage settings
AZURE_STORAGE_ACCOUNT_NAME: str | None = None
AZURE_STORAGE_ACCOUNT_KEY: str | None = None
+ AZURE_STORAGE_CONTAINER_ARTIFACTS: str = "skyvern-artifacts"
+ AZURE_STORAGE_CONTAINER_SCREENSHOTS: str = "skyvern-screenshots"
+ AZURE_STORAGE_CONTAINER_BROWSER_SESSIONS: str = "skyvern-browser-sessions"
+ AZURE_STORAGE_CONTAINER_UPLOADS: str = "skyvern-uploads"
SKYVERN_TELEMETRY: bool = True
ANALYTICS_ID: str = "anonymous"
diff --git a/skyvern/forge/forge_app.py b/skyvern/forge/forge_app.py
index 71463266b..c428bfb15 100644
--- a/skyvern/forge/forge_app.py
+++ b/skyvern/forge/forge_app.py
@@ -16,6 +16,7 @@ from skyvern.forge.sdk.api.llm.api_handler import LLMAPIHandler
from skyvern.forge.sdk.api.llm.api_handler_factory import LLMAPIHandlerFactory
from skyvern.forge.sdk.api.real_azure import RealAzureClientFactory
from skyvern.forge.sdk.artifact.manager import ArtifactManager
+from skyvern.forge.sdk.artifact.storage.azure import AzureStorage
from skyvern.forge.sdk.artifact.storage.base import BaseStorage
from skyvern.forge.sdk.artifact.storage.factory import StorageFactory
from skyvern.forge.sdk.artifact.storage.s3 import S3Storage
@@ -104,6 +105,8 @@ def create_forge_app() -> ForgeApp:
if settings.SKYVERN_STORAGE_TYPE == "s3":
StorageFactory.set_storage(S3Storage())
+ elif settings.SKYVERN_STORAGE_TYPE == "azureblob":
+ StorageFactory.set_storage(AzureStorage())
app.STORAGE = StorageFactory.get_storage()
app.CACHE = CacheFactory.get_cache()
app.ARTIFACT_MANAGER = ArtifactManager()
diff --git a/skyvern/forge/sdk/api/aws.py b/skyvern/forge/sdk/api/aws.py
index e777a48cd..7f83b5475 100644
--- a/skyvern/forge/sdk/api/aws.py
+++ b/skyvern/forge/sdk/api/aws.py
@@ -1,4 +1,5 @@
from enum import StrEnum
+from mimetypes import add_type, guess_type
from typing import IO, Any
from urllib.parse import urlparse
@@ -12,6 +13,10 @@ from types_boto3_secretsmanager.client import SecretsManagerClient
from skyvern.config import settings
+# Register custom mime types for mimetypes guessing
+add_type("application/json", ".har")
+add_type("text/plain", ".log")
+
LOG = structlog.get_logger()
@@ -188,6 +193,10 @@ class AsyncAWSClient:
extra_args["Tagging"] = self._create_tag_string(tags)
if content_type:
extra_args["ContentType"] = content_type
+ else:
+ guessed_type, _ = guess_type(file_path)
+ if guessed_type:
+ extra_args["ContentType"] = guessed_type
await client.upload_file(
Filename=file_path,
Bucket=parsed_uri.bucket,
diff --git a/skyvern/forge/sdk/api/azure.py b/skyvern/forge/sdk/api/azure.py
index af07cfb46..996e482ce 100644
--- a/skyvern/forge/sdk/api/azure.py
+++ b/skyvern/forge/sdk/api/azure.py
@@ -1,8 +1,35 @@
from typing import Protocol, Self
+from urllib.parse import urlparse
+
+from azure.storage.blob import StandardBlobTier
from skyvern.forge.sdk.schemas.organizations import AzureClientSecretCredential
+class AzureUri:
+ """Parse azure://{container}/{blob_path} URIs."""
+
+ def __init__(self, uri: str) -> None:
+ self._parsed = urlparse(uri, allow_fragments=False)
+
+ @property
+ def container(self) -> str:
+ return self._parsed.netloc
+
+ @property
+ def blob_path(self) -> str:
+ if self._parsed.query:
+ return self._parsed.path.lstrip("/") + "?" + self._parsed.query
+ return self._parsed.path.lstrip("/")
+
+ @property
+ def uri(self) -> str:
+ return self._parsed.geturl()
+
+ def __str__(self) -> str:
+ return self.uri
+
+
class AsyncAzureVaultClient(Protocol):
"""Protocol defining the interface for Azure Vault clients.
@@ -68,21 +95,24 @@ class AsyncAzureVaultClient(Protocol):
class AsyncAzureStorageClient(Protocol):
- """Protocol defining the interface for Azure Storage clients.
-
- This client provides methods to interact with Azure Blob Storage for file operations.
- """
-
- async def upload_file_from_path(self, container_name: str, blob_name: str, file_path: str) -> None:
+ """Protocol defining the interface for Azure Storage clients."""
+
+ async def upload_file_from_path(
+ self,
+ uri: str,
+ file_path: str,
+ tier: StandardBlobTier = StandardBlobTier.HOT,
+ tags: dict[str, str] | None = None,
+ metadata: dict[str, str] | None = None,
+ ) -> None:
"""Upload a file from the local filesystem to Azure Blob Storage.
Args:
- container_name: The name of the Azure Blob container
- blob_name: The name to give the blob in storage
+ uri: The azure:// URI for the blob (azure://container/blob_path)
file_path: The local path to the file to upload
-
- Raises:
- Exception: If the upload fails
+ tier: The storage tier for the blob
+ tags: Optional tags to attach to the blob
+ metadata: Optional metadata to attach to the blob
"""
...
diff --git a/skyvern/forge/sdk/api/files.py b/skyvern/forge/sdk/api/files.py
index 75866c513..4264998fd 100644
--- a/skyvern/forge/sdk/api/files.py
+++ b/skyvern/forge/sdk/api/files.py
@@ -17,7 +17,8 @@ from yarl import URL
from skyvern.config import settings
from skyvern.constants import BROWSER_DOWNLOAD_TIMEOUT, BROWSER_DOWNLOADING_SUFFIX, REPO_ROOT_DIR
from skyvern.exceptions import DownloadFileMaxSizeExceeded, DownloadFileMaxWaitingTime
-from skyvern.forge.sdk.api.aws import AsyncAWSClient, aws_client
+from skyvern.forge import app
+from skyvern.forge.sdk.api.aws import AsyncAWSClient
from skyvern.utils.url_validators import encode_url
LOG = structlog.get_logger()
@@ -97,6 +98,12 @@ def validate_download_url(url: str) -> bool:
return True
return False
+ # Allow Azure URIs for Skyvern uploads container
+ if scheme == "azure":
+ if url.startswith(f"azure://{settings.AZURE_STORAGE_CONTAINER_UPLOADS}/{settings.ENV}/o_"):
+ return True
+ return False
+
# Allow file:// URLs only in local environment
if scheme == "file":
if settings.ENV != "local":
@@ -129,20 +136,41 @@ async def download_file(url: str, max_size_mb: int | None = None) -> str:
url = f"https://drive.google.com/uc?export=download&id={file_id}"
LOG.info("Converting Google Drive link to direct download", url=url)
- # Check if URL is an S3 URI
- if url.startswith(f"s3://{settings.AWS_S3_BUCKET_UPLOADS}/{settings.ENV}/o_"):
- LOG.info("Downloading Skyvern file from S3", url=url)
- client = AsyncAWSClient()
- return await download_from_s3(client, url)
+ # Check if URL is a cloud storage URI (S3 or Azure)
+ parsed = urlparse(url)
+ if parsed.scheme == "s3":
+ uploads_prefix = f"s3://{settings.AWS_S3_BUCKET_UPLOADS}/{settings.ENV}/o_"
+ if url.startswith(uploads_prefix):
+ LOG.info("Downloading Skyvern file from S3", url=url)
+ data = await app.STORAGE.download_uploaded_file(url)
+ if data is None:
+ raise Exception(f"Failed to download file from S3: {url}")
+ filename = url.split("/")[-1]
+ temp_file = create_named_temporary_file(delete=False, file_name=filename)
+ LOG.info(f"Downloaded file to {temp_file.name}")
+ temp_file.write(data)
+ return temp_file.name
+ elif parsed.scheme == "azure":
+ uploads_prefix = f"azure://{settings.AZURE_STORAGE_CONTAINER_UPLOADS}/{settings.ENV}/o_"
+ if url.startswith(uploads_prefix):
+ LOG.info("Downloading Skyvern file from Azure Blob Storage", url=url)
+ data = await app.STORAGE.download_uploaded_file(url)
+ if data is None:
+ raise Exception(f"Failed to download file from Azure Blob Storage: {url}")
+ filename = url.split("/")[-1]
+ temp_file = create_named_temporary_file(delete=False, file_name=filename)
+ LOG.info(f"Downloaded file to {temp_file.name}")
+ temp_file.write(data)
+ return temp_file.name
# Check if URL is a file:// URI
# we only support to download local files when the environment is local
# and the file is in the skyvern downloads directory
if url.startswith("file://") and settings.ENV == "local":
- file_path = parse_uri_to_path(url)
- if file_path.startswith(f"{REPO_ROOT_DIR}/downloads"):
+ local_path = parse_uri_to_path(url)
+ if local_path.startswith(f"{REPO_ROOT_DIR}/downloads"):
LOG.info("Downloading file from local file system", url=url)
- return file_path
+ return local_path
async with aiohttp.ClientSession(raise_for_status=True) as session:
LOG.info("Starting to download file", url=url)
@@ -262,12 +290,13 @@ async def wait_for_download_finished(downloading_files: list[str], timeout: floa
while len(cur_downloading_files) > 0:
new_downloading_files: list[str] = []
for path in cur_downloading_files:
- if path.startswith("s3://"):
- try:
- await aws_client.get_object_info(path)
- except Exception:
+ # Check for cloud storage URIs (S3 or Azure)
+ parsed = urlparse(path)
+ if parsed.scheme in ("s3", "azure"):
+ if not await app.STORAGE.file_exists(path):
LOG.debug(
- "downloading file is not found in s3, means the file finished downloading", path=path
+ "downloading file is not found in cloud storage, means the file finished downloading",
+ path=path,
)
continue
else:
diff --git a/skyvern/forge/sdk/api/real_azure.py b/skyvern/forge/sdk/api/real_azure.py
index ad7b8aaba..41109a894 100644
--- a/skyvern/forge/sdk/api/real_azure.py
+++ b/skyvern/forge/sdk/api/real_azure.py
@@ -1,15 +1,29 @@
"""Real implementations of Azure clients (Vault and Storage) and their factories."""
-from typing import Self
+from datetime import datetime, timedelta, timezone
+from mimetypes import add_type, guess_type
+from typing import IO, Self
import structlog
+from azure.core.exceptions import ResourceNotFoundError
from azure.identity.aio import ClientSecretCredential, DefaultAzureCredential
from azure.keyvault.secrets.aio import SecretClient
+from azure.storage.blob import BlobSasPermissions, ContentSettings, StandardBlobTier, generate_blob_sas
from azure.storage.blob.aio import BlobServiceClient
-from skyvern.forge.sdk.api.azure import AsyncAzureStorageClient, AsyncAzureVaultClient, AzureClientFactory
+from skyvern.config import settings
+from skyvern.forge.sdk.api.azure import (
+ AsyncAzureStorageClient,
+ AsyncAzureVaultClient,
+ AzureClientFactory,
+ AzureUri,
+)
from skyvern.forge.sdk.schemas.organizations import AzureClientSecretCredential
+# Register custom mime types for mimetypes guessing
+add_type("application/json", ".har")
+add_type("text/plain", ".log")
+
LOG = structlog.get_logger()
@@ -73,37 +87,256 @@ class RealAsyncAzureVaultClient(AsyncAzureVaultClient):
class RealAsyncAzureStorageClient(AsyncAzureStorageClient):
- """Real implementation of Azure Storage client using Azure SDK."""
+ """Async client for Azure Blob Storage operations. Implements AsyncAzureStorageClient protocol."""
- def __init__(self, storage_account_name: str, storage_account_key: str):
- self.blob_service_client = BlobServiceClient(
- account_url=f"https://{storage_account_name}.blob.core.windows.net",
- credential=storage_account_key,
- )
+ def __init__(
+ self,
+ account_name: str | None = None,
+ account_key: str | None = None,
+ ) -> None:
+ self.account_name = account_name or settings.AZURE_STORAGE_ACCOUNT_NAME
+ self.account_key = account_key or settings.AZURE_STORAGE_ACCOUNT_KEY
+
+ if not self.account_name or not self.account_key:
+ raise ValueError("Azure Storage account name and key are required")
+
+ self._blob_service_client: BlobServiceClient | None = None
+ self._verified_containers: set[str] = set()
+
+ def _get_blob_service_client(self) -> BlobServiceClient:
+ if self._blob_service_client is None:
+ self._blob_service_client = BlobServiceClient(
+ account_url=f"https://{self.account_name}.blob.core.windows.net",
+ credential=self.account_key,
+ )
+ return self._blob_service_client
- async def upload_file_from_path(self, container_name: str, blob_name: str, file_path: str) -> None:
+ async def _ensure_container_exists(self, container: str) -> None:
+ if container in self._verified_containers:
+ return
+ client = self._get_blob_service_client()
+ container_client = client.get_container_client(container)
try:
- container_client = self.blob_service_client.get_container_client(container_name)
- # Create the container if it doesn't exist
- try:
+ if not await container_client.exists():
await container_client.create_container()
- except Exception as e:
- LOG.info("Azure container already exists or failed to create", container_name=container_name, error=e)
+ LOG.info("Created Azure container", container=container)
+ except Exception:
+ LOG.debug("Container may already exist", container=container)
+ self._verified_containers.add(container)
- with open(file_path, "rb") as data:
- await container_client.upload_blob(name=blob_name, data=data, overwrite=True)
- LOG.info("File uploaded to Azure Blob Storage", container_name=container_name, blob_name=blob_name)
- except Exception as e:
- LOG.error(
- "Failed to upload file to Azure Blob Storage",
- container_name=container_name,
- blob_name=blob_name,
- error=e,
+ async def upload_file(
+ self,
+ uri: str,
+ data: bytes,
+ tier: StandardBlobTier = StandardBlobTier.HOT,
+ tags: dict[str, str] | None = None,
+ ) -> None:
+ parsed = AzureUri(uri)
+ await self._ensure_container_exists(parsed.container)
+ client = self._get_blob_service_client()
+ container_client = client.get_container_client(parsed.container)
+ await container_client.upload_blob(
+ name=parsed.blob_path,
+ data=data,
+ overwrite=True,
+ standard_blob_tier=tier,
+ tags=tags,
+ )
+
+ async def upload_file_from_path(
+ self,
+ uri: str,
+ file_path: str,
+ tier: StandardBlobTier = StandardBlobTier.HOT,
+ tags: dict[str, str] | None = None,
+ metadata: dict[str, str] | None = None,
+ ) -> None:
+ parsed = AzureUri(uri)
+ await self._ensure_container_exists(parsed.container)
+ client = self._get_blob_service_client()
+ container_client = client.get_container_client(parsed.container)
+ content_type, _ = guess_type(file_path)
+ content_settings = ContentSettings(content_type=content_type) if content_type else None
+ with open(file_path, "rb") as f:
+ await container_client.upload_blob(
+ name=parsed.blob_path,
+ data=f,
+ overwrite=True,
+ standard_blob_tier=tier,
+ tags=tags,
+ metadata=metadata,
+ content_settings=content_settings,
)
- raise e
+
+ async def upload_file_stream(
+ self,
+ uri: str,
+ file_obj: IO[bytes],
+ tier: StandardBlobTier = StandardBlobTier.HOT,
+ tags: dict[str, str] | None = None,
+ metadata: dict[str, str] | None = None,
+ ) -> str:
+ parsed = AzureUri(uri)
+ await self._ensure_container_exists(parsed.container)
+ client = self._get_blob_service_client()
+ container_client = client.get_container_client(parsed.container)
+ await container_client.upload_blob(
+ name=parsed.blob_path,
+ data=file_obj,
+ overwrite=True,
+ standard_blob_tier=tier,
+ tags=tags,
+ metadata=metadata,
+ )
+ return uri
+
+ async def download_file(self, uri: str, log_exception: bool = True) -> bytes | None:
+ parsed = AzureUri(uri)
+ try:
+ client = self._get_blob_service_client()
+ container_client = client.get_container_client(parsed.container)
+ blob_client = container_client.get_blob_client(parsed.blob_path)
+ download = await blob_client.download_blob()
+ return await download.readall()
+ except ResourceNotFoundError:
+ if log_exception:
+ LOG.warning("Azure blob not found", uri=uri)
+ return None
+ except Exception:
+ if log_exception:
+ LOG.exception("Failed to download from Azure", uri=uri)
+ return None
+
+ async def get_blob_properties(self, uri: str) -> dict | None:
+ parsed = AzureUri(uri)
+ try:
+ client = self._get_blob_service_client()
+ container_client = client.get_container_client(parsed.container)
+ blob_client = container_client.get_blob_client(parsed.blob_path)
+ props = await blob_client.get_blob_properties()
+ return {
+ "size": props.size,
+ "content_type": props.content_settings.content_type if props.content_settings else None,
+ "last_modified": props.last_modified,
+ "etag": props.etag,
+ "metadata": props.metadata,
+ }
+ except ResourceNotFoundError:
+ return None
+ except Exception:
+ LOG.exception("Failed to get blob properties", uri=uri)
+ return None
+
+ async def blob_exists(self, uri: str) -> bool:
+ parsed = AzureUri(uri)
+ try:
+ client = self._get_blob_service_client()
+ container_client = client.get_container_client(parsed.container)
+ blob_client = container_client.get_blob_client(parsed.blob_path)
+ return await blob_client.exists()
+ except Exception:
+ return False
+
+ async def delete_blob(self, uri: str) -> None:
+ parsed = AzureUri(uri)
+ try:
+ client = self._get_blob_service_client()
+ container_client = client.get_container_client(parsed.container)
+ blob_client = container_client.get_blob_client(parsed.blob_path)
+ await blob_client.delete_blob()
+ except ResourceNotFoundError:
+ LOG.debug("Azure blob not found for deletion", uri=uri)
+ except Exception:
+ LOG.exception("Failed to delete Azure blob", uri=uri)
+ raise
+
+ async def list_blobs(self, container: str, prefix: str | None = None) -> list[str]:
+ try:
+ client = self._get_blob_service_client()
+ container_client = client.get_container_client(container)
+ blobs = []
+ async for blob in container_client.list_blobs(name_starts_with=prefix):
+ blobs.append(blob.name)
+ return blobs
+ except ResourceNotFoundError:
+ return []
+ except Exception:
+ LOG.exception("Failed to list Azure blobs", container=container, prefix=prefix)
+ return []
+
+ def create_sas_url(self, uri: str, expiry_hours: int = 24) -> str | None:
+ parsed = AzureUri(uri)
+ try:
+ sas_token = generate_blob_sas(
+ account_name=self.account_name,
+ container_name=parsed.container,
+ blob_name=parsed.blob_path,
+ account_key=self.account_key,
+ permission=BlobSasPermissions(read=True),
+ expiry=datetime.now(timezone.utc) + timedelta(hours=expiry_hours),
+ )
+ return (
+ f"https://{self.account_name}.blob.core.windows.net/{parsed.container}/{parsed.blob_path}?{sas_token}"
+ )
+ except Exception:
+ LOG.exception("Failed to create SAS URL", uri=uri)
+ return None
+
+ async def create_sas_urls(self, uris: list[str], expiry_hours: int = 24) -> list[str] | None:
+ try:
+ sas_urls: list[str] = []
+ for uri in uris:
+ url = self.create_sas_url(uri, expiry_hours)
+ if url is None:
+ LOG.warning("SAS URL generation failed, aborting batch", failed_uri=uri, uris=uris)
+ return None
+ sas_urls.append(url)
+ return sas_urls
+ except Exception:
+ LOG.exception("Failed to create SAS URLs")
+ return None
async def close(self) -> None:
- await self.blob_service_client.close()
+ if self._blob_service_client:
+ await self._blob_service_client.close()
+ self._blob_service_client = None
+
+ async def list_files(self, uri: str) -> list[str]:
+ """List files under a URI prefix. Returns blob names relative to container."""
+ parsed = AzureUri(uri)
+ return await self.list_blobs(parsed.container, parsed.blob_path)
+
+ async def get_object_info(self, uri: str) -> dict | None:
+ """Get object info including metadata. Returns dict with Metadata and LastModified keys."""
+ props = await self.get_blob_properties(uri)
+ if props is None:
+ return None
+ return {
+ "Metadata": props.get("metadata", {}),
+ "LastModified": props.get("last_modified"),
+ }
+
+ async def delete_file(self, uri: str) -> None:
+ """Delete a file at the given URI."""
+ await self.delete_blob(uri)
+
+ async def get_file_metadata(self, uri: str, log_exception: bool = True) -> dict[str, str] | None:
+ """Get only the metadata for a file."""
+ parsed = AzureUri(uri)
+ try:
+ client = self._get_blob_service_client()
+ container_client = client.get_container_client(parsed.container)
+ blob_client = container_client.get_blob_client(parsed.blob_path)
+ props = await blob_client.get_blob_properties()
+ return props.metadata or {}
+ except ResourceNotFoundError:
+ if log_exception:
+ LOG.warning("Azure blob not found for metadata", uri=uri)
+ return None
+ except Exception:
+ if log_exception:
+ LOG.exception("Failed to get blob metadata", uri=uri)
+ return None
class RealAzureClientFactory(AzureClientFactory):
@@ -124,4 +357,4 @@ class RealAzureClientFactory(AzureClientFactory):
def create_storage_client(self, storage_account_name: str, storage_account_key: str) -> AsyncAzureStorageClient:
"""Create an Azure Storage client with the provided credentials."""
- return RealAsyncAzureStorageClient(storage_account_name, storage_account_key)
+ return RealAsyncAzureStorageClient(account_name=storage_account_name, account_key=storage_account_key)
diff --git a/skyvern/forge/sdk/artifact/storage/azure.py b/skyvern/forge/sdk/artifact/storage/azure.py
new file mode 100644
index 000000000..3b35e3eb5
--- /dev/null
+++ b/skyvern/forge/sdk/artifact/storage/azure.py
@@ -0,0 +1,539 @@
+import os
+import shutil
+import uuid
+from datetime import datetime, timezone
+from typing import BinaryIO
+
+import structlog
+
+from skyvern.config import settings
+from skyvern.constants import BROWSER_DOWNLOADING_SUFFIX, DOWNLOAD_FILE_PREFIX
+from skyvern.forge.sdk.api.azure import StandardBlobTier
+from skyvern.forge.sdk.api.files import (
+ calculate_sha256_for_file,
+ create_named_temporary_file,
+ get_download_dir,
+ get_skyvern_temp_dir,
+ make_temp_directory,
+ unzip_files,
+)
+from skyvern.forge.sdk.api.real_azure import RealAsyncAzureStorageClient
+from skyvern.forge.sdk.artifact.models import Artifact, ArtifactType, LogEntityType
+from skyvern.forge.sdk.artifact.storage.base import FILE_EXTENTSION_MAP, BaseStorage
+from skyvern.forge.sdk.models import Step
+from skyvern.forge.sdk.schemas.ai_suggestions import AISuggestion
+from skyvern.forge.sdk.schemas.files import FileInfo
+from skyvern.forge.sdk.schemas.task_v2 import TaskV2, Thought
+from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock
+
+LOG = structlog.get_logger()
+
+
+class AzureStorage(BaseStorage):
+ _PATH_VERSION = "v1"
+
+ def __init__(
+ self,
+ container: str | None = None,
+ account_name: str | None = None,
+ account_key: str | None = None,
+ ) -> None:
+ self.async_client = RealAsyncAzureStorageClient(account_name=account_name, account_key=account_key)
+ self.container = container or settings.AZURE_STORAGE_CONTAINER_ARTIFACTS
+
+ def build_uri(self, *, organization_id: str, artifact_id: str, step: Step, artifact_type: ArtifactType) -> str:
+ file_ext = FILE_EXTENTSION_MAP[artifact_type]
+ return f"{self._build_base_uri(organization_id)}/{step.task_id}/{step.order:02d}_{step.retry_index}_{step.step_id}/{datetime.utcnow().isoformat()}_{artifact_id}_{artifact_type}.{file_ext}"
+
+ async def retrieve_global_workflows(self) -> list[str]:
+ uri = f"azure://{self.container}/{settings.ENV}/global_workflows.txt"
+ data = await self.async_client.download_file(uri, log_exception=False)
+ if not data:
+ return []
+ return [line.strip() for line in data.decode("utf-8").split("\n") if line.strip()]
+
+ def _build_base_uri(self, organization_id: str) -> str:
+ return f"azure://{self.container}/{self._PATH_VERSION}/{settings.ENV}/{organization_id}"
+
+ def build_log_uri(
+ self, *, organization_id: str, log_entity_type: LogEntityType, log_entity_id: str, artifact_type: ArtifactType
+ ) -> str:
+ file_ext = FILE_EXTENTSION_MAP[artifact_type]
+ return f"{self._build_base_uri(organization_id)}/logs/{log_entity_type}/{log_entity_id}/{datetime.utcnow().isoformat()}_{artifact_type}.{file_ext}"
+
+ def build_thought_uri(
+ self, *, organization_id: str, artifact_id: str, thought: Thought, artifact_type: ArtifactType
+ ) -> str:
+ file_ext = FILE_EXTENTSION_MAP[artifact_type]
+ return f"{self._build_base_uri(organization_id)}/observers/{thought.observer_cruise_id}/{thought.observer_thought_id}/{datetime.utcnow().isoformat()}_{artifact_id}_{artifact_type}.{file_ext}"
+
+ def build_task_v2_uri(
+ self, *, organization_id: str, artifact_id: str, task_v2: TaskV2, artifact_type: ArtifactType
+ ) -> str:
+ file_ext = FILE_EXTENTSION_MAP[artifact_type]
+ return f"{self._build_base_uri(organization_id)}/observers/{task_v2.observer_cruise_id}/{datetime.utcnow().isoformat()}_{artifact_id}_{artifact_type}.{file_ext}"
+
+ def build_workflow_run_block_uri(
+ self,
+ *,
+ organization_id: str,
+ artifact_id: str,
+ workflow_run_block: WorkflowRunBlock,
+ artifact_type: ArtifactType,
+ ) -> str:
+ file_ext = FILE_EXTENTSION_MAP[artifact_type]
+ return f"{self._build_base_uri(organization_id)}/workflow_runs/{workflow_run_block.workflow_run_id}/{workflow_run_block.workflow_run_block_id}/{datetime.utcnow().isoformat()}_{artifact_id}_{artifact_type}.{file_ext}"
+
+ def build_ai_suggestion_uri(
+ self, *, organization_id: str, artifact_id: str, ai_suggestion: AISuggestion, artifact_type: ArtifactType
+ ) -> str:
+ file_ext = FILE_EXTENTSION_MAP[artifact_type]
+ return f"{self._build_base_uri(organization_id)}/ai_suggestions/{ai_suggestion.ai_suggestion_id}/{datetime.utcnow().isoformat()}_{artifact_id}_{artifact_type}.{file_ext}"
+
+ def build_script_file_uri(
+ self, *, organization_id: str, script_id: str, script_version: int, file_path: str
+ ) -> str:
+ """Build the Azure URI for a script file."""
+ return f"{self._build_base_uri(organization_id)}/scripts/{script_id}/{script_version}/{file_path}"
+
+ async def store_artifact(self, artifact: Artifact, data: bytes) -> None:
+ tier = await self._get_storage_tier_for_org(artifact.organization_id)
+ tags = await self._get_tags_for_org(artifact.organization_id)
+ LOG.debug(
+ "Storing artifact",
+ artifact_id=artifact.artifact_id,
+ organization_id=artifact.organization_id,
+ uri=artifact.uri,
+ storage_tier=tier,
+ tags=tags,
+ )
+ await self.async_client.upload_file(artifact.uri, data, tier=tier, tags=tags)
+
+ async def _get_storage_tier_for_org(self, organization_id: str) -> StandardBlobTier:
+ return StandardBlobTier.HOT
+
+ async def _get_tags_for_org(self, organization_id: str) -> dict[str, str]:
+ return {}
+
+ async def retrieve_artifact(self, artifact: Artifact) -> bytes | None:
+ return await self.async_client.download_file(artifact.uri)
+
+ async def get_share_link(self, artifact: Artifact) -> str | None:
+ share_urls = await self.async_client.create_sas_urls([artifact.uri])
+ return share_urls[0] if share_urls else None
+
+ async def get_share_links(self, artifacts: list[Artifact]) -> list[str] | None:
+ return await self.async_client.create_sas_urls([artifact.uri for artifact in artifacts])
+
+ async def store_artifact_from_path(self, artifact: Artifact, path: str) -> None:
+ tier = await self._get_storage_tier_for_org(artifact.organization_id)
+ tags = await self._get_tags_for_org(artifact.organization_id)
+ LOG.debug(
+ "Storing artifact from path",
+ artifact_id=artifact.artifact_id,
+ organization_id=artifact.organization_id,
+ uri=artifact.uri,
+ storage_tier=tier,
+ path=path,
+ tags=tags,
+ )
+ await self.async_client.upload_file_from_path(artifact.uri, path, tier=tier, tags=tags)
+
+ async def save_streaming_file(self, organization_id: str, file_name: str) -> None:
+ from_path = f"{get_skyvern_temp_dir()}/{organization_id}/{file_name}"
+ to_path = f"azure://{settings.AZURE_STORAGE_CONTAINER_SCREENSHOTS}/{settings.ENV}/{organization_id}/{file_name}"
+ tier = await self._get_storage_tier_for_org(organization_id)
+ tags = await self._get_tags_for_org(organization_id)
+ LOG.debug(
+ "Saving streaming file",
+ organization_id=organization_id,
+ file_name=file_name,
+ from_path=from_path,
+ to_path=to_path,
+ storage_tier=tier,
+ tags=tags,
+ )
+ await self.async_client.upload_file_from_path(to_path, from_path, tier=tier, tags=tags)
+
+ async def get_streaming_file(self, organization_id: str, file_name: str, use_default: bool = True) -> bytes | None:
+ path = f"azure://{settings.AZURE_STORAGE_CONTAINER_SCREENSHOTS}/{settings.ENV}/{organization_id}/{file_name}"
+ return await self.async_client.download_file(path, log_exception=False)
+
+ async def store_browser_session(self, organization_id: str, workflow_permanent_id: str, directory: str) -> None:
+ # Zip the directory to a temp file
+ temp_zip_file = create_named_temporary_file()
+ zip_file_path = shutil.make_archive(temp_zip_file.name, "zip", directory)
+ browser_session_uri = f"azure://{settings.AZURE_STORAGE_CONTAINER_BROWSER_SESSIONS}/{settings.ENV}/{organization_id}/{workflow_permanent_id}.zip"
+ tier = await self._get_storage_tier_for_org(organization_id)
+ tags = await self._get_tags_for_org(organization_id)
+ LOG.debug(
+ "Storing browser session",
+ organization_id=organization_id,
+ workflow_permanent_id=workflow_permanent_id,
+ zip_file_path=zip_file_path,
+ browser_session_uri=browser_session_uri,
+ storage_tier=tier,
+ tags=tags,
+ )
+ await self.async_client.upload_file_from_path(browser_session_uri, zip_file_path, tier=tier, tags=tags)
+
+ async def retrieve_browser_session(self, organization_id: str, workflow_permanent_id: str) -> str | None:
+ browser_session_uri = f"azure://{settings.AZURE_STORAGE_CONTAINER_BROWSER_SESSIONS}/{settings.ENV}/{organization_id}/{workflow_permanent_id}.zip"
+ downloaded_zip_bytes = await self.async_client.download_file(browser_session_uri, log_exception=True)
+ if not downloaded_zip_bytes:
+ return None
+ temp_zip_file = create_named_temporary_file(delete=False)
+ temp_zip_file.write(downloaded_zip_bytes)
+ temp_zip_file_path = temp_zip_file.name
+
+ temp_dir = make_temp_directory(prefix="skyvern_browser_session_")
+ unzip_files(temp_zip_file_path, temp_dir)
+ temp_zip_file.close()
+ return temp_dir
+
+ async def store_browser_profile(self, organization_id: str, profile_id: str, directory: str) -> None:
+ """Store browser profile to Azure."""
+ temp_zip_file = create_named_temporary_file()
+ zip_file_path = shutil.make_archive(temp_zip_file.name, "zip", directory)
+ profile_uri = f"azure://{settings.AZURE_STORAGE_CONTAINER_BROWSER_SESSIONS}/{settings.ENV}/{organization_id}/profiles/{profile_id}.zip"
+ tier = await self._get_storage_tier_for_org(organization_id)
+ tags = await self._get_tags_for_org(organization_id)
+ LOG.debug(
+ "Storing browser profile",
+ organization_id=organization_id,
+ profile_id=profile_id,
+ zip_file_path=zip_file_path,
+ profile_uri=profile_uri,
+ storage_tier=tier,
+ tags=tags,
+ )
+ await self.async_client.upload_file_from_path(profile_uri, zip_file_path, tier=tier, tags=tags)
+
+ async def retrieve_browser_profile(self, organization_id: str, profile_id: str) -> str | None:
+ """Retrieve browser profile from Azure."""
+ profile_uri = f"azure://{settings.AZURE_STORAGE_CONTAINER_BROWSER_SESSIONS}/{settings.ENV}/{organization_id}/profiles/{profile_id}.zip"
+ downloaded_zip_bytes = await self.async_client.download_file(profile_uri, log_exception=True)
+ if not downloaded_zip_bytes:
+ return None
+ temp_zip_file = create_named_temporary_file(delete=False)
+ temp_zip_file.write(downloaded_zip_bytes)
+ temp_zip_file_path = temp_zip_file.name
+
+ temp_dir = make_temp_directory(prefix="skyvern_browser_profile_")
+ unzip_files(temp_zip_file_path, temp_dir)
+ temp_zip_file.close()
+ return temp_dir
+
+ async def list_downloaded_files_in_browser_session(
+ self, organization_id: str, browser_session_id: str
+ ) -> list[str]:
+ uri = f"azure://{settings.AZURE_STORAGE_CONTAINER_ARTIFACTS}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/downloads"
+ return [
+ f"azure://{settings.AZURE_STORAGE_CONTAINER_ARTIFACTS}/{file}"
+ for file in await self.async_client.list_files(uri=uri)
+ ]
+
+ async def get_shared_downloaded_files_in_browser_session(
+ self, organization_id: str, browser_session_id: str
+ ) -> list[FileInfo]:
+ object_keys = await self.list_downloaded_files_in_browser_session(organization_id, browser_session_id)
+ if len(object_keys) == 0:
+ return []
+
+ file_infos: list[FileInfo] = []
+ for key in object_keys:
+ metadata = {}
+ modified_at: datetime | None = None
+ # Get metadata (including checksum)
+ try:
+ object_info = await self.async_client.get_object_info(key)
+ if object_info:
+ metadata = object_info.get("Metadata", {})
+ modified_at = object_info.get("LastModified")
+ except Exception:
+ LOG.exception("Object info retrieval failed", uri=key)
+
+ # Create FileInfo object
+ filename = os.path.basename(key)
+ checksum = metadata.get("sha256_checksum") if metadata else None
+
+ # Get SAS URL
+ sas_urls = await self.async_client.create_sas_urls([key])
+ if not sas_urls:
+ continue
+
+ file_info = FileInfo(
+ url=sas_urls[0],
+ checksum=checksum,
+ filename=metadata.get("original_filename", filename) if metadata else filename,
+ modified_at=modified_at,
+ )
+ file_infos.append(file_info)
+
+ return file_infos
+
+ async def list_downloading_files_in_browser_session(
+ self, organization_id: str, browser_session_id: str
+ ) -> list[str]:
+ uri = f"azure://{settings.AZURE_STORAGE_CONTAINER_ARTIFACTS}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/downloads"
+ files = [
+ f"azure://{settings.AZURE_STORAGE_CONTAINER_ARTIFACTS}/{file}"
+ for file in await self.async_client.list_files(uri=uri)
+ ]
+ return [file for file in files if file.endswith(BROWSER_DOWNLOADING_SUFFIX)]
+
+ async def list_recordings_in_browser_session(self, organization_id: str, browser_session_id: str) -> list[str]:
+ """List all recording files for a browser session from Azure."""
+ uri = f"azure://{settings.AZURE_STORAGE_CONTAINER_ARTIFACTS}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/videos"
+ return [
+ f"azure://{settings.AZURE_STORAGE_CONTAINER_ARTIFACTS}/{file}"
+ for file in await self.async_client.list_files(uri=uri)
+ ]
+
+ async def get_shared_recordings_in_browser_session(
+ self, organization_id: str, browser_session_id: str
+ ) -> list[FileInfo]:
+ """Get recording files with SAS URLs for a browser session."""
+ object_keys = await self.list_recordings_in_browser_session(organization_id, browser_session_id)
+ if len(object_keys) == 0:
+ return []
+
+ file_infos: list[FileInfo] = []
+ for key in object_keys:
+ # Playwright's record_video_dir should only contain .webm files.
+ # Filter defensively in case of unexpected files.
+ key_lower = key.lower()
+ if not (key_lower.endswith(".webm") or key_lower.endswith(".mp4")):
+ LOG.warning(
+ "Skipping recording file with unsupported extension",
+ uri=key,
+ organization_id=organization_id,
+ browser_session_id=browser_session_id,
+ )
+ continue
+
+ metadata = {}
+ modified_at: datetime | None = None
+ content_length: int | None = None
+ # Get metadata (including checksum)
+ try:
+ object_info = await self.async_client.get_object_info(key)
+ if object_info:
+ metadata = object_info.get("Metadata", {})
+ modified_at = object_info.get("LastModified")
+ content_length = object_info.get("ContentLength") or object_info.get("Size")
+ except Exception:
+ LOG.exception("Recording object info retrieval failed", uri=key)
+
+ # Skip zero-byte objects (if any incomplete uploads)
+ if content_length == 0:
+ continue
+
+ # Create FileInfo object
+ filename = os.path.basename(key)
+ checksum = metadata.get("sha256_checksum") if metadata else None
+
+ # Get SAS URL
+ sas_urls = await self.async_client.create_sas_urls([key])
+ if not sas_urls:
+ continue
+
+ file_info = FileInfo(
+ url=sas_urls[0],
+ checksum=checksum,
+ filename=metadata.get("original_filename", filename) if metadata else filename,
+ modified_at=modified_at,
+ )
+ file_infos.append(file_info)
+
+ # Prefer the newest recording first (Azure list order is not guaranteed).
+ # Treat None as "oldest".
+ file_infos.sort(key=lambda f: (f.modified_at is not None, f.modified_at), reverse=True)
+ return file_infos
+
+ async def save_downloaded_files(self, organization_id: str, run_id: str | None) -> None:
+ download_dir = get_download_dir(run_id=run_id)
+ files = os.listdir(download_dir)
+ tier = await self._get_storage_tier_for_org(organization_id)
+ tags = await self._get_tags_for_org(organization_id)
+ base_uri = f"azure://{settings.AZURE_STORAGE_CONTAINER_UPLOADS}/{DOWNLOAD_FILE_PREFIX}/{settings.ENV}/{organization_id}/{run_id}"
+ for file in files:
+ fpath = os.path.join(download_dir, file)
+ if not os.path.isfile(fpath):
+ continue
+ uri = f"{base_uri}/{file}"
+ checksum = calculate_sha256_for_file(fpath)
+ LOG.info(
+ "Calculated checksum for file",
+ file=file,
+ checksum=checksum,
+ organization_id=organization_id,
+ storage_tier=tier,
+ )
+ # Upload file with checksum metadata
+ await self.async_client.upload_file_from_path(
+ uri=uri,
+ file_path=fpath,
+ metadata={"sha256_checksum": checksum, "original_filename": file},
+ tier=tier,
+ tags=tags,
+ )
+
+ async def get_downloaded_files(self, organization_id: str, run_id: str | None) -> list[FileInfo]:
+ uri = f"azure://{settings.AZURE_STORAGE_CONTAINER_UPLOADS}/{DOWNLOAD_FILE_PREFIX}/{settings.ENV}/{organization_id}/{run_id}"
+ object_keys = await self.async_client.list_files(uri=uri)
+ if len(object_keys) == 0:
+ return []
+
+ file_infos: list[FileInfo] = []
+ for key in object_keys:
+ object_uri = f"azure://{settings.AZURE_STORAGE_CONTAINER_UPLOADS}/{key}"
+
+ # Get metadata (including checksum)
+ metadata = await self.async_client.get_file_metadata(object_uri, log_exception=False)
+
+ # Create FileInfo object
+ filename = os.path.basename(key)
+ checksum = metadata.get("sha256_checksum") if metadata else None
+
+ # Get SAS URL
+ sas_urls = await self.async_client.create_sas_urls([object_uri])
+ if not sas_urls:
+ continue
+
+ file_info = FileInfo(
+ url=sas_urls[0],
+ checksum=checksum,
+ filename=metadata.get("original_filename", filename) if metadata else filename,
+ )
+ file_infos.append(file_info)
+
+ return file_infos
+
+ async def save_legacy_file(
+ self, *, organization_id: str, filename: str, fileObj: BinaryIO
+ ) -> tuple[str, str] | None:
+ todays_date = datetime.now(tz=timezone.utc).strftime("%Y-%m-%d")
+ container = settings.AZURE_STORAGE_CONTAINER_UPLOADS
+ tier = await self._get_storage_tier_for_org(organization_id)
+ tags = await self._get_tags_for_org(organization_id)
+ # First try uploading with original filename
+ try:
+ sanitized_filename = os.path.basename(filename) # Remove any path components
+ azure_uri = f"azure://{container}/{settings.ENV}/{organization_id}/{todays_date}/{sanitized_filename}"
+ uploaded_uri = await self.async_client.upload_file_stream(azure_uri, fileObj, tier=tier, tags=tags)
+ except Exception:
+ LOG.error("Failed to upload file to Azure", exc_info=True)
+ uploaded_uri = None
+
+ # If upload fails, try again with UUID prefix
+ if not uploaded_uri:
+ uuid_prefixed_filename = f"{str(uuid.uuid4())}_{filename}"
+ azure_uri = f"azure://{container}/{settings.ENV}/{organization_id}/{todays_date}/{uuid_prefixed_filename}"
+ fileObj.seek(0) # Reset file pointer
+ uploaded_uri = await self.async_client.upload_file_stream(azure_uri, fileObj, tier=tier, tags=tags)
+
+ if not uploaded_uri:
+ LOG.error(
+ "Failed to upload file to Azure after retrying with UUID prefix",
+ organization_id=organization_id,
+ storage_tier=tier,
+ filename=filename,
+ exc_info=True,
+ )
+ return None
+ LOG.debug(
+ "Legacy file upload",
+ organization_id=organization_id,
+ storage_tier=tier,
+ filename=filename,
+ uploaded_uri=uploaded_uri,
+ )
+ # Generate a SAS URL for the uploaded file
+ sas_urls = await self.async_client.create_sas_urls([uploaded_uri])
+ if not sas_urls:
+ LOG.error(
+ "Failed to create SAS URL for uploaded file",
+ organization_id=organization_id,
+ storage_tier=tier,
+ uploaded_uri=uploaded_uri,
+ filename=filename,
+ exc_info=True,
+ )
+ return None
+ return sas_urls[0], uploaded_uri
+
+ def _build_browser_session_uri(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> str:
+ """Build the Azure URI for a browser session file."""
+ base = f"azure://{self.container}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/{artifact_type}"
+ if date:
+ return f"{base}/{date}/{remote_path}"
+ return f"{base}/{remote_path}"
+
+ async def sync_browser_session_file(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ local_file_path: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> str:
+ """Sync a file from local browser session to Azure."""
+ uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)
+ tier = await self._get_storage_tier_for_org(organization_id)
+ tags = await self._get_tags_for_org(organization_id)
+ await self.async_client.upload_file_from_path(uri, local_file_path, tier=tier, tags=tags)
+ return uri
+
+ async def delete_browser_session_file(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> None:
+ """Delete a file from browser session storage in Azure."""
+ uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)
+ await self.async_client.delete_file(uri)
+
+ async def browser_session_file_exists(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> bool:
+ """Check if a file exists in browser session storage in Azure."""
+ uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)
+ try:
+ info = await self.async_client.get_object_info(uri)
+ return info is not None
+ except Exception:
+ return False
+
+ async def download_uploaded_file(self, uri: str) -> bytes | None:
+ """Download a user-uploaded file from Azure."""
+ return await self.async_client.download_file(uri, log_exception=False)
+
+ async def file_exists(self, uri: str) -> bool:
+ """Check if a file exists at the given Azure URI."""
+ try:
+ info = await self.async_client.get_object_info(uri)
+ return info is not None
+ except Exception:
+ return False
+
+ @property
+ def storage_type(self) -> str:
+ """Returns 'azure' as the storage type."""
+ return "azure"
diff --git a/skyvern/forge/sdk/artifact/storage/base.py b/skyvern/forge/sdk/artifact/storage/base.py
index de44be462..cf8993200 100644
--- a/skyvern/forge/sdk/artifact/storage/base.py
+++ b/skyvern/forge/sdk/artifact/storage/base.py
@@ -172,3 +172,50 @@ class BaseStorage(ABC):
self, *, organization_id: str, filename: str, fileObj: BinaryIO
) -> tuple[str, str] | None:
pass
+
+ @abstractmethod
+ async def sync_browser_session_file(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ local_file_path: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> str:
+ pass
+
+ @abstractmethod
+ async def delete_browser_session_file(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> None:
+ pass
+
+ @abstractmethod
+ async def browser_session_file_exists(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> bool:
+ pass
+
+ @abstractmethod
+ async def download_uploaded_file(self, uri: str) -> bytes | None:
+ pass
+
+ @abstractmethod
+ async def file_exists(self, uri: str) -> bool:
+ pass
+
+ @property
+ @abstractmethod
+ def storage_type(self) -> str:
+ pass
diff --git a/skyvern/forge/sdk/artifact/storage/local.py b/skyvern/forge/sdk/artifact/storage/local.py
index d39e5011a..e9a85a9d8 100644
--- a/skyvern/forge/sdk/artifact/storage/local.py
+++ b/skyvern/forge/sdk/artifact/storage/local.py
@@ -160,11 +160,11 @@ class LocalStorage(BaseStorage):
)
return None
- async def get_share_link(self, artifact: Artifact) -> str:
- return artifact.uri
+ async def get_share_link(self, artifact: Artifact) -> str | None:
+ return None
- async def get_share_links(self, artifacts: list[Artifact]) -> list[str]:
- return [artifact.uri for artifact in artifacts]
+ async def get_share_links(self, artifacts: list[Artifact]) -> list[str] | None:
+ return None
async def save_streaming_file(self, organization_id: str, file_name: str) -> None:
return
@@ -346,3 +346,98 @@ class LocalStorage(BaseStorage):
raise NotImplementedError(
"Legacy file storage is not implemented for LocalStorage. Please use a different storage backend."
)
+
+ def _build_browser_session_path(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> Path:
+ """Build the local path for a browser session file."""
+ base = (
+ Path(self.artifact_path)
+ / settings.ENV
+ / organization_id
+ / "browser_sessions"
+ / browser_session_id
+ / artifact_type
+ )
+ if date:
+ return base / date / remote_path
+ return base / remote_path
+
+ async def sync_browser_session_file(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ local_file_path: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> str:
+ """Sync a file from local browser session to local storage."""
+ target_path = self._build_browser_session_path(
+ organization_id, browser_session_id, artifact_type, remote_path, date
+ )
+ if WINDOWS:
+ target_path = target_path.with_name(_windows_safe_filename(target_path.name))
+ self._create_directories_if_not_exists(target_path)
+ shutil.copy2(local_file_path, target_path)
+ return f"file://{target_path}"
+
+ async def delete_browser_session_file(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> None:
+ """Delete a file from browser session storage in local filesystem."""
+ target_path = self._build_browser_session_path(
+ organization_id, browser_session_id, artifact_type, remote_path, date
+ )
+ try:
+ if target_path.exists():
+ target_path.unlink()
+ except Exception:
+ LOG.exception("Failed to delete local browser session file", path=str(target_path))
+
+ async def browser_session_file_exists(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> bool:
+ """Check if a file exists in browser session storage in local filesystem."""
+ target_path = self._build_browser_session_path(
+ organization_id, browser_session_id, artifact_type, remote_path, date
+ )
+ return target_path.exists()
+
+ async def download_uploaded_file(self, uri: str) -> bytes | None:
+ """Download a user-uploaded file from local filesystem."""
+ try:
+ file_path = parse_uri_to_path(uri)
+ with open(file_path, "rb") as f:
+ return f.read()
+ except Exception:
+ LOG.exception("Failed to read local file", uri=uri)
+ return None
+
+ async def file_exists(self, uri: str) -> bool:
+ """Check if a file exists at the given local URI."""
+ try:
+ file_path = parse_uri_to_path(uri)
+ return os.path.exists(file_path)
+ except Exception:
+ return False
+
+ @property
+ def storage_type(self) -> str:
+ """Returns 'file' as the storage type."""
+ return "file"
diff --git a/skyvern/forge/sdk/artifact/storage/s3.py b/skyvern/forge/sdk/artifact/storage/s3.py
index 6bb359a05..c95a286e1 100644
--- a/skyvern/forge/sdk/artifact/storage/s3.py
+++ b/skyvern/forge/sdk/artifact/storage/s3.py
@@ -235,10 +235,9 @@ class S3Storage(BaseStorage):
async def list_downloaded_files_in_browser_session(
self, organization_id: str, browser_session_id: str
) -> list[str]:
- uri = f"s3://{settings.AWS_S3_BUCKET_ARTIFACTS}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/downloads"
- return [
- f"s3://{settings.AWS_S3_BUCKET_ARTIFACTS}/{file}" for file in await self.async_client.list_files(uri=uri)
- ]
+ bucket = settings.AWS_S3_BUCKET_ARTIFACTS
+ uri = f"s3://{bucket}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/downloads"
+ return [f"s3://{bucket}/{file}" for file in await self.async_client.list_files(uri=uri)]
async def get_shared_downloaded_files_in_browser_session(
self, organization_id: str, browser_session_id: str
@@ -281,18 +280,16 @@ class S3Storage(BaseStorage):
async def list_downloading_files_in_browser_session(
self, organization_id: str, browser_session_id: str
) -> list[str]:
- uri = f"s3://{settings.AWS_S3_BUCKET_ARTIFACTS}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/downloads"
- files = [
- f"s3://{settings.AWS_S3_BUCKET_ARTIFACTS}/{file}" for file in await self.async_client.list_files(uri=uri)
- ]
+ bucket = settings.AWS_S3_BUCKET_ARTIFACTS
+ uri = f"s3://{bucket}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/downloads"
+ files = [f"s3://{bucket}/{file}" for file in await self.async_client.list_files(uri=uri)]
return [file for file in files if file.endswith(BROWSER_DOWNLOADING_SUFFIX)]
async def list_recordings_in_browser_session(self, organization_id: str, browser_session_id: str) -> list[str]:
"""List all recording files for a browser session from S3."""
- uri = f"s3://{settings.AWS_S3_BUCKET_ARTIFACTS}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/videos"
- return [
- f"s3://{settings.AWS_S3_BUCKET_ARTIFACTS}/{file}" for file in await self.async_client.list_files(uri=uri)
- ]
+ bucket = settings.AWS_S3_BUCKET_ARTIFACTS
+ uri = f"s3://{bucket}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/videos"
+ return [f"s3://{bucket}/{file}" for file in await self.async_client.list_files(uri=uri)]
async def get_shared_recordings_in_browser_session(
self, organization_id: str, browser_session_id: str
@@ -385,14 +382,15 @@ class S3Storage(BaseStorage):
)
async def get_downloaded_files(self, organization_id: str, run_id: str | None) -> list[FileInfo]:
- uri = f"s3://{settings.AWS_S3_BUCKET_UPLOADS}/{DOWNLOAD_FILE_PREFIX}/{settings.ENV}/{organization_id}/{run_id}"
+ bucket = settings.AWS_S3_BUCKET_UPLOADS
+ uri = f"s3://{bucket}/{DOWNLOAD_FILE_PREFIX}/{settings.ENV}/{organization_id}/{run_id}"
object_keys = await self.async_client.list_files(uri=uri)
if len(object_keys) == 0:
return []
file_infos: list[FileInfo] = []
for key in object_keys:
- object_uri = f"s3://{settings.AWS_S3_BUCKET_UPLOADS}/{key}"
+ object_uri = f"s3://{bucket}/{key}"
# Get metadata (including checksum)
metadata = await self.async_client.get_file_metadata(object_uri, log_exception=False)
@@ -467,3 +465,78 @@ class S3Storage(BaseStorage):
)
return None
return presigned_urls[0], uploaded_s3_uri
+
+ def _build_browser_session_uri(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> str:
+ """Build the S3 URI for a browser session file."""
+ base = f"s3://{self.bucket}/v1/{settings.ENV}/{organization_id}/browser_sessions/{browser_session_id}/{artifact_type}"
+ if date:
+ return f"{base}/{date}/{remote_path}"
+ return f"{base}/{remote_path}"
+
+ async def sync_browser_session_file(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ local_file_path: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> str:
+ """Sync a file from local browser session to S3."""
+ uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)
+ sc = await self._get_storage_class_for_org(organization_id)
+ tags = await self._get_tags_for_org(organization_id)
+ await self.async_client.upload_file_from_path(uri, local_file_path, storage_class=sc, tags=tags)
+ return uri
+
+ async def delete_browser_session_file(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> None:
+ """Delete a file from browser session storage in S3."""
+ uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)
+ await self.async_client.delete_file(uri, log_exception=True)
+
+ async def browser_session_file_exists(
+ self,
+ organization_id: str,
+ browser_session_id: str,
+ artifact_type: str,
+ remote_path: str,
+ date: str | None = None,
+ ) -> bool:
+ """Check if a file exists in browser session storage in S3."""
+ uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)
+ try:
+ info = await self.async_client.get_object_info(uri)
+ return info is not None
+ except Exception:
+ return False
+
+ async def download_uploaded_file(self, uri: str) -> bytes | None:
+ """Download a user-uploaded file from S3."""
+ return await self.async_client.download_file(uri, log_exception=False)
+
+ async def file_exists(self, uri: str) -> bool:
+ """Check if a file exists at the given S3 URI."""
+ try:
+ info = await self.async_client.get_object_info(uri)
+ return info is not None
+ except Exception:
+ return False
+
+ @property
+ def storage_type(self) -> str:
+ """Returns 's3' as the storage type."""
+ return "s3"
diff --git a/skyvern/forge/sdk/artifact/storage/test_azure_storage.py b/skyvern/forge/sdk/artifact/storage/test_azure_storage.py
new file mode 100644
index 000000000..6187f49ac
--- /dev/null
+++ b/skyvern/forge/sdk/artifact/storage/test_azure_storage.py
@@ -0,0 +1,251 @@
+from pathlib import Path
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from skyvern.config import settings
+from skyvern.forge.sdk.api.azure import StandardBlobTier
+from skyvern.forge.sdk.api.real_azure import RealAsyncAzureStorageClient
+from skyvern.forge.sdk.artifact.storage.azure import AzureStorage
+
+# Test constants
+TEST_CONTAINER = "test-azure-container"
+TEST_ORGANIZATION_ID = "test-org-123"
+TEST_BROWSER_SESSION_ID = "bs_test_123"
+
+
+class AzureStorageForTests(AzureStorage):
+ """Test subclass that overrides org-specific methods and bypasses client init."""
+
+ async_client: Any # Allow mock attribute access
+
+ def __init__(self, container: str) -> None:
+ # Don't call super().__init__ to avoid creating real RealAsyncAzureStorageClient
+ self.container = container
+ self.async_client = AsyncMock()
+
+ async def _get_storage_tier_for_org(self, organization_id: str) -> StandardBlobTier:
+ return StandardBlobTier.HOT
+
+ async def _get_tags_for_org(self, organization_id: str) -> dict[str, str]:
+ return {"test": "tag"}
+
+
+def azure_storage() -> AzureStorageForTests:
+ """Create AzureStorage with mocked async_client."""
+ return AzureStorageForTests(container=TEST_CONTAINER)
+
+
+class TestAzureStorageBrowserSessionFiles:
+ """Test AzureStorage browser session file methods."""
+
+ async def test_sync_browser_session_file_with_date(
+ self, azure_storage: AzureStorageForTests, tmp_path: Path
+ ) -> None:
+ """Test syncing a file with date in path (videos/har)."""
+ test_file = tmp_path / "recording.webm"
+ test_file.write_bytes(b"fake video data")
+
+ uri = await azure_storage.sync_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ local_file_path=str(test_file),
+ remote_path="recording.webm",
+ date="2025-01-15",
+ )
+
+ expected_uri = f"azure://{TEST_CONTAINER}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/videos/2025-01-15/recording.webm"
+ assert uri == expected_uri
+ azure_storage.async_client.upload_file_from_path.assert_called_once()
+
+ async def test_sync_browser_session_file_without_date(
+ self, azure_storage: AzureStorageForTests, tmp_path: Path
+ ) -> None:
+ """Test syncing a file without date (downloads category)."""
+ test_file = tmp_path / "document.pdf"
+ test_file.write_bytes(b"fake download data")
+
+ uri = await azure_storage.sync_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="downloads",
+ local_file_path=str(test_file),
+ remote_path="document.pdf",
+ date=None,
+ )
+
+ expected_uri = f"azure://{TEST_CONTAINER}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/downloads/document.pdf"
+ assert uri == expected_uri
+
+ async def test_browser_session_file_exists_returns_true(self, azure_storage: AzureStorageForTests) -> None:
+ """Test browser_session_file_exists returns True when file exists."""
+ azure_storage.async_client.get_object_info.return_value = {"LastModified": "2025-01-15"}
+
+ exists = await azure_storage.browser_session_file_exists(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ remote_path="exists.webm",
+ date="2025-01-15",
+ )
+
+ assert exists is True
+
+ async def test_browser_session_file_exists_returns_false_on_exception(
+ self, azure_storage: AzureStorageForTests
+ ) -> None:
+ """Test browser_session_file_exists returns False when exception is raised."""
+ azure_storage.async_client.get_object_info.side_effect = Exception("Not found")
+
+ exists = await azure_storage.browser_session_file_exists(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ remote_path="nonexistent.webm",
+ date="2025-01-15",
+ )
+
+ assert exists is False
+
+ async def test_delete_browser_session_file(self, azure_storage: AzureStorageForTests) -> None:
+ """Test deleting a browser session file."""
+ await azure_storage.delete_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ remote_path="to_delete.webm",
+ date="2025-01-15",
+ )
+
+ expected_uri = f"azure://{TEST_CONTAINER}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/videos/2025-01-15/to_delete.webm"
+ azure_storage.async_client.delete_file.assert_called_once_with(expected_uri)
+
+ async def test_file_exists_returns_true(self, azure_storage: AzureStorageForTests) -> None:
+ """Test file_exists returns True when file exists."""
+ azure_storage.async_client.get_object_info.return_value = {"LastModified": "2025-01-15"}
+ uri = f"azure://{TEST_CONTAINER}/test/file.txt"
+
+ exists = await azure_storage.file_exists(uri)
+
+ assert exists is True
+
+ async def test_file_exists_returns_false_on_exception(self, azure_storage: AzureStorageForTests) -> None:
+ """Test file_exists returns False when exception is raised (404)."""
+ azure_storage.async_client.get_object_info.side_effect = Exception("Not found")
+ uri = f"azure://{TEST_CONTAINER}/nonexistent/file.txt"
+
+ exists = await azure_storage.file_exists(uri)
+
+ assert exists is False
+
+ async def test_download_uploaded_file(self, azure_storage: AzureStorageForTests) -> None:
+ """Test downloading an uploaded file."""
+ test_data = b"uploaded file content"
+ azure_storage.async_client.download_file.return_value = test_data
+ uri = f"azure://{TEST_CONTAINER}/uploads/file.pdf"
+
+ downloaded = await azure_storage.download_uploaded_file(uri)
+
+ assert downloaded == test_data
+ azure_storage.async_client.download_file.assert_called_once_with(uri, log_exception=False)
+
+ async def test_download_uploaded_file_returns_none(self, azure_storage: AzureStorageForTests) -> None:
+ """Test downloading a non-existent file returns None."""
+ azure_storage.async_client.download_file.return_value = None
+ uri = f"azure://{TEST_CONTAINER}/nonexistent/file.txt"
+
+ downloaded = await azure_storage.download_uploaded_file(uri)
+
+ assert downloaded is None
+
+ def test_storage_type_property(self, azure_storage: AzureStorageForTests) -> None:
+ """Test storage_type returns 'azure'."""
+ assert azure_storage.storage_type == "azure"
+
+
+class TestAzureStorageBuildUri:
+ """Test Azure URI building methods."""
+
+ def test_build_browser_session_uri_with_date(self, azure_storage: AzureStorageForTests) -> None:
+ """Test building URI with date."""
+ uri = azure_storage._build_browser_session_uri(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ remote_path="file.webm",
+ date="2025-01-15",
+ )
+
+ expected = f"azure://{TEST_CONTAINER}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/videos/2025-01-15/file.webm"
+ assert uri == expected
+
+ def test_build_browser_session_uri_without_date(self, azure_storage: AzureStorageForTests) -> None:
+ """Test building URI without date."""
+ uri = azure_storage._build_browser_session_uri(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="downloads",
+ remote_path="file.pdf",
+ date=None,
+ )
+
+ expected = f"azure://{TEST_CONTAINER}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/downloads/file.pdf"
+ assert uri == expected
+
+
+AZURE_CONTENT_TYPE_TEST_CASES = [
+ # (filename, expected_content_type, artifact_type, date)
+ ("video.webm", "video/webm", "videos", "2025-01-15"),
+ ("data.json", "application/json", "har", "2025-01-15"),
+ ("network.har", "application/json", "har", "2025-01-15"),
+ ("screenshot.png", "image/png", "downloads", None),
+ ("output.txt", "text/plain", "downloads", None),
+ ("debug.log", "text/plain", "downloads", None),
+]
+
+
+class TestAzureStorageContentType:
+ """Test Azure Storage content type guessing.
+
+ Tests at two levels:
+ 1. High-level: sync_browser_session_file interface with artifact_type/date
+ 2. Low-level: RealAsyncAzureStorageClient to verify ContentSettings is passed
+ """
+
+ @pytest.mark.parametrize("filename,expected_content_type,artifact_type,date", AZURE_CONTENT_TYPE_TEST_CASES)
+ async def test_content_type_guessing(
+ self,
+ tmp_path: Path,
+ filename: str,
+ expected_content_type: str,
+ artifact_type: str,
+ date: str | None,
+ ) -> None:
+ """Test that RealAsyncAzureStorageClient sets correct content type based on extension."""
+ test_file = tmp_path / filename
+ test_file.write_bytes(b"test content")
+
+ with patch.object(RealAsyncAzureStorageClient, "_get_blob_service_client") as mock_get_client:
+ mock_container_client = MagicMock()
+ mock_container_client.upload_blob = AsyncMock()
+ mock_container_client.exists = AsyncMock(return_value=True)
+ mock_blob_service = MagicMock()
+ mock_blob_service.get_container_client.return_value = mock_container_client
+ mock_get_client.return_value = mock_blob_service
+
+ client = RealAsyncAzureStorageClient(account_name="test", account_key="testkey")
+ client._verified_containers.add("test-container")
+
+ await client.upload_file_from_path(
+ uri=f"azure://test-container/path/{filename}",
+ file_path=str(test_file),
+ )
+
+ call_kwargs = mock_container_client.upload_blob.call_args.kwargs
+ assert call_kwargs["content_settings"] is not None
+ assert call_kwargs["content_settings"].content_type == expected_content_type
diff --git a/skyvern/forge/sdk/artifact/storage/test_s3_storage.py b/skyvern/forge/sdk/artifact/storage/test_s3_storage.py
index 810bed0ae..8ee7f9bbd 100644
--- a/skyvern/forge/sdk/artifact/storage/test_s3_storage.py
+++ b/skyvern/forge/sdk/artifact/storage/test_s3_storage.py
@@ -221,3 +221,229 @@ class TestS3StorageStore:
await s3_storage.store_artifact(artifact, test_data)
_assert_object_content(boto3_test_client, artifact.uri, test_data)
_assert_object_meta(boto3_test_client, artifact.uri)
+
+
+TEST_BROWSER_SESSION_ID = "bs_test_123"
+
+
+class TestS3StorageBrowserSessionFiles:
+ """Test S3Storage browser session file methods."""
+
+ async def test_sync_browser_session_file_with_date(
+ self, s3_storage: S3Storage, boto3_test_client: S3Client, tmp_path: Path
+ ) -> None:
+ """Test syncing a file with date in path (videos/har)."""
+ test_data = b"fake video data"
+ test_file = tmp_path / "recording.webm"
+ test_file.write_bytes(test_data)
+
+ uri = await s3_storage.sync_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ local_file_path=str(test_file),
+ remote_path="recording.webm",
+ date="2025-01-15",
+ )
+
+ expected_uri = f"s3://{TEST_BUCKET}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/videos/2025-01-15/recording.webm"
+ assert uri == expected_uri
+ _assert_object_content(boto3_test_client, uri, test_data)
+ _assert_object_meta(boto3_test_client, uri)
+
+ async def test_sync_browser_session_file_without_date(
+ self, s3_storage: S3Storage, boto3_test_client: S3Client, tmp_path: Path
+ ) -> None:
+ """Test syncing a file without date (downloads category)."""
+ test_data = b"fake download data"
+ test_file = tmp_path / "document.pdf"
+ test_file.write_bytes(test_data)
+
+ uri = await s3_storage.sync_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="downloads",
+ local_file_path=str(test_file),
+ remote_path="document.pdf",
+ date=None,
+ )
+
+ expected_uri = f"s3://{TEST_BUCKET}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/downloads/document.pdf"
+ assert uri == expected_uri
+ _assert_object_content(boto3_test_client, uri, test_data)
+
+ async def test_browser_session_file_exists_returns_true(
+ self, s3_storage: S3Storage, boto3_test_client: S3Client, tmp_path: Path
+ ) -> None:
+ """Test browser_session_file_exists returns True for existing file."""
+ test_file = tmp_path / "exists.webm"
+ test_file.write_bytes(b"test data")
+
+ await s3_storage.sync_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ local_file_path=str(test_file),
+ remote_path="exists.webm",
+ date="2025-01-15",
+ )
+
+ exists = await s3_storage.browser_session_file_exists(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ remote_path="exists.webm",
+ date="2025-01-15",
+ )
+ assert exists is True
+
+ async def test_browser_session_file_exists_returns_false(self, s3_storage: S3Storage) -> None:
+ """Test browser_session_file_exists returns False for non-existent file."""
+ exists = await s3_storage.browser_session_file_exists(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ remote_path="nonexistent.webm",
+ date="2025-01-15",
+ )
+ assert exists is False
+
+ async def test_delete_browser_session_file(
+ self, s3_storage: S3Storage, boto3_test_client: S3Client, tmp_path: Path
+ ) -> None:
+ """Test deleting a browser session file."""
+ test_file = tmp_path / "to_delete.webm"
+ test_file.write_bytes(b"test data")
+
+ await s3_storage.sync_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ local_file_path=str(test_file),
+ remote_path="to_delete.webm",
+ date="2025-01-15",
+ )
+
+ exists_before = await s3_storage.browser_session_file_exists(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ remote_path="to_delete.webm",
+ date="2025-01-15",
+ )
+ assert exists_before is True
+
+ await s3_storage.delete_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ remote_path="to_delete.webm",
+ date="2025-01-15",
+ )
+
+ exists_after = await s3_storage.browser_session_file_exists(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="videos",
+ remote_path="to_delete.webm",
+ date="2025-01-15",
+ )
+ assert exists_after is False
+
+ async def test_file_exists_returns_true(
+ self, s3_storage: S3Storage, boto3_test_client: S3Client, tmp_path: Path
+ ) -> None:
+ """Test file_exists returns True for existing file."""
+ test_file = tmp_path / "test.txt"
+ test_file.write_bytes(b"test data")
+
+ uri = await s3_storage.sync_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="downloads",
+ local_file_path=str(test_file),
+ remote_path="test.txt",
+ )
+
+ exists = await s3_storage.file_exists(uri)
+ assert exists is True
+
+ async def test_file_exists_returns_false(self, s3_storage: S3Storage) -> None:
+ """Test file_exists returns False for non-existent file."""
+ uri = f"s3://{TEST_BUCKET}/nonexistent/path/file.txt"
+ exists = await s3_storage.file_exists(uri)
+ assert exists is False
+
+ async def test_download_uploaded_file(
+ self, s3_storage: S3Storage, boto3_test_client: S3Client, tmp_path: Path
+ ) -> None:
+ """Test downloading an uploaded file."""
+ test_data = b"uploaded file content"
+ test_file = tmp_path / "uploaded.pdf"
+ test_file.write_bytes(test_data)
+
+ uri = await s3_storage.sync_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type="downloads",
+ local_file_path=str(test_file),
+ remote_path="uploaded.pdf",
+ )
+
+ downloaded = await s3_storage.download_uploaded_file(uri)
+ assert downloaded == test_data
+
+ async def test_download_uploaded_file_nonexistent(self, s3_storage: S3Storage) -> None:
+ """Test downloading a non-existent file returns None."""
+ uri = f"s3://{TEST_BUCKET}/nonexistent/path/file.txt"
+ downloaded = await s3_storage.download_uploaded_file(uri)
+ assert downloaded is None
+
+ def test_storage_type_property(self, s3_storage: S3Storage) -> None:
+ """Test storage_type returns 's3'."""
+ assert s3_storage.storage_type == "s3"
+
+
+CONTENT_TYPE_TEST_CASES = [
+ # (filename, expected_content_type, artifact_type, date)
+ ("video.webm", "video/webm", "videos", "2025-01-15"),
+ ("data.json", "application/json", "har", "2025-01-15"),
+ ("network.har", "application/json", "har", "2025-01-15"),
+ ("screenshot.png", "image/png", "downloads", None),
+ ("output.txt", "text/plain", "downloads", None),
+ ("debug.log", "text/plain", "downloads", None),
+]
+
+
+class TestS3StorageContentType:
+ """Test S3Storage content type guessing."""
+
+ @pytest.mark.parametrize("filename,expected_content_type,artifact_type,date", CONTENT_TYPE_TEST_CASES)
+ async def test_content_type_guessing(
+ self,
+ s3_storage: S3Storage,
+ boto3_test_client: S3Client,
+ tmp_path: Path,
+ filename: str,
+ expected_content_type: str,
+ artifact_type: str,
+ date: str | None,
+ ) -> None:
+ """Test that files get correct content type based on extension."""
+ test_file = tmp_path / filename
+ test_file.write_bytes(b"test content")
+
+ uri = await s3_storage.sync_browser_session_file(
+ organization_id=TEST_ORGANIZATION_ID,
+ browser_session_id=TEST_BROWSER_SESSION_ID,
+ artifact_type=artifact_type,
+ local_file_path=str(test_file),
+ remote_path=filename,
+ date=date,
+ )
+
+ s3uri = S3Uri(uri)
+ obj_meta = boto3_test_client.head_object(Bucket=TEST_BUCKET, Key=s3uri.key)
+ assert obj_meta["ContentType"] == expected_content_type
diff --git a/skyvern/forge/sdk/routes/agent_protocol.py b/skyvern/forge/sdk/routes/agent_protocol.py
index d6184d3ab..aeb1dd39c 100644
--- a/skyvern/forge/sdk/routes/agent_protocol.py
+++ b/skyvern/forge/sdk/routes/agent_protocol.py
@@ -1294,15 +1294,9 @@ async def get_artifact(
status_code=http_status.HTTP_404_NOT_FOUND,
detail=f"Artifact not found {artifact_id}",
)
- if settings.ENV != "local" or settings.GENERATE_PRESIGNED_URLS:
- signed_urls = await app.ARTIFACT_MANAGER.get_share_links([artifact])
- if signed_urls:
- artifact.signed_url = signed_urls[0]
- else:
- LOG.warning(
- "Failed to get signed url for artifact",
- artifact_id=artifact_id,
- )
+ signed_urls = await app.ARTIFACT_MANAGER.get_share_links([artifact])
+ if signed_urls and len(signed_urls) == 1:
+ artifact.signed_url = signed_urls[0]
return artifact
@@ -1334,23 +1328,10 @@ async def get_run_artifacts(
# Ensure we have a list of artifacts (since group_by_type=False, this will always be a list)
artifacts_list = artifacts if isinstance(artifacts, list) else []
- if settings.ENV != "local" or settings.GENERATE_PRESIGNED_URLS:
- # Get signed URLs for all artifacts
- signed_urls = await app.ARTIFACT_MANAGER.get_share_links(artifacts_list)
-
- if signed_urls and len(signed_urls) == len(artifacts_list):
- for i, artifact in enumerate(artifacts_list):
- if hasattr(artifact, "signed_url"):
- artifact.signed_url = signed_urls[i]
- elif signed_urls:
- LOG.warning(
- "Mismatch between artifacts and signed URLs count",
- artifacts_count=len(artifacts_list),
- urls_count=len(signed_urls),
- run_id=run_id,
- )
- else:
- LOG.warning("Failed to get signed urls for artifacts", run_id=run_id)
+ signed_urls = await app.ARTIFACT_MANAGER.get_share_links(artifacts_list)
+ if signed_urls and len(signed_urls) == len(artifacts_list):
+ for i, artifact in enumerate(artifacts_list):
+ artifact.signed_url = signed_urls[i]
return ORJSONResponse([artifact.model_dump() for artifact in artifacts_list])
@@ -1976,17 +1957,10 @@ async def get_artifacts(
}
artifacts = await app.DATABASE.get_artifacts_by_entity_id(organization_id=current_org.organization_id, **params) # type: ignore
- if settings.ENV != "local" or settings.GENERATE_PRESIGNED_URLS:
- signed_urls = await app.ARTIFACT_MANAGER.get_share_links(artifacts)
- if signed_urls:
- for i, artifact in enumerate(artifacts):
- artifact.signed_url = signed_urls[i]
- else:
- LOG.warning(
- "Failed to get signed urls for artifacts",
- entity_type=entity_type,
- entity_id=entity_id,
- )
+ signed_urls = await app.ARTIFACT_MANAGER.get_share_links(artifacts)
+ if signed_urls and len(signed_urls) == len(artifacts):
+ for i, artifact in enumerate(artifacts):
+ artifact.signed_url = signed_urls[i]
return ORJSONResponse([artifact.model_dump() for artifact in artifacts])
@@ -2021,17 +1995,10 @@ async def get_step_artifacts(
step_id,
organization_id=current_org.organization_id,
)
- if settings.ENV != "local" or settings.GENERATE_PRESIGNED_URLS:
- signed_urls = await app.ARTIFACT_MANAGER.get_share_links(artifacts)
- if signed_urls:
- for i, artifact in enumerate(artifacts):
- artifact.signed_url = signed_urls[i]
- else:
- LOG.warning(
- "Failed to get signed urls for artifacts",
- task_id=task_id,
- step_id=step_id,
- )
+ signed_urls = await app.ARTIFACT_MANAGER.get_share_links(artifacts)
+ if signed_urls and len(signed_urls) == len(artifacts):
+ for i, artifact in enumerate(artifacts):
+ artifact.signed_url = signed_urls[i]
return ORJSONResponse([artifact.model_dump() for artifact in artifacts])
diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.py
index 1b296ab85..2b22d82fa 100644
--- a/skyvern/forge/sdk/workflow/models/block.py
+++ b/skyvern/forge/sdk/workflow/models/block.py
@@ -2603,9 +2603,8 @@ class FileUploadBlock(Block):
blob_name = self._get_azure_blob_name(workflow_run_id, file_path)
azure_uri = self._get_azure_blob_uri(workflow_run_id, blob_name)
uploaded_uris.append(azure_uri)
- await azure_client.upload_file_from_path(
- container_name=self.azure_blob_container_name or "", blob_name=blob_name, file_path=file_path
- )
+ uri = f"azure://{self.azure_blob_container_name or ''}/{blob_name}"
+ await azure_client.upload_file_from_path(uri, file_path)
LOG.info("FileUploadBlock: File(s) uploaded to Azure Blob Storage", file_path=self.path)
else:
# This case should ideally be caught by the initial validation