autoglm-gui 1.5.5__py3-none-any.whl → 1.5.6__py3-none-any.whl

AutoGLM_GUI/scheduler_manager.py

@@ -1,9 +1,11 @@
 """Scheduled task manager with APScheduler."""
 
+import asyncio
 import json
+from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
@@ -11,6 +13,17 @@ from apscheduler.triggers.cron import CronTrigger
 from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.models.scheduled_task import ScheduledTask
 
+if TYPE_CHECKING:
+    from AutoGLM_GUI.models.history import MessageRecord
+
+
+@dataclass
+class DeviceExecutionResult:
+    serialno: str
+    success: bool
+    message: str
+    device_model: str = ""
+
 
 class SchedulerManager:
     _instance: Optional["SchedulerManager"] = None
@@ -45,14 +58,16 @@ class SchedulerManager:
         self,
         name: str,
         workflow_uuid: str,
-        device_serialno: str,
+        device_serialnos: list[str] | None,
         cron_expression: str,
         enabled: bool = True,
+        device_group_id: str | None = None,
     ) -> ScheduledTask:
         task = ScheduledTask(
             name=name,
             workflow_uuid=workflow_uuid,
-            device_serialno=device_serialno,
+            device_serialnos=device_serialnos or [],
+            device_group_id=device_group_id,
             cron_expression=cron_expression,
             enabled=enabled,
         )
@@ -167,37 +182,31 @@ class SchedulerManager:
         except Exception as e:
             logger.warning(f"Failed to remove job {task_id}: {e}")
 
-    def _execute_task(self, task_id: str) -> None:
-        task = self._tasks.get(task_id)
-        if not task:
-            logger.warning(f"Task {task_id} not found for execution")
-            return
-
-        logger.info(f"Executing scheduled task: {task.name}")
-
-        from AutoGLM_GUI.device_manager import DeviceManager
-        from AutoGLM_GUI.history_manager import history_manager
+    def _execute_single_device(
+        self,
+        serialno: str,
+        workflow: dict[str, Any],
+        task_name: str,
+        manager: Any,
+        device_manager: Any,
+        history_manager: Any,
+    ) -> DeviceExecutionResult:
         from AutoGLM_GUI.models.history import ConversationRecord, MessageRecord
-        from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
-        from AutoGLM_GUI.workflow_manager import workflow_manager
-
-        workflow = workflow_manager.get_workflow(task.workflow_uuid)
-        if not workflow:
-            self._record_failure(task, "Workflow not found")
-            return
 
-        device_manager = DeviceManager.get_instance()
         device = None
         for d in device_manager.get_devices():
-            if d.serial == task.device_serialno and d.state.value == "online":
+            if d.serial == serialno and d.state.value == "online":
                 device = d
                 break
 
         if not device:
-            self._record_failure(task, "Device offline")
-            return
+            return DeviceExecutionResult(
+                serialno=serialno,
+                success=False,
+                message="Device offline",
+                device_model="",
+            )
 
-        manager = PhoneAgentManager.get_instance()
         acquired = manager.acquire_device(
             device.primary_device_id,
             timeout=0,
@@ -206,56 +215,85 @@ class SchedulerManager:
         )
 
         if not acquired:
-            self._record_failure(task, "Device busy")
-            return
+            return DeviceExecutionResult(
+                serialno=serialno,
+                success=False,
+                message="Device busy",
+                device_model=device.model or serialno,
+            )
 
         start_time = datetime.now()
-
-        # 收集完整对话消息
-        messages: list[MessageRecord] = []
-        messages.append(
+        messages: list["MessageRecord"] = [
             MessageRecord(
                 role="user",
                 content=workflow["text"],
                 timestamp=start_time,
             )
-        )
+        ]
+
+        result_message = ""
+        task_success = False
 
         try:
-            agent = manager.get_agent(device.primary_device_id)
-            agent.reset()
+            from AutoGLM_GUI.agents.protocols import is_async_agent
 
