Skip to content

Self-improving AI Employees for everyone

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.tsx
index 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 }> = ({ co
onSaveCredentials={() => {
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.tsx
index 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.ts
index 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.py
index 0dd6292a..370764f5 100644
--- a/server/routers/websocket.py
+++ b/server/routers/websocket.py
@@ -2038,66 +2038,23 @@ from services.telegram_service import get_telegram_service
async 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.py
index 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_service
service = 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-reconnect
logger.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.py
index 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 update
await 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 {