Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
fix(credentials): OAuth panel input + Telegram auth consolidation
trohitg7deb362ae267
diff --git a/client/src/components/credentials/panels/OAuthPanel.tsx b/client/src/components/credentials/panels/OAuthPanel.tsxindex 285f6e0d..dfba9297 100644--- a/client/src/components/credentials/panels/OAuthPanel.tsx+++ b/client/src/components/credentials/panels/OAuthPanel.tsx@@ -26,8 +26,17 @@ const OAuthPanel: React.FC<{ config: ProviderConfig; visible: boolean }> = ({ coonSaveCredentials={() => {const missing = config.fields?.find(f => f.required && !panel.form.getFieldValue(f.key)?.trim());if (missing) { panel.setError(`${missing.label} is required`); return; }+ // Snapshot values BEFORE the loop. Each panel.actions.save call+ // invalidates the credentialValues query, which refetches and+ // only reflects fields already stored on the server — reading+ // getFieldValue inside the loop would return undefined for any+ // field we haven't saved yet, silently dropping them.+ const snapshot = panel.form.getFieldsValue();panel.execute('save', async () => {- for (const f of config.fields!) { const v = panel.form.getFieldValue(f.key)?.trim(); if (v) await panel.actions.save(f.key, v); }+ for (const f of config.fields!) {+ const v = snapshot[f.key]?.trim();+ if (v) await panel.actions.save(f.key, v);+ }panel.setStored(true);return { success: true };});diff --git a/client/src/components/credentials/primitives/FieldRenderer.tsx b/client/src/components/credentials/primitives/FieldRenderer.tsxindex 0385c86f..93581298 100644--- a/client/src/components/credentials/primitives/FieldRenderer.tsx+++ b/client/src/components/credentials/primitives/FieldRenderer.tsx@@ -3,7 +3,7 @@* Takes a FieldDef[] array + the form shim from useCredentialPanel.*/-import React, { useState } from 'react';+import React, { useEffect, useState } from 'react';import { Eye, EyeOff } from 'lucide-react';import { Input } from '@/components/ui/input';@@ -37,9 +37,23 @@ interface FieldRowProps {const FieldRow: React.FC<FieldRowProps> = ({ field, form }) => {const [revealed, setRevealed] = useState(false);- const value = form.getFieldValue(field.key) ?? '';+ // Local state for the controlled input — same pattern ApiKeyPanel+ // uses. Reading the value directly from form.getFieldValue (backed by+ // a TanStack Query cache) introduces a render-timing gap in the+ // controlled-input loop that drops keystrokes. Local state avoids it;+ // we mirror to the form on every change so panel-level getFieldValue+ // still works for Save Credentials.+ const initial = form.getFieldValue(field.key) ?? '';+ const [value, setValue] = useState(initial);const isSecret = !!field.secret;+ // When the stored value arrives (query resolves), seed the local+ // state. After that, user input is authoritative.+ useEffect(() => {+ if (!value && initial) setValue(initial);+ // eslint-disable-next-line react-hooks/exhaustive-deps+ }, [initial]);+return (<div className="grid gap-1.5"><Label htmlFor={`field-${field.key}`} className="text-xs">@@ -51,7 +65,11 @@ const FieldRow: React.FC<FieldRowProps> = ({ field, form }) => {id={`field-${field.key}`}type={isSecret && !revealed ? 'password' : 'text'}value={value}- onChange={(e) => form.setFieldValue(field.key, e.target.value)}+ onChange={(e) => {+ const v = e.target.value;+ setValue(v);+ form.setFieldValue(field.key, v);+ }}placeholder={field.placeholder}className={isSecret ? 'font-mono pr-9' : 'font-mono'}/>diff --git a/client/src/components/credentials/useCredentialPanel.ts b/client/src/components/credentials/useCredentialPanel.tsindex ba0a2434..df24dfee 100644--- a/client/src/components/credentials/useCredentialPanel.ts+++ b/client/src/components/credentials/useCredentialPanel.ts@@ -17,7 +17,7 @@* panel action has the same ergonomics.*/-import { useCallback, useRef, useState } from 'react';+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';import { useQuery, useQueryClient } from '@tanstack/react-query';import { useApiKeys } from '../../hooks/useApiKeys';import { useWebSocket } from '../../contexts/WebSocketContext';@@ -34,6 +34,16 @@ export function useCredentialPanel(config: ProviderConfig, visible: boolean) {const [error, setError] = useState<string | null>(null);const [stored, setStored] = useState(false);+ // Reset transient UI state when the user switches providers so a+ // "Bot Token required" error from Telegram doesn't bleed into the+ // Google Workspace panel, etc. `stored` is re-seeded from the+ // credentialValuesQuery below.+ useEffect(() => {+ setError(null);+ setLoading(null);+ setStored(false);+ }, [config.id]);+const {validateApiKey, saveApiKey, getStoredApiKey, hasStoredKey, removeApiKey,getProviderDefaults, saveProviderDefaults,@@ -87,17 +97,25 @@ export function useCredentialPanel(config: ProviderConfig, visible: boolean) {[qc, providerKey],);- const form = useRef({- getFieldValue: (key: string): string | undefined => valuesRef.current[key],- getFieldsValue: (): CredentialFormValues => ({ ...valuesRef.current }),- setFieldValue: (key: string, value: string) => {- writeValues((prev) => ({ ...prev, [key]: value }));- },- setFieldsValue: (next: CredentialFormValues) => {- writeValues((prev) => ({ ...prev, ...next }));- },- resetFields: () => writeValues(() => EMPTY_VALUES),- }).current;+ // useMemo keyed on writeValues so form.setFieldValue always targets the+ // current provider's cache. useRef would freeze the closure to the+ // first render's providerKey — breaking every panel opened after the+ // first one (typing would write to the wrong provider, save would read+ // undefined from the right provider).+ const form = useMemo(+ () => ({+ getFieldValue: (key: string): string | undefined => valuesRef.current[key],+ getFieldsValue: (): CredentialFormValues => ({ ...valuesRef.current }),+ setFieldValue: (key: string, value: string) => {+ writeValues((prev) => ({ ...prev, [key]: value }));+ },+ setFieldsValue: (next: CredentialFormValues) => {+ writeValues((prev) => ({ ...prev, ...next }));+ },+ resetFields: () => writeValues(() => EMPTY_VALUES),+ }),+ [writeValues],+ );// Sync stored from query on first load — if the backend already has// a key, mark stored=true so the badge renders without a validate click.diff --git a/server/routers/websocket.py b/server/routers/websocket.pyindex 0dd6292a..370764f5 100644--- a/server/routers/websocket.py+++ b/server/routers/websocket.py@@ -2038,66 +2038,23 @@ from services.telegram_service import get_telegram_serviceasync def handle_telegram_connect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Connect to Telegram with bot token. Stores token in encrypted credentials."""- token = data.get("token")- if not token:- return {"success": False, "error": "Bot token required"}-- service = get_telegram_service()- result = await service.connect(token)-- # Store token in encrypted credentials on success- if result.get("success"):- try:- auth_service = get_auth_service()- await auth_service.store_api_key(- provider="telegram_bot_token",- api_key=token,- models=[],- session_id="default",- )- # Restore owner_chat_id from credentials if previously captured- saved_owner = await auth_service.get_api_key("telegram_owner_chat_id")- if saved_owner:- await service.set_owner(int(saved_owner))- except Exception as e:- logger.warning(f"[Telegram] Failed to store token in credentials: {e}")-- return result+ """Connect to Telegram. Service reads stored token from DB when the+ payload omits it — DB is the source of truth, the frontend saves the+ token via save_api_key before calling this handler."""+ return await get_telegram_service().connect(data.get("token"))async def handle_telegram_disconnect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Disconnect Telegram bot and remove stored token and owner chat ID."""- service = get_telegram_service()- result = await service.disconnect()-- # Remove stored token and owner chat ID- try:- auth_service = get_auth_service()- await auth_service.remove_api_key("telegram_bot_token")- await auth_service.remove_api_key("telegram_owner_chat_id")- except Exception as e:- logger.warning(f"[Telegram] Failed to remove stored credentials: {e}")-- result["has_stored_token"] = False- return result+ """Stop the polling session. The stored token stays in DB; explicit+ delete_api_key removes it."""+ return await get_telegram_service().disconnect()async def handle_telegram_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Get Telegram bot connection status. Also checks for stored token."""+ """Get Telegram bot connection status."""service = get_telegram_service()status = service.get_status()-- # Check if token is stored (for reconnect UI)- has_stored_token = False- try:- auth_service = get_auth_service()- stored = await auth_service.get_api_key("telegram_bot_token")- has_stored_token = stored is not None- except Exception:- pass-- status["has_stored_token"] = has_stored_token+ status["has_stored_token"] = await service.has_stored_token()return {"success": True, "status": status}diff --git a/server/services/status_broadcaster.py b/server/services/status_broadcaster.pyindex 9bb80983..a5109252 100644--- a/server/services/status_broadcaster.py+++ b/server/services/status_broadcaster.py@@ -337,75 +337,42 @@ class StatusBroadcaster:async def _refresh_telegram_status(self):"""Refresh Telegram status from stored credentials and auto-reconnect.- Called on client connect. If bot has a stored token and isn't connected,- attempts auto-reconnect (mirrors the Android relay reconnect pattern).+ Called on client connect. Auth reads + owner restore are handled+ inside TelegramService; this function just decides whether to+ attempt an auto-reconnect and mirrors the resulting status into+ the broadcaster cache."""try:from services.telegram_service import get_telegram_serviceservice = get_telegram_service()- # If already connected, just sync status cache- if service.connected:- status = service.get_status()- self._status["telegram"] = {- "connected": True,- "bot_id": status.get("bot_id"),- "bot_username": status.get("bot_username"),- "bot_name": status.get("bot_name"),- "owner_chat_id": status.get("owner_chat_id"),- "has_stored_token": True,+ def _snapshot(connected: bool, has_token: bool) -> Dict[str, Any]:+ s = service.get_status()+ return {+ "connected": connected,+ "bot_id": s.get("bot_id") if connected else None,+ "bot_username": s.get("bot_username") if connected else None,+ "bot_name": s.get("bot_name") if connected else None,+ "owner_chat_id": s.get("owner_chat_id") if connected else None,+ "has_stored_token": has_token,}- logger.debug(f"[StatusBroadcaster] Telegram already connected: @{status.get('bot_username')}")- return- # Not connected - check for stored token- from core.container import container- auth_service = container.auth_service()- stored_token = await auth_service.get_api_key("telegram_bot_token")+ if service.connected:+ self._status["telegram"] = _snapshot(True, True)+ return- if not stored_token:- self._status["telegram"] = {- "connected": False,- "bot_id": None,- "bot_username": None,- "bot_name": None,- "owner_chat_id": None,- "has_stored_token": False,- }+ if not await service.has_stored_token():+ self._status["telegram"] = _snapshot(False, False)return- # Has stored token but not connected - auto-reconnectlogger.info("[StatusBroadcaster] Auto-reconnecting Telegram bot...")- result = await service.connect(stored_token)-- if result.get("success"):- # Restore owner_chat_id from credentials- try:- saved_owner = await auth_service.get_api_key("telegram_owner_chat_id")- if saved_owner:- await service.set_owner(int(saved_owner))- except Exception:- pass-- status = service.get_status()- self._status["telegram"] = {- "connected": True,- "bot_id": status.get("bot_id"),- "bot_username": status.get("bot_username"),- "bot_name": status.get("bot_name"),- "owner_chat_id": status.get("owner_chat_id"),- "has_stored_token": True,- }- logger.info(f"[StatusBroadcaster] Telegram auto-reconnected: @{status.get('bot_username')}")+ result = await service.connect() # service reads token from DB+ ok = bool(result.get("success"))+ self._status["telegram"] = _snapshot(ok, True)+ if ok:+ bot_username = self._status["telegram"].get("bot_username")+ logger.info(f"[StatusBroadcaster] Telegram auto-reconnected: @{bot_username}")else:- self._status["telegram"] = {- "connected": False,- "bot_id": None,- "bot_username": None,- "bot_name": None,- "owner_chat_id": None,- "has_stored_token": True,- }logger.warning(f"[StatusBroadcaster] Telegram auto-reconnect failed: {result.get('error')}")except Exception as e:diff --git a/server/services/telegram_service.py b/server/services/telegram_service.pyindex 85639d1e..89cfdebb 100644--- a/server/services/telegram_service.py+++ b/server/services/telegram_service.py@@ -85,15 +85,35 @@ class TelegramService:"owner_chat_id": self._owner_chat_id,}- async def connect(self, token: str) -> Dict[str, Any]:+ async def has_stored_token(self) -> bool:+ """Whether a ``telegram_bot_token`` is persisted in auth credentials."""+ from core.container import container+ auth = container.auth_service()+ return bool(await auth.get_api_key("telegram_bot_token"))++ async def connect(self, token: Optional[str] = None) -> Dict[str, Any]:"""Connect to Telegram with bot token and start polling.+ When ``token`` is omitted, falls back to the stored+ ``telegram_bot_token`` credential — matches the Twitter/Google+ OAuth pattern where the frontend saves credentials first and then+ calls connect. On success the token is persisted (idempotent) and+ any previously captured owner chat id is restored.+Args:- token: Bot token from @BotFather+ token: Bot token from @BotFather. Optional when a token has+ already been saved via ``auth_service.store_api_key``.Returns:Connection result with bot info"""+ from core.container import container+ auth = container.auth_service()++ if not token:+ token = await auth.get_api_key("telegram_bot_token")+ if not token:+ return {"success": False, "error": "Bot token required"}async with self._lock:if self._connected:await self._disconnect_internal()@@ -148,6 +168,15 @@ class TelegramService:# Broadcast status updateawait self._broadcast_status()+ # Hydrate runtime owner_chat_id from stored credential.+ # The DB is the source of truth; connect only reads.+ saved_owner = await auth.get_api_key("telegram_owner_chat_id")+ if saved_owner:+ try:+ self._owner_chat_id = int(saved_owner)+ except (TypeError, ValueError):+ pass+logger.info(f"[Telegram] Connected and polling started for @{me.username}")return {