service-forge 0.1.24__py3-none-any.whl → 0.1.27__py3-none-any.whl

service_forge/api/http_api.py

@@ -3,7 +3,7 @@ import uvicorn
 from fastapi import APIRouter
 from loguru import logger
 from urllib.parse import urlparse
-from fastapi import HTTPException, Request
+from fastapi import HTTPException, Request, WebSocket, WebSocketException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.utils import get_openapi
 from service_forge.api.routers.websocket.websocket_router import websocket_router
@@ -36,6 +36,88 @@ def is_trusted_origin(origin_host: str, host: str, trusted_root: str = "ring.shi
     )
 
 
+def validate_auth_from_headers(
+    headers: dict,
+    origin: str | None,
+    scheme: str,
+    host: str,
+    trusted_domain: str = "ring.shiweinan.com",
+) -> tuple[str | None, str | None]:
+    """
+    Validate authentication from headers and return user_id and token.
+    
+    Args:
+        headers: Dictionary of headers (can be from Request or WebSocket)
+        origin: Origin header value
+        scheme: URL scheme (http/https/ws/wss)
+        host: Host header value
+        trusted_domain: Trusted domain for origin validation
+        
+    Returns:
+        tuple: (user_id, auth_token) - user_id can be None if not authenticated and not same origin
+    """
+    is_same_origin = False
+    
+    logger.debug(f"origin {origin}, host:{host}")
+    
+    if origin and host:
+        try:
+            parsed_origin = urlparse(origin)
+            parsed_host = urlparse(f"{scheme}://{host}")
+            is_same_origin = (
+                parsed_origin.hostname == parsed_host.hostname
+                and parsed_origin.port == parsed_host.port
+                and is_trusted_origin(parsed_origin.hostname, parsed_host.hostname, trusted_domain)
+            )
+        except Exception:
+            pass
+    
+    user_id = headers.get("X-User-ID")
+    token = headers.get("X-User-Token")
+    
+    if not is_same_origin:
+        # For cross-origin requests, user_id is required
+        if not user_id:
+            return None, None
+        return user_id, token
+    else:
+        # For same-origin requests, user_id defaults to "0" if not provided
+        return user_id if user_id else "0", token
+
+
+async def authenticate_websocket(
+    websocket: WebSocket,
+    trusted_domain: str = "ring.shiweinan.com",
+) -> None:
+    """
+    Authenticate WebSocket connection and set user_id and auth_token in websocket.state.
+    
+    Args:
+        websocket: WebSocket instance
+        trusted_domain: Trusted domain for origin validation
+        
+    Raises:
+        WebSocketException: If authentication fails
+    """
+    origin = websocket.headers.get("origin") or websocket.headers.get("referer")
+    scheme = websocket.url.scheme
+    host = websocket.headers.get("host", "")
+    
+    user_id, token = validate_auth_from_headers(
+        websocket.headers,
+        origin,
+        scheme,
+        host,
+        trusted_domain,
+    )
+    
+    if user_id is None:
+        raise WebSocketException(code=1008, reason="Unauthorized")
+    
+    websocket.state.user_id = user_id
+    websocket.state.auth_token = token
+
+
 def create_app(
     app: FastAPI | None = None,
     routers: list[APIRouter] | None = None,
@@ -77,6 +159,10 @@ def create_app(
         for router in routers:
             app.include_router(router)
     
+    # Store auth configuration in app.state for WebSocket endpoints to access
+    app.state.enable_auth_middleware = enable_auth_middleware
+    app.state.trusted_domain = trusted_domain
+
     # Always include WebSocket router
     app.include_router(websocket_router)
 
@@ -100,31 +186,20 @@ def create_app(
                 origin = request.headers.get("origin") or request.headers.get("referer")
                 scheme = request.url.scheme
                 host = request.headers.get("host", "")
-                is_same_origin = False
                 
-                logger.debug(f"origin {origin}, host:{host}")
+                user_id, token = validate_auth_from_headers(
+                    request.headers,
+                    origin,
+                    scheme,
+                    host,
+                    trusted_domain,
+                )
+                
+                if user_id is None:
+                    raise HTTPException(status_code=401, detail="Unauthorized")
                 
-                if origin and host:
-                    try:
-                        parsed_origin = urlparse(origin)
-                        parsed_host = urlparse(f"{scheme}://{host}")
-                        is_same_origin = (
-                            parsed_origin.hostname == parsed_host.hostname
-                            and parsed_origin.port == parsed_host.port
-                            and is_trusted_origin(parsed_origin.hostname, parsed_host.hostname, trusted_domain)
-                        )
-                    except Exception:
-                        pass  # If parsing fails, continue with default behavior
-                if not is_same_origin:
-                    headers = request.headers
-                    user_id = headers.get("X-User-ID")
-                    if not user_id:
-                        raise HTTPException(status_code=401, detail="Unauthorized")
-                    
-                    request.state.user_id = user_id
-                else:
-                    # Same-origin requests can skip auth, but still set default user_id
-                    request.state.user_id = "0"  # Can be None or default value as needed
+                request.state.user_id = user_id
+                request.state.auth_token = token
 
             return await call_next(request)
     
@@ -147,6 +222,7 @@ async def start_fastapi_server(host: str, port: int):
 
 try:
     metadata = load_metadata("sf-meta.yaml")
-    fastapi_app = create_app(enable_auth_middleware=False, root_path=f"/api/v1/{get_service_url_name(metadata.name, metadata.version)}")
+    fastapi_app = create_app(enable_auth_middleware=metadata.enable_auth_middleware, root_path=f"/api/v1/{get_service_url_name(metadata.name, metadata.version)}")
 except Exception as e:
-    fastapi_app = create_app(enable_auth_middleware=False, root_path=None)
+    logger.warning(f"Failed to load metadata, using default configuration: {e}")
+    fastapi_app = create_app(enable_auth_middleware=True, root_path=None)

service_forge/api/routers/websocket/websocket_router.py

@@ -9,6 +9,19 @@ websocket_router = APIRouter()
 
 @websocket_router.websocket("/sdk/ws")
 async def sdk_websocket_endpoint(websocket: WebSocket):
+    # Authenticate WebSocket connection before accepting
+    # Get trusted_domain from app.state if available
+    # trusted_domain = getattr(websocket.app.state, "trusted_domain", "ring.shiweinan.com")
+    # enable_auth = getattr(websocket.app.state, "enable_auth_middleware", True)
+    
+    # if enable_auth:
+    #     from service_forge.api.http_api import authenticate_websocket
+    #     await authenticate_websocket(websocket, trusted_domain)
+    # else:
+    #     # If auth is disabled, set default values
+    #     websocket.state.user_id = websocket.headers.get("X-User-ID", "0")
+    #     websocket.state.auth_token = websocket.headers.get("X-User-Token")
+    
     await websocket.accept()
     try:
         while True:

service_forge/service.py

@@ -4,6 +4,7 @@ import os
 import asyncio
 import threading
 import uuid
+from importlib.metadata import version
 from loguru import logger
 from typing import Callable, AsyncIterator, Awaitable, Any, TYPE_CHECKING
 from service_forge.workflow.node import node_register
@@ -260,6 +261,12 @@ class Service:
     
     @staticmethod
     def from_config(metadata: SfMetadata, service_env: dict[str, Any] = None, config: ServiceConfig = None) -> Service:
+        try:
+            service_forge_version = version("service-forge")
+            logger.info(f"service-forge version: {service_forge_version}")
+        except Exception as e:
+            logger.warning(f"Failed to get service-forge version: {e}")
+        
         if config is not None:
             config_path = None
         else:

service_forge/sft/config/injector.py

@@ -133,9 +133,14 @@ class Injector:
                 f.write(new_content)
 
     def inject(self) -> None:
-        self.inject_deployment()
-        self.inject_service_config()
-        self.inject_ingress()
-        self.inject_dockerfile()
-        self.inject_pyproject_toml()
-        self.clear_start_sh()
+        if self.metadata.inject.deployment:
+            self.inject_deployment()
+        if self.metadata.inject.service_config:
+            self.inject_service_config()
+        if self.metadata.inject.ingress:
+            self.inject_ingress()
+        if self.metadata.inject.dockerfile:
+            self.inject_dockerfile()
+        if self.metadata.inject.pyproject_toml:
+            self.inject_pyproject_toml()
+        self.clear_start_sh()

service_forge/sft/config/sf_metadata.py

@@ -1,30 +1,29 @@
-from omegaconf import OmegaConf
+from __future__ import annotations
+import yaml
+from pydantic import BaseModel
 
-class SfMetadata:
-    def __init__(
-        self,
-        name: str,
-        version: str,
-        description: str,
-        service_config: str,
-        config_only: bool,
-        env: list[dict],
-    ) -> None:
-        self.name = name
-        self.version = version
-        self.description = description
-        self.service_config = service_config
-        self.config_only = config_only
-        self.env = env
+class SfMetadataInject(BaseModel):
+    deployment: bool = True
+    service_config: bool = True
+    ingress: bool = True
+    dockerfile: bool = True
+    pyproject_toml: bool = True
+
+class SfMetadata(BaseModel):
+    name: str
+    version: str
+    description: str
+    service_config: str
+    config_only: bool
+    env: list[dict]
+    inject: SfMetadataInject = SfMetadataInject()
+    enable_auth_middleware: bool = True
+
+    @classmethod
+    def from_yaml_file(cls, filepath: str) -> SfMetadata:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            data = yaml.safe_load(f)
+        return cls(**data)
 
 def load_metadata(path: str) -> SfMetadata:
-    with open(path, 'r') as file:
-        data = OmegaConf.load(file)
-        return SfMetadata(
-            name=data.get('name'),
-            version=data.get('version'),
-            description=data.get('description'),
-            service_config=data.get('service_config'),
-            config_only=data.get('config_only'),
-            env=data.get('env', []),
-        )
+    return SfMetadata.from_yaml_file(path)

service_forge/sft/util/assert_util.py

@@ -2,7 +2,6 @@ import typer
 from pathlib import Path
 from typing import Callable, TypeVar, Any
 from service_forge.sft.util.logger import log_error, log_info
-from service_forge.sft.config.sf_metadata import load_metadata, SfMetadata
 
 T = TypeVar('T')
 

service_forge/workflow/triggers/fast_api_trigger.py

@@ -26,6 +26,7 @@ class FastAPITrigger(Trigger):
     DEFAULT_OUTPUT_PORTS = [
         Port("trigger", bool),
         Port("user_id", int),
+        Port("token", str),
         Port("data", Any),
     ]
 
@@ -72,6 +73,7 @@ class FastAPITrigger(Trigger):
         self.trigger_queue.put_nowait({
             "id": task_id,
             "user_id": getattr(request.state, "user_id", None),
+            "token": getattr(request.state, "auth_token", None),
             "data": converted_data,
         })
 
@@ -169,6 +171,7 @@ class FastAPITrigger(Trigger):
             try:
                 trigger = await self.trigger_queue.get()
                 self.prepare_output_edges(self.get_output_port_by_name('user_id'), trigger['user_id'])
+                self.prepare_output_edges(self.get_output_port_by_name('token'), trigger['token'])
                 self.prepare_output_edges(self.get_output_port_by_name('data'), trigger['data'])
                 yield self.trigger(trigger['id'])
             except Exception as e:

service_forge/workflow/triggers/websocket_api_trigger.py

@@ -9,6 +9,7 @@ from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from service_forge.workflow.port import Port
 from google.protobuf.message import Message
 from google.protobuf.json_format import MessageToJson
+from service_forge.api.http_api import authenticate_websocket
 
 class WebSocketAPITrigger(Trigger):
     DEFAULT_INPUT_PORTS = [
@@ -19,6 +20,8 @@ class WebSocketAPITrigger(Trigger):
 
     DEFAULT_OUTPUT_PORTS = [
         Port("trigger", bool),
+        Port("user_id", int),
+        Port("token", str),
         Port("data", Any),
     ]
 
@@ -36,6 +39,20 @@ class WebSocketAPITrigger(Trigger):
             )
         return result
 
+    async def send_message(
+        self,
+        websocket: WebSocket,
+        type: str,
+        task_id: uuid.UUID,
+        data: Any,
+    ):
+        message = {
+            "type": type,
+            "task_id": str(task_id),
+            "data": data
+        }
+        await websocket.send_text(json.dumps(message))
+
     async def handle_stream_output(
         self,
         websocket: WebSocket,
@@ -46,12 +63,7 @@ class WebSocketAPITrigger(Trigger):
                 item = await self.stream_queues[task_id].get()
 
                 if item.is_error:
-                    error_response = {
-                        "type": "stream_error",
-                        "task_id": str(task_id),
-                        "detail": str(item.result)
-                    }
-                    await websocket.send_text(json.dumps(error_response))
+                    await self.send_message(websocket, "stream_error", task_id, str(item.result))
                     break
                 
                 if item.is_end:
@@ -65,18 +77,9 @@ class WebSocketAPITrigger(Trigger):
                                 data = serialized
                         else:
                             data = serialized
-                        
-                        end_response = {
-                            "type": "stream_end",
-                            "task_id": str(task_id),
-                            "data": data
-                        }
+                        await self.send_message(websocket, "stream_end", task_id, data)
                     else:
-                        end_response = {
-                            "type": "stream_end",
-                            "task_id": str(task_id)
-                        }
-                    await websocket.send_text(json.dumps(end_response))
+                        await self.send_message(websocket, "stream_end", task_id, None)
                     break
 
                 # Send stream data
@@ -89,23 +92,10 @@ class WebSocketAPITrigger(Trigger):
                 else:
                     data = serialized
                 
-                stream_response = {
-                    "type": "stream",
-                    "task_id": str(task_id),
-                    "data": data
-                }
-                await websocket.send_text(json.dumps(stream_response))
+                await self.send_message(websocket, "stream", task_id, data)
         except Exception as e:
             logger.error(f"Error handling stream output for task {task_id}: {e}")
-            error_response = {
-                "type": "stream_error",
-                "task_id": str(task_id),
-                "detail": str(e)
-            }
-            try:
-                await websocket.send_text(json.dumps(error_response))
-            except Exception:
-                pass
+            await self.send_message(websocket, "stream_error", task_id, str(e))
         finally:
             if task_id in self.stream_queues:
                 del self.stream_queues[task_id]
@@ -120,6 +110,8 @@ class WebSocketAPITrigger(Trigger):
         self.result_queues[task_id] = asyncio.Queue()
         self.stream_queues[task_id] = asyncio.Queue()
 
+        logger.info('user_id', getattr(websocket.state, "user_id", None), 'token', getattr(websocket.state, "auth_token", None))
+
         if data_type is Any:
             converted_data = message_data
         else:
@@ -136,6 +128,8 @@ class WebSocketAPITrigger(Trigger):
 
         self.trigger_queue.put_nowait({
             "id": task_id,
+            "user_id": getattr(websocket.state, "user_id", None),
+            "token": getattr(websocket.state, "auth_token", None),
             "data": converted_data,
         })
 
@@ -143,6 +137,18 @@ class WebSocketAPITrigger(Trigger):
 
     def _setup_websocket(self, app: FastAPI, path: str, data_type: type) -> None:
         async def websocket_handler(websocket: WebSocket):
+            # Authenticate WebSocket connection before accepting
+            # Get trusted_domain from app.state if available
+            trusted_domain = getattr(app.state, "trusted_domain", "ring.shiweinan.com")
+            enable_auth = getattr(app.state, "enable_auth_middleware", True)
+            
+            if enable_auth:
+                await authenticate_websocket(websocket, trusted_domain)
+            else:
+                # If auth is disabled, set default values
+                websocket.state.user_id = websocket.headers.get("X-User-ID", "0")
+                websocket.state.auth_token = websocket.headers.get("X-User-Token")
+            
             await websocket.accept()
             
             try:
@@ -178,6 +184,8 @@ class WebSocketAPITrigger(Trigger):
         while True:
             try:
                 trigger = await self.trigger_queue.get()
+                self.prepare_output_edges(self.get_output_port_by_name('user_id'), trigger['user_id'])
+                self.prepare_output_edges(self.get_output_port_by_name('token'), trigger['token'])
                 self.prepare_output_edges(self.get_output_port_by_name('data'), trigger['data'])
                 yield self.trigger(trigger['id'])
             except Exception as e:

{service_forge-0.1.24.dist-info → service_forge-0.1.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: service-forge
-Version: 0.1.24
+Version: 0.1.27
 Summary: Add your description here
 Author-email: euxcet <zcc.qwer@gmail.com>
 Requires-Python: >=3.11

{service_forge-0.1.24.dist-info → service_forge-0.1.27.dist-info}/RECORD

@@ -1,16 +1,16 @@
 service_forge/current_service.py,sha256=0YKm7nQiXzUUAc1ToCcbG1QPJfOSNKcOHUpyJ4E3xrY,342
-service_forge/service.py,sha256=rZZ7-BXTTCrc6KqnONnKpg-bRs5JCfDTvMrl4K26vbE,12633
+service_forge/service.py,sha256=lHsZraEH6Ze20QO5v6iW1MO8src8T8JKLFRBXtd0LD0,12933
 service_forge/service_config.py,sha256=zsTdCZ1peMAotjGEVypPos7d-gjwrYoB9x_12g95G4g,1242
 service_forge/api/deprecated_websocket_api.py,sha256=E36-fpUPxzMJ2YGlCPeqwRbryk2FMMbQD_pbb8k1FYI,3343
 service_forge/api/deprecated_websocket_manager.py,sha256=Xiwg3zwXRVi63sXmVH-TgbpL2XH_djyLeo96STm4cNM,16757
-service_forge/api/http_api.py,sha256=XnEQ45zuWQV1zrSL9vd3USUh47ymkVc4w_1SoFlNdl8,5648
+service_forge/api/http_api.py,sha256=8vcN7oyxwTwu_w1f-Egh2XrFWsm-ci5_gk7KsQiP1iM,7673
 service_forge/api/http_api_doc.py,sha256=ASlxvsIiUzDcMhVoumRjt9CfEMbh0O1U4ZLC9eobLF8,20235
 service_forge/api/kafka_api.py,sha256=PInx2ZzKJRON7EaJFWroXkiOt_UeZY7WE6qK03gq4ak,4599
 service_forge/api/task_manager.py,sha256=9Lk-NV4cBnuv9b8V6GVLWJJ4MCiAwCp5TVAwmYgqXbs,5269
 service_forge/api/routers/feedback/feedback_router.py,sha256=JOJI6kaQYapg4__iA6Eo26_9su48p7R2Kpn422nbsxw,5640
 service_forge/api/routers/service/service_router.py,sha256=hGOT-ScnXR7agHp-F9OFGWiPFjG9f3gl7NBsnayW3JI,5088
 service_forge/api/routers/websocket/websocket_manager.py,sha256=j1AFqzXQhZZyaLQwhvZefXAS-zCOPzLcRMDEuusv6V0,3605
-service_forge/api/routers/websocket/websocket_router.py,sha256=V0B7eQP8toO94-WbTrGraadXD3qeZ9lnKFcxwx6kLgM,3777
+service_forge/api/routers/websocket/websocket_router.py,sha256=sPDJriEpD2mqu4508cOaWK7u040sgOdaUFlyiBqCSgc,4447
 service_forge/db/__init__.py,sha256=EWLhH8bYsMOvRF_YXF6FgL3irKA6GZeLxSGvWDRM6f8,85
 service_forge/db/database.py,sha256=WKtZ0MoOnbMw54ohfs9zKsrOZ5_qenLvXkAV_Gr2WOs,10068
 service_forge/db/migrations/feedback_migration.py,sha256=-zQ71TsOlWmQPQo1NKSIu3C1T47v3cfD6IAQ5HE_ffk,4845
@@ -30,15 +30,15 @@ service_forge/sft/cmd/remote_deploy.py,sha256=AStAlbqGD7XeZFhL0fx2j12YWP_MVbdURb
 service_forge/sft/cmd/remote_list_tars.py,sha256=mx6hkNnu0ySMyBX2Qi6blKMj5xnNnrmXq3VD_nERlmw,4176
 service_forge/sft/cmd/service_command.py,sha256=69GMMN61KtuoEFuYzFJ74ivNt8RX8q0I6rbePfJfEwQ,5538
 service_forge/sft/cmd/upload_service.py,sha256=86PvvJSXCZKH4BU6rLytuc45grX-sRnQnOHCo9zUaPY,1232
-service_forge/sft/config/injector.py,sha256=-eU21Ob09ond9pwHVkjklAd5_qLWWbbf0b91iCg2Kwk,6335
+service_forge/sft/config/injector.py,sha256=V79AW1W_LyU-Hn2QgJlLyTt8tdI3J1t1jS3wRoXfbSo,6581
 service_forge/sft/config/injector_default_files.py,sha256=f7mNJ5Y9yb4e9kjLn414WiQoZrOue9ok_hq_POG4I2o,2717
-service_forge/sft/config/sf_metadata.py,sha256=Y9akhSCgOd11-oqRs3LIs8FL9pvWNw6hyy57fuFcBhc,866
+service_forge/sft/config/sf_metadata.py,sha256=RruOe3_6JdxLnzMbmdnOcncxwnmATR-1q3Cn8R9d5eE,782
 service_forge/sft/config/sft_config.py,sha256=MgurtgbcSmyXbGlVX3NG84KD4Hst1gZWHdF9a8zi-6U,7707
 service_forge/sft/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 service_forge/sft/file/ignore_pattern.py,sha256=UrVmR83wOx51XHFcZDTPp15dGYcvMTE5W1m07-SvHpw,2521
 service_forge/sft/file/sft_file_manager.py,sha256=poIM77tZZg7vfwBdCsdQctBbCczVLQePdTwVINEABvE,4337
 service_forge/sft/kubernetes/kubernetes_manager.py,sha256=IF2_X9U-k5Dx7EZuGrJ9lZ85ltbilrrZDfsl8qFyTu4,11339
-service_forge/sft/util/assert_util.py,sha256=8HreVkOzs9_ClKiFqG4qsFn_yyDLo5uXYhYUPXlmDjM,828
+service_forge/sft/util/assert_util.py,sha256=6XVTsXKxg92ww3heWzuMvTbybGuw1cmTqWqfiSbPAcY,753
 service_forge/sft/util/logger.py,sha256=0Hi74IoxshE-wBgvBa2EZPXYj37tTrUYwlOBd9UMMMs,502
 service_forge/sft/util/name_util.py,sha256=WSYHM6c7SZULXCFON7nmGqsvAPPs_wavd6QjCa4UbRQ,301
 service_forge/sft/util/yaml_utils.py,sha256=9OhJNQlzj_C1NeQoUZVF8qpDovrE7RDWtNXe-H7tuNA,1703
@@ -74,12 +74,12 @@ service_forge/workflow/nodes/test/if_console_input_node.py,sha256=CtKHkFqr8PN974
 service_forge/workflow/nodes/test/time_consuming_node.py,sha256=gB2qw2DdjRf82z1158u36nSnCHrheHaxscAzPRnXNyk,1813
 service_forge/workflow/triggers/__init__.py,sha256=iQ0WEYu6JgL191Y9XslMhZ7jS7JO8bL3SZ9YqIw5LCM,269
 service_forge/workflow/triggers/a2a_api_trigger.py,sha256=Oaw3vRLA8fWZUIQ-h33dYmojmjp4mwNF_0LHqQ_4mZQ,8583
-service_forge/workflow/triggers/fast_api_trigger.py,sha256=8BF0A8gdcKeiP3cyF_dF0T3MH7bXnnZRCa_h5hx9kQ4,7513
+service_forge/workflow/triggers/fast_api_trigger.py,sha256=bAtnuNkUcB5rApXj7x3oBscdavUnDGTb7lE9OpmtauE,7705
 service_forge/workflow/triggers/kafka_api_trigger.py,sha256=Zv8J75Rmg1-xqxHwpBMBhsm_TWX8p3_rqldk2RVSwVc,1561
 service_forge/workflow/triggers/once_trigger.py,sha256=YmzSQBoKE-8liNFIoDCqi2UdqhHujizsXVDft81_8jA,572
 service_forge/workflow/triggers/period_trigger.py,sha256=JFX3yBjKqoRP55jiulaSG_SPO-zWLMcwEb1BwcKsWUM,767
-service_forge/workflow/triggers/websocket_api_trigger.py,sha256=JjRYb0VM_em90_w3QEErgxMDBCaBHCrSBhTaV4Fl4HY,6894
-service_forge-0.1.24.dist-info/METADATA,sha256=tOQocyV5Smmw3sdoR6k-0MBwB-C0eaMGlG2hRDGj4AY,2308
-service_forge-0.1.24.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-service_forge-0.1.24.dist-info/entry_points.txt,sha256=WHntHW7GAyKQUEeMcMvHDZ7_xAb0-cZeAK4iJeu9lm8,51
-service_forge-0.1.24.dist-info/RECORD,,
+service_forge/workflow/triggers/websocket_api_trigger.py,sha256=JmA0NkOjbskvP6j7Oook2VkHvY4r4OdX6CBih7D5NBg,7588
+service_forge-0.1.27.dist-info/METADATA,sha256=8_qXSBKj6S4P15B2mJW1ZXy1I4d6AT4YXOJPtasMTOw,2308
+service_forge-0.1.27.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+service_forge-0.1.27.dist-info/entry_points.txt,sha256=WHntHW7GAyKQUEeMcMvHDZ7_xAb0-cZeAK4iJeu9lm8,51
+service_forge-0.1.27.dist-info/RECORD,,