-            # 使用 step 循环执行，收集每步信息
-            is_first = True
-            result_message = ""
-            task_success = False
-
-            while agent.step_count < agent.agent_config.max_steps:
-                step_result = agent.step(workflow["text"] if is_first else None)  # type: ignore[misc]
-                is_first = False
-
-                # 收集每个 step 的消息
-                messages.append(
-                    MessageRecord(
-                        role="assistant",
-                        content="",
-                        timestamp=datetime.now(),
-                        thinking=step_result.thinking,  # type: ignore[union-attr]
-                        action=step_result.action,  # type: ignore[union-attr]
-                        step=agent.step_count,
-                    )
-                )
+            agent: Any = manager.get_agent(device.primary_device_id)
+            agent.reset()
 
-                if step_result.finished:  # type: ignore[union-attr]
-                    result_message = step_result.message or "Task completed"  # type: ignore[union-attr]
-                    task_success = step_result.success  # type: ignore[union-attr]
-                    break
+            if is_async_agent(agent):
+
+                async def run_async():
+                    nonlocal result_message, task_success
+                    stream_gen = agent.stream(workflow["text"])
+                    async for event in stream_gen:
+                        step_data: dict[str, Any] = event.get("data", {})
+                        if event["type"] == "step":
+                            messages.append(
+                                MessageRecord(
+                                    role="assistant",
+                                    content="",
+                                    timestamp=datetime.now(),
+                                    thinking=step_data.get("thinking", ""),
+                                    action=step_data.get("action", {}),
+                                    step=step_data.get("step", 0),
+                                )
+                            )
+                        elif event["type"] == "done":
+                            result_message = step_data.get("message", "Task completed")
+                            task_success = step_data.get("success", False)
+                            break
+                        elif event["type"] == "error":
+                            result_message = step_data.get("message", "Task failed")
+                            task_success = False
+                            break
+
+                asyncio.run(run_async())
             else:
-                result_message = "Max steps reached"
-                task_success = False
+                is_first = True
+                while agent.step_count < agent.agent_config.max_steps:
+                    step_result = agent.step(workflow["text"] if is_first else None)
+                    is_first = False
+                    messages.append(
+                        MessageRecord(
+                            role="assistant",
+                            content="",
+                            timestamp=datetime.now(),
+                            thinking=step_result.thinking,
+                            action=step_result.action,
+                            step=agent.step_count,
+                        )
+                    )
+                    if step_result.finished:
+                        result_message = step_result.message or "Task completed"
+                        task_success = step_result.success
+                        break
+                else:
+                    result_message = "Max steps reached"
+                    task_success = False
 
             steps = agent.step_count
             end_time = datetime.now()
+            device_model = device.model or serialno
 
             record = ConversationRecord(
                 task_text=workflow["text"],
@@ -266,21 +304,23 @@ class SchedulerManager:
                 end_time=end_time,
                 duration_ms=int((end_time - start_time).total_seconds() * 1000),
                 source="scheduled",
-                source_detail=task.name,
+                source_detail=f"{task_name} [{device_model}]",
                 error_message=None if task_success else result_message,
                 messages=messages,
             )
-            history_manager.add_record(task.device_serialno, record)
+            history_manager.add_record(serialno, record)
 
-            if task_success:
-                self._record_success(task, result_message)
-            else:
-                self._record_failure(task, result_message)
+            return DeviceExecutionResult(
+                serialno=serialno,
+                success=task_success,
+                message=result_message,
+                device_model=device_model,
+            )
 
         except Exception as e:
             end_time = datetime.now()
             error_msg = str(e)
-            logger.error(f"Scheduled task failed: {task.name} - {error_msg}")
+            device_model = device.model or serialno
 
             record = ConversationRecord(
                 task_text=workflow["text"],
@@ -291,30 +331,165 @@ class SchedulerManager:
                 end_time=end_time,
                 duration_ms=int((end_time - start_time).total_seconds() * 1000),
                 source="scheduled",
-                source_detail=task.name,
+                source_detail=f"{task_name} [{device_model}]",
                 error_message=error_msg,
                 messages=messages,
             )
-            history_manager.add_record(task.device_serialno, record)
+            history_manager.add_record(serialno, record)
 
-            self._record_failure(task, error_msg)
+            return DeviceExecutionResult(
+                serialno=serialno,
+                success=False,
+                message=error_msg,
+                device_model=device_model,
+            )
 
         finally:
             manager.release_device(device.primary_device_id)
 
-    def _record_success(self, task: ScheduledTask, message: str) -> None:
-        task.last_run_time = datetime.now()
-        task.last_run_success = True
-        task.last_run_message = message[:500] if message else ""
-        self._save_tasks()
-        logger.info(f"Scheduled task completed: {task.name}")
+    def _resolve_device_serialnos(self, task: ScheduledTask) -> list[str]:
+        """解析任务的目标设备列表.
+
+        如果指定了 device_group_id，则从分组获取设备列表；
+        否则使用 device_serialnos 字段。
+        """
+        if task.device_group_id:
+            from AutoGLM_GUI.device_group_manager import device_group_manager
+            from AutoGLM_GUI.device_manager import DeviceManager
+
+            device_manager = DeviceManager.get_instance()
+
+            # 获取分组内的所有设备
+            if task.device_group_id == "default":
+                # 默认分组：获取所有未分配到其他分组的设备
+                assignments = device_group_manager.get_all_assignments()
+                assigned_serials = {
+                    s for s, gid in assignments.items() if gid != "default"
+                }
+                managed_devices = device_manager.get_devices()
+                return [
+                    d.serial
+                    for d in managed_devices
+                    if d.serial not in assigned_serials
+                ]
+            else:
+                # 其他分组：从分配中获取
+                return device_group_manager.get_devices_in_group(task.device_group_id)
+        else:
+            return task.device_serialnos
 
-    def _record_failure(self, task: ScheduledTask, error: str) -> None:
+    def _execute_task(self, task_id: str) -> None:
+        task = self._tasks.get(task_id)
+        if not task:
+            logger.warning(f"Task {task_id} not found for execution")
+            return
+
+        # 解析目标设备列表
+        device_serialnos = self._resolve_device_serialnos(task)
+
+        logger.info(
+            f"Executing scheduled task: {task.name} on {len(device_serialnos)} device(s)"
+        )
+
+        from AutoGLM_GUI.device_manager import DeviceManager
+        from AutoGLM_GUI.history_manager import history_manager
+        from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
+        from AutoGLM_GUI.workflow_manager import workflow_manager
+
+        workflow = workflow_manager.get_workflow(task.workflow_uuid)
+        if not workflow:
+            self._record_run(
+                task=task,
+                status="failure",
+                message="Workflow not found",
+                success_count=0,
+                total_count=len(device_serialnos),
+            )
+            return
+
+        device_manager = DeviceManager.get_instance()
+        manager = PhoneAgentManager.get_instance()
+
+        total_count = len(device_serialnos)
+        if total_count == 0:
+            self._record_run(
+                task=task,
+                status="failure",
+                message="No devices selected",
+                success_count=0,
+                total_count=0,
+            )
+            return
+
+        results: list[DeviceExecutionResult] = []
+        for serialno in device_serialnos:
+            result = self._execute_single_device(
+                serialno=serialno,
+                workflow=workflow,
+                task_name=task.name,
+                manager=manager,
+                device_manager=device_manager,
+                history_manager=history_manager,
+            )
+            results.append(result)
+            status_icon = "✓" if result.success else "✗"
+            logger.info(
+                f"  {status_icon} {result.device_model or result.serialno}: {result.message[:50]}"
+            )
+
+        success_count = sum(1 for r in results if r.success)
+        any_success = success_count > 0
+        all_success = success_count == total_count
+
+        summary_parts = []
+        for r in results:
+            status = "✓" if r.success else "✗"
+            short_serial = r.serialno[:8] + "..." if len(r.serialno) > 8 else r.serialno
+            display_name = r.device_model or short_serial
+            summary_parts.append(f"{status} {display_name}: {r.message[:30]}")
+        summary_message = " | ".join(summary_parts)
+
+        logger.info(
+            f"Task {task.name} completed: {success_count}/{total_count} devices succeeded"
+        )
+
+        status: str
+        if all_success:
+            status = "success"
+        elif any_success:
+            status = "partial"
+        else:
+            status = "failure"
+
+        self._record_run(
+            task=task,
+            status=status,
+            message=summary_message,
+            success_count=success_count,
+            total_count=total_count,
+        )
+
+    def _record_run(
+        self,
+        task: ScheduledTask,
+        status: str,
+        message: str,
+        success_count: int,
+        total_count: int,
+    ) -> None:
         task.last_run_time = datetime.now()
-        task.last_run_success = False
-        task.last_run_message = error[:500] if error else ""
+        task.last_run_status = status
+        task.last_run_success = status == "success"
+        task.last_run_success_count = success_count
+        task.last_run_total_count = total_count
+        task.last_run_message = message[:500] if message else ""
         self._save_tasks()
-        logger.warning(f"Scheduled task failed: {task.name} - {error}")
+        if status == "success":
+            logger.info(f"Scheduled task completed: {task.name}")
+        elif status == "partial":
+            logger.warning(f"Scheduled task partially succeeded: {task.name}")
+        else:
+            logger.warning(f"Scheduled task failed: {task.name} - {message}")
 
     def _load_tasks(self) -> None:
         if not self._tasks_path.exists():

AutoGLM_GUI/schemas.py

@@ -277,6 +277,7 @@ class DeviceResponse(BaseModel):
     state: str
     is_available_only: bool
     display_name: str | None = None
+    group_id: str = "default"  # 所属分组 ID
     agent: AgentStatusResponse | None = None
 
 
@@ -765,7 +766,8 @@ class ScheduledTaskCreate(BaseModel):
 
     name: str
     workflow_uuid: str
-    device_serialno: str
+    device_serialnos: list[str] | None = None  # 直接指定设备列表
+    device_group_id: str | None = None  # 或指定设备分组
     cron_expression: str
     enabled: bool = True
 
@@ -776,6 +778,21 @@ class ScheduledTaskCreate(BaseModel):
             raise ValueError("name cannot be empty")
         return v.strip()
 
+    @field_validator("device_serialnos")
+    @classmethod
+    def validate_devices(cls, v: list[str] | None) -> list[str] | None:
+        if v is None:
+            return None
+        normalized: list[str] = []
+        seen: set[str] = set()
+        for raw in v or []:
+            s = raw.strip()
+            if not s or s in seen:
+                continue
+            normalized.append(s)
+            seen.add(s)
+        return normalized if normalized else None
+
     @field_validator("cron_expression")
     @classmethod
     def validate_cron(cls, v: str) -> str:
@@ -788,16 +805,41 @@ class ScheduledTaskCreate(BaseModel):
             )
         return v.strip()
 
+    def model_post_init(self, __context) -> None:
+        """验证必须指定 device_serialnos 或 device_group_id 之一."""
+        if not self.device_serialnos and not self.device_group_id:
+            raise ValueError(
+                "either device_serialnos or device_group_id must be specified"
+            )
+
 
 class ScheduledTaskUpdate(BaseModel):
     """更新定时任务请求."""
 
     name: str | None = None
     workflow_uuid: str | None = None
-    device_serialno: str | None = None
+    device_serialnos: list[str] | None = None
+    device_group_id: str | None = None
     cron_expression: str | None = None
     enabled: bool | None = None
 
+    @field_validator("device_serialnos")
+    @classmethod
+    def validate_devices(cls, v: list[str] | None) -> list[str] | None:
+        if v is None:
+            return None
+
+        normalized: list[str] = []
+        seen: set[str] = set()
+        for raw in v:
+            s = raw.strip()
+            if not s or s in seen:
+                continue
+            normalized.append(s)
+            seen.add(s)
+
+        return normalized if normalized else None
+
     @field_validator("cron_expression")
     @classmethod
     def validate_cron(cls, v: str | None) -> str | None:
@@ -819,13 +861,17 @@ class ScheduledTaskResponse(BaseModel):
     id: str
     name: str
     workflow_uuid: str
-    device_serialno: str
+    device_serialnos: list[str]
+    device_group_id: str | None = None
     cron_expression: str
     enabled: bool
     created_at: str
     updated_at: str
     last_run_time: str | None
     last_run_success: bool | None
+    last_run_status: str | None = None
+    last_run_success_count: int | None = None
+    last_run_total_count: int | None = None
     last_run_message: str | None
     next_run_time: str | None = None
 
@@ -874,6 +920,105 @@ class EnableDisableResponse(BaseModel):
     enabled: bool
 
 
+# Device Group Models
+
+
+class DeviceGroupResponse(BaseModel):
+    """设备分组响应."""
+
+    id: str
+    name: str
+    order: int
+    created_at: str
+    updated_at: str
+    is_default: bool = False
+    device_count: int = 0  # 分组内设备数量
+
+
+class DeviceGroupListResponse(BaseModel):
+    """设备分组列表响应."""
+
+    groups: list[DeviceGroupResponse]
+
+
+class DeviceGroupCreateRequest(BaseModel):
+    """创建设备分组请求."""
+
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        """验证 name 非空."""
+        if not v or not v.strip():
+            raise ValueError("name cannot be empty")
+        v = v.strip()
+        if len(v) > 50:
+            raise ValueError("name too long (max 50 characters)")
+        return v
+
+
+class DeviceGroupUpdateRequest(BaseModel):
+    """更新设备分组请求."""
+
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        """验证 name 非空."""
+        if not v or not v.strip():
+            raise ValueError("name cannot be empty")
+        v = v.strip()
+        if len(v) > 50:
+            raise ValueError("name too long (max 50 characters)")
+        return v
+
+
+class DeviceGroupReorderRequest(BaseModel):
+    """调整设备分组顺序请求."""
+
+    group_ids: list[str]
+
+    @field_validator("group_ids")
+    @classmethod
+    def validate_group_ids(cls, v: list[str]) -> list[str]:
+        """验证 group_ids 非空且无重复."""
+        if not v:
+            raise ValueError("group_ids cannot be empty")
+        seen: set[str] = set()
+        result: list[str] = []
+        for gid in v:
+            gid = gid.strip()
+            if gid in seen:
+                raise ValueError(f"duplicate group_id: {gid}")
+            seen.add(gid)
+            result.append(gid)
+        return result
+
+
+class DeviceGroupAssignRequest(BaseModel):
+    """分配设备到分组请求."""
+
+    group_id: str
+
+    @field_validator("group_id")
+    @classmethod
+    def validate_group_id(cls, v: str) -> str:
+        """验证 group_id 非空."""
+        if not v or not v.strip():
+            raise ValueError("group_id cannot be empty")
+        return v.strip()
+
+
+class DeviceGroupOperationResponse(BaseModel):
+    """设备分组操作响应."""
+
+    success: bool
+    message: str
+    error: str | None = None
+
+
 # Device Name Models
 
 

AutoGLM_GUI/static/assets/{about-BwLRPh96.js → about-DVviVdH2.js}

@@ -1 +1 @@
-import{j as o}from"./index-CH4jPveL.js";function t(){return o.jsx("div",{className:"p-2",children:o.jsx("h3",{children:"About"})})}export{t as component};
+import{j as o}from"./index-DUNWZsFq.js";function t(){return o.jsx("div",{className:"p-2",children:o.jsx("h3",{children:"About"})})}export{t as component};

AutoGLM_GUI/static/assets/{alert-dialog-BvDNaR9v.js → alert-dialog-IHmO2JCQ.js}

@@ -1 +1 @@
-import{o as u,r as o,j as a,b as r,B as d}from"./index-CH4jPveL.js";import{P as g,c as x,b as f,d as m}from"./popover-BnpBfSOh.js";import{D as p,d as h,e as w,f as j,g as D}from"./dialog-IM0Ds7Lf.js";const N=[["path",{d:"M20 6 9 17l-5-5",key:"1gmf2c"}]],b=u("check",N),c=o.createContext(void 0),P=({value:t="",onValueChange:e,children:s})=>{const[n,l]=o.useState(!1);return a.jsx(c.Provider,{value:{value:t,onValueChange:e||(()=>{}),open:n,setOpen:l},children:a.jsx(g,{open:n,onOpenChange:l,children:s})})},C=o.forwardRef(({className:t,children:e,...s},n)=>{if(!o.useContext(c))throw new Error("SelectTrigger must be used within Select");return a.jsx(x,{asChild:!0,children:a.jsxs("button",{ref:n,className:r("flex h-10 w-full items-center justify-between rounded-md border border-slate-200 bg-white px-3 py-2 text-sm ring-offset-white placeholder:text-slate-500 focus:outline-none focus:ring-2 focus:ring-slate-950 focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 dark:border-slate-800 dark:bg-slate-950 dark:ring-offset-slate-950 dark:placeholder:text-slate-400 dark:focus:ring-slate-300",t),...s,children:[e,a.jsx(f,{className:"h-4 w-4 opacity-50"})]})})});C.displayName="SelectTrigger";const V=({placeholder:t})=>{const e=o.useContext(c);if(!e)throw new Error("SelectValue must be used within Select");return a.jsx("span",{className:e.value?"":"text-slate-500",children:e.value||t})},I=({children:t,className:e})=>a.jsx(m,{className:r("w-[var(--radix-popover-trigger-width)] p-1",e),children:t}),O=({value:t,children:e,disabled:s,className:n})=>{const l=o.useContext(c);if(!l)throw new Error("SelectItem must be used within Select");const i=l.value===t;return a.jsxs("div",{role:"option","aria-selected":i,className:r("relative flex w-full cursor-pointer select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none hover:bg-slate-100 focus:bg-slate-100 dark:hover:bg-slate-800 dark:focus:bg-slate-800",s&&"pointer-events-none opacity-50",n),onClick:()=>{s||(l.onValueChange(t),l.setOpen(!1))},children:[a.jsx("span",{className:"absolute left-2 flex h-3.5 w-3.5 items-center justify-center",children:i&&a.jsx(b,{className:"h-4 w-4"})}),e]})},B=({open:t,onOpenChange:e,children:s})=>a.jsx(p,{open:t,onOpenChange:e,children:s}),v=o.forwardRef(({className:t,...e},s)=>a.jsx(h,{ref:s,className:r("sm:max-w-[425px]",t),...e}));v.displayName="AlertDialogContent";const F=({className:t,...e})=>a.jsx(w,{className:r(t),...e}),H=({className:t,...e})=>a.jsx(D,{className:r(t),...e}),A=o.forwardRef(({className:t,...e},s)=>a.jsx(j,{ref:s,className:r(t),...e}));A.displayName="AlertDialogTitle";const S=o.forwardRef(({className:t,...e},s)=>a.jsx("p",{ref:s,className:r("text-sm text-slate-500 dark:text-slate-400",t),...e}));S.displayName="AlertDialogDescription";const y=o.forwardRef(({className:t,...e},s)=>a.jsx(d,{ref:s,className:r(t),...e}));y.displayName="AlertDialogAction";const k=o.forwardRef(({className:t,...e},s)=>a.jsx(d,{ref:s,variant:"outline",className:r(t),...e}));k.displayName="AlertDialogCancel";export{B as A,P as S,C as a,V as b,I as c,O as d,v as e,F as f,A as g,S as h,H as i,k as j,y as k};
+import{b as u,r as o,j as a,e as r,B as d}from"./index-DUNWZsFq.js";import{P as g,c as x,b as f,d as m}from"./popover-DitUZhUk.js";import{D as p,d as h,e as w,f as j,g as D}from"./dialog-DOpd71Lu.js";const N=[["path",{d:"M20 6 9 17l-5-5",key:"1gmf2c"}]],b=u("check",N),c=o.createContext(void 0),P=({value:t="",onValueChange:e,children:s})=>{const[n,l]=o.useState(!1);return a.jsx(c.Provider,{value:{value:t,onValueChange:e||(()=>{}),open:n,setOpen:l},children:a.jsx(g,{open:n,onOpenChange:l,children:s})})},C=o.forwardRef(({className:t,children:e,...s},n)=>{if(!o.useContext(c))throw new Error("SelectTrigger must be used within Select");return a.jsx(x,{asChild:!0,children:a.jsxs("button",{ref:n,className:r("flex h-10 w-full items-center justify-between rounded-md border border-slate-200 bg-white px-3 py-2 text-sm ring-offset-white placeholder:text-slate-500 focus:outline-none focus:ring-2 focus:ring-slate-950 focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 dark:border-slate-800 dark:bg-slate-950 dark:ring-offset-slate-950 dark:placeholder:text-slate-400 dark:focus:ring-slate-300",t),...s,children:[e,a.jsx(f,{className:"h-4 w-4 opacity-50"})]})})});C.displayName="SelectTrigger";const V=({placeholder:t})=>{const e=o.useContext(c);if(!e)throw new Error("SelectValue must be used within Select");return a.jsx("span",{className:e.value?"":"text-slate-500",children:e.value||t})},I=({children:t,className:e})=>a.jsx(m,{className:r("w-[var(--radix-popover-trigger-width)] p-1",e),children:t}),O=({value:t,children:e,disabled:s,className:n})=>{const l=o.useContext(c);if(!l)throw new Error("SelectItem must be used within Select");const i=l.value===t;return a.jsxs("div",{role:"option","aria-selected":i,className:r("relative flex w-full cursor-pointer select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none hover:bg-slate-100 focus:bg-slate-100 dark:hover:bg-slate-800 dark:focus:bg-slate-800",s&&"pointer-events-none opacity-50",n),onClick:()=>{s||(l.onValueChange(t),l.setOpen(!1))},children:[a.jsx("span",{className:"absolute left-2 flex h-3.5 w-3.5 items-center justify-center",children:i&&a.jsx(b,{className:"h-4 w-4"})}),e]})},B=({open:t,onOpenChange:e,children:s})=>a.jsx(p,{open:t,onOpenChange:e,children:s}),v=o.forwardRef(({className:t,...e},s)=>a.jsx(h,{ref:s,className:r("sm:max-w-[425px]",t),...e}));v.displayName="AlertDialogContent";const F=({className:t,...e})=>a.jsx(w,{className:r(t),...e}),H=({className:t,...e})=>a.jsx(D,{className:r(t),...e}),A=o.forwardRef(({className:t,...e},s)=>a.jsx(j,{ref:s,className:r(t),...e}));A.displayName="AlertDialogTitle";const S=o.forwardRef(({className:t,...e},s)=>a.jsx("p",{ref:s,className:r("text-sm text-slate-500 dark:text-slate-400",t),...e}));S.displayName="AlertDialogDescription";const y=o.forwardRef(({className:t,...e},s)=>a.jsx(d,{ref:s,className:r(t),...e}));y.displayName="AlertDialogAction";const k=o.forwardRef(({className:t,...e},s)=>a.jsx(d,{ref:s,variant:"outline",className:r(t),...e}));k.displayName="AlertDialogCancel";export{B as A,P as S,C as a,V as b,I as c,O as d,v as e,F as f,A as g,S as h,H as i,k as j,y as k};