@lobehub/lobehub 2.0.0-next.311 → 2.0.0-next.313

package/src/server/routers/lambda/user.ts

@@ -16,7 +16,12 @@ import { after } from 'next/server';
 import { v4 as uuidv4 } from 'uuid';
 import { z } from 'zod';
 
-import { getIsInWaitList, getReferralStatus, getSubscriptionPlan } from '@/business/server/user';
+import {
+  getIsInviteCodeRequired,
+  getIsInWaitList,
+  getReferralStatus,
+  getSubscriptionPlan,
+} from '@/business/server/user';
 import { MessageModel } from '@/database/models/message';
 import { SessionModel } from '@/database/models/session';
 import { UserModel, UserNotFoundError } from '@/database/models/user';
@@ -129,15 +134,23 @@ export const userRouter = router({
     };
 
     // Run user state fetch and count queries in parallel
-    const [state, messageCount, hasExtraSession, referralStatus, subscriptionPlan, isInWaitList] =
-      await Promise.all([
-        getOrCreateUserState(),
-        ctx.messageModel.countUpTo(5),
-        ctx.sessionModel.hasMoreThanN(1),
-        getReferralStatus(ctx.userId),
-        getSubscriptionPlan(ctx.userId),
-        getIsInWaitList(ctx.userId),
-      ]);
+    const [
+      state,
+      messageCount,
+      hasExtraSession,
+      referralStatus,
+      subscriptionPlan,
+      isInWaitList,
+      isInviteCodeRequired,
+    ] = await Promise.all([
+      getOrCreateUserState(),
+      ctx.messageModel.countUpTo(5),
+      ctx.sessionModel.hasMoreThanN(1),
+      getReferralStatus(ctx.userId),
+      getSubscriptionPlan(ctx.userId),
+      getIsInWaitList(ctx.userId),
+      getIsInviteCodeRequired(ctx.userId),
+    ]);
 
     const hasMoreThan4Messages = messageCount > 4;
     const hasAnyMessages = messageCount > 0;
@@ -168,6 +181,7 @@ export const userRouter = router({
       referralStatus,
       subscriptionPlan,
       isInWaitList,
+      isInviteCodeRequired,
       isFreePlan: !subscriptionPlan || subscriptionPlan === Plans.Free,
     } satisfies UserInitializationState;
     /* eslint-enable sort-keys-fix/sort-keys-fix */

package/src/server/services/agentRuntime/AgentRuntimeService.test.ts

@@ -40,6 +40,9 @@ vi.mock('@/server/modules/ModelRuntime', () => ({
 
 // Mock search service to avoid server-side env access
 vi.mock('@/server/services/search', () => ({
+  SearchService: vi.fn().mockImplementation(() => ({
+    search: vi.fn(),
+  })),
   searchService: {
     search: vi.fn(),
   },

package/src/server/services/agentRuntime/AgentRuntimeService.ts

@@ -233,6 +233,7 @@ export class AgentRuntimeService {
       toolManifestMap,
       toolSourceMap,
       stepCallbacks,
+      userInterventionConfig,
     } = params;
 
     try {
@@ -261,6 +262,8 @@ export class AgentRuntimeService {
         toolManifestMap,
         toolSourceMap,
         tools,
+        // User intervention config for headless mode in async tasks
+        userInterventionConfig,
       } as Partial<AgentState>;
 
       // Use coordinator to create operation, automatically sends initialization event
@@ -329,10 +332,7 @@ export class AgentRuntimeService {
       });
 
       // Get operation state and metadata
-      const [agentState, operationMetadata] = await Promise.all([
-        this.coordinator.loadAgentState(operationId),
-        this.coordinator.getOperationMetadata(operationId),
-      ]);
+      const agentState = await this.coordinator.loadAgentState(operationId);
 
       if (!agentState) {
         throw new Error(`Agent state not found for operation ${operationId}`);
@@ -353,8 +353,10 @@ export class AgentRuntimeService {
       }
 
       // Create Agent and Runtime instances
+      // Use agentState.metadata which contains the full app context (topicId, agentId, etc.)
+      // operationMetadata only contains basic fields (agentConfig, modelRuntimeConfig, userId)
       const { runtime } = await this.createAgentRuntime({
-        metadata: operationMetadata,
+        metadata: agentState?.metadata,
         operationId,
         stepIndex,
       });
@@ -850,6 +852,7 @@ export class AgentRuntimeService {
       stepIndex,
       streamManager: this.streamManager,
       toolExecutionService: this.toolExecutionService,
+      topicId: metadata?.topicId,
       userId: metadata?.userId,
     };
 

package/src/server/services/agentRuntime/types.ts

@@ -1,5 +1,6 @@
 import { type AgentRuntimeContext, type AgentState } from '@lobechat/agent-runtime';
 import { type LobeToolManifest } from '@lobechat/context-engine';
+import type { UserInterventionConfig } from '@lobechat/types';
 
 // ==================== Step Lifecycle Callbacks ====================
 
@@ -90,6 +91,12 @@ export interface OperationCreationParams {
   toolSourceMap?: Record<string, 'builtin' | 'plugin' | 'mcp' | 'klavis' | 'lobehubSkill'>;
   tools?: any[];
   userId?: string;
+  /**
+   * User intervention configuration
+   * Controls how tools requiring approval are handled
+   * Use { approvalMode: 'headless' } for async tasks that should never wait for human approval
+   */
+  userInterventionConfig?: UserInterventionConfig;
 }
 
 export interface OperationCreationResult {

package/src/server/services/aiAgent/__tests__/execGroupSubAgentTask.test.ts

@@ -185,6 +185,9 @@ describe('AiAgentService.execSubAgentTask', () => {
           onAfterStep: expect.any(Function),
           onComplete: expect.any(Function),
         }),
+        userInterventionConfig: {
+          approvalMode: 'headless',
+        },
       });
     });
 

package/src/server/services/aiAgent/index.ts

@@ -8,6 +8,7 @@ import type {
   ExecGroupAgentResult,
   ExecSubAgentTaskParams,
   ExecSubAgentTaskResult,
+  UserInterventionConfig,
 } from '@lobechat/types';
 import { ThreadStatus, ThreadType } from '@lobechat/types';
 import { nanoid } from '@lobechat/utils';
@@ -66,6 +67,11 @@ interface InternalExecAgentParams extends ExecAgentParams {
   stepCallbacks?: StepLifecycleCallbacks;
   /** Topic creation trigger source ('cron' | 'chat' | 'api') */
   trigger?: string;
+  /**
+   * User intervention configuration
+   * Use { approvalMode: 'headless' } for async tasks that should never wait for human approval
+   */
+  userInterventionConfig?: UserInterventionConfig;
 }
 
 /**
@@ -125,6 +131,7 @@ export class AiAgentService {
       stepCallbacks,
       trigger,
       cronJobId,
+      userInterventionConfig,
     } = params;
 
     // Validate that either agentId or slug is provided
@@ -231,10 +238,6 @@ export class AiAgentService {
 
     const tools = toolsResult.tools;
 
-    // Log detailed tools generation result
-    if (toolsResult.filteredTools && toolsResult.filteredTools.length > 0) {
-      log('execAgent: filtered tools: %O', toolsResult.filteredTools);
-    }
     log('execAgent: enabled tool ids: %O', toolsResult.enabledToolIds);
 
     // Get manifest map and convert from Map to Record
@@ -396,6 +399,7 @@ export class AiAgentService {
         toolSourceMap,
         tools,
         userId: this.userId,
+        userInterventionConfig,
       });
 
       log('execAgent: created operation %s (autoStarted: %s)', operationId, result.autoStarted);
@@ -572,12 +576,14 @@ export class AiAgentService {
 
     // 4. Delegate to execAgent with threadId in appContext and callbacks
     // The instruction will be created as user message in the Thread
+    // Use headless mode to skip human approval in async task execution
     const result = await this.execAgent({
       agentId,
       appContext: { groupId, threadId: thread.id, topicId },
       autoStart: true,
       prompt: instruction,
       stepCallbacks,
+      userInterventionConfig: { approvalMode: 'headless' },
     });
 
     log(

package/src/server/services/market/index.ts

@@ -368,6 +368,13 @@ export class MarketService {
     return this.market.user.getUserInfo(username, options);
   }
 
+  /**
+   * Register user on market and optionally follow another user
+   */
+  async registerUser(params: { followUserId?: string; registerUserId: string }): Promise<void> {
+    await this.market.user.register(params);
+  }
+
   // ============================== Skills Methods ==============================
 
   /**

package/src/server/services/sandbox/index.ts

@@ -0,0 +1,120 @@
+import { type CodeInterpreterToolName } from '@lobehub/market-sdk';
+import {
+  type ISandboxService,
+  type SandboxCallToolResult,
+  type SandboxExportFileResult,
+} from '@lobechat/builtin-tool-cloud-sandbox';
+import debug from 'debug';
+
+import { MarketService } from '@/server/services/market';
+
+const log = debug('lobe-server:sandbox-service');
+
+export interface ServerSandboxServiceOptions {
+  marketService: MarketService;
+  topicId: string;
+  userId: string;
+}
+
+/**
+ * Server-side Sandbox Service
+ *
+ * This service implements ISandboxService for server-side execution.
+ * Context (topicId, userId) is bound at construction time.
+ * It uses MarketService to call sandbox tools.
+ *
+ * Usage:
+ * - Used by BuiltinToolsExecutor when executing CloudSandbox tools on server
+ * - MarketService handles authentication via trustedClientToken
+ */
+export class ServerSandboxService implements ISandboxService {
+  private marketService: MarketService;
+  private topicId: string;
+  private userId: string;
+
+  constructor(options: ServerSandboxServiceOptions) {
+    this.marketService = options.marketService;
+    this.topicId = options.topicId;
+    this.userId = options.userId;
+  }
+
+  /**
+   * Call a sandbox tool via MarketService
+   */
+  async callTool(toolName: string, params: Record<string, any>): Promise<SandboxCallToolResult> {
+    log('Calling sandbox tool: %s with params: %O, topicId: %s', toolName, params, this.topicId);
+
+    try {
+      const response = await this.marketService.getSDK().plugins.runBuildInTool(
+        toolName as CodeInterpreterToolName,
+        params as any,
+        { topicId: this.topicId, userId: this.userId },
+      );
+
+      log('Sandbox tool %s response: %O', toolName, response);
+
+      if (!response.success) {
+        return {
+          error: {
+            message: response.error?.message || 'Unknown error',
+            name: response.error?.code,
+          },
+          result: null,
+          sessionExpiredAndRecreated: false,
+          success: false,
+        };
+      }
+
+      return {
+        result: response.data?.result,
+        sessionExpiredAndRecreated: response.data?.sessionExpiredAndRecreated || false,
+        success: true,
+      };
+    } catch (error) {
+      log('Error calling sandbox tool %s: %O', toolName, error);
+
+      return {
+        error: {
+          message: (error as Error).message,
+          name: (error as Error).name,
+        },
+        result: null,
+        sessionExpiredAndRecreated: false,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Export and upload a file from sandbox
+   *
+   * Note: This is a simplified version for server-side use.
+   * The full implementation with S3 upload is in the tRPC router.
+   */
+  async exportAndUploadFile(path: string, filename: string): Promise<SandboxExportFileResult> {
+    log('Exporting file: %s from path: %s, topicId: %s', filename, path, this.topicId);
+
+    // For server-side, we need to call the exportFile tool
+    // The full S3 upload logic should be handled separately
+    // This is a basic implementation that can be extended
+
+    try {
+      return {
+        error: {
+          message:
+            'Server-side file export not fully implemented. Use tRPC endpoint for file exports.',
+        },
+        filename,
+        success: false,
+      };
+    } catch (error) {
+      log('Error exporting file: %O', error);
+
+      return {
+        error: { message: (error as Error).message },
+        filename,
+        success: false,
+      };
+    }
+  }
+}

package/src/server/services/toolExecution/builtin.ts

@@ -1,28 +1,26 @@
-import { WebBrowsingManifest } from '@lobechat/builtin-tool-web-browsing';
-import { WebBrowsingExecutionRuntime } from '@lobechat/builtin-tool-web-browsing/executionRuntime';
 import { type LobeChatDatabase } from '@lobechat/database';
 import { type ChatToolPayload } from '@lobechat/types';
 import { safeParseJSON } from '@lobechat/utils';
 import debug from 'debug';
 
 import { MarketService } from '@/server/services/market';
-import { SearchService } from '@/server/services/search';
 
-import { type IToolExecutor, type ToolExecutionResult } from './types';
+import { getServerRuntime, hasServerRuntime } from './serverRuntimes';
+import { type IToolExecutor, type ToolExecutionContext, type ToolExecutionResult } from './types';
 
 const log = debug('lobe-server:builtin-tools-executor');
 
-const BuiltinToolServerRuntimes: Record<string, any> = {
-  [WebBrowsingManifest.identifier]: WebBrowsingExecutionRuntime,
-};
-
 export class BuiltinToolsExecutor implements IToolExecutor {
   private marketService: MarketService;
 
   constructor(db: LobeChatDatabase, userId: string) {
     this.marketService = new MarketService({ userInfo: { userId } });
   }
-  async execute(payload: ChatToolPayload): Promise<ToolExecutionResult> {
+
+  async execute(
+    payload: ChatToolPayload,
+    context: ToolExecutionContext,
+  ): Promise<ToolExecutionResult> {
     const { identifier, apiName, arguments: argsStr, source } = payload;
     const args = safeParseJSON(argsStr) || {};
 
@@ -43,19 +41,15 @@ export class BuiltinToolsExecutor implements IToolExecutor {
       });
     }
 
-    // Default: original builtin runtime logic
-    const ServerRuntime = BuiltinToolServerRuntimes[identifier];
-
-    if (!ServerRuntime) {
+    // Use server runtime registry (handles both pre-instantiated and per-request runtimes)
+    if (!hasServerRuntime(identifier)) {
       throw new Error(`Builtin tool "${identifier}" is not implemented`);
     }
 
-    const runtime = new ServerRuntime({
-      searchService: new SearchService(),
-    });
+    const runtime = getServerRuntime(identifier, context);
 
     if (!runtime[apiName]) {
-      throw new Error(`Builtin tool ${identifier} 's ${apiName} is not implemented`);
+      throw new Error(`Builtin tool ${identifier}'s ${apiName} is not implemented`);
     }
 
     try {
@@ -64,7 +58,7 @@ export class BuiltinToolsExecutor implements IToolExecutor {
       const error = e as Error;
       console.error('Error executing builtin tool %s:%s: %O', identifier, apiName, error);
 
-      return { content: error.message, error: error, success: false };
+      return { content: error.message, error, success: false };
     }
   }
 }

package/src/server/services/toolExecution/index.ts

@@ -47,7 +47,7 @@ export class ToolExecutionService {
       let data: ToolExecutionResult;
       switch (typeStr) {
         case 'builtin': {
-          data = await this.builtinToolsExecutor.execute(payload);
+          data = await this.builtinToolsExecutor.execute(payload, context);
           break;
         }
 

package/src/server/services/toolExecution/serverRuntimes/cloudSandbox.ts

@@ -0,0 +1,31 @@
+import {
+  CloudSandboxExecutionRuntime,
+  CloudSandboxIdentifier,
+} from '@lobechat/builtin-tool-cloud-sandbox';
+
+import { MarketService } from '@/server/services/market';
+import { ServerSandboxService } from '@/server/services/sandbox';
+
+import { type ServerRuntimeRegistration } from './types';
+
+/**
+ * CloudSandbox Server Runtime
+ * Per-request runtime (needs topicId, userId)
+ */
+export const cloudSandboxRuntime: ServerRuntimeRegistration = {
+  factory: (context) => {
+    if (!context.userId || !context.topicId) {
+      throw new Error('userId and topicId are required for Cloud Sandbox execution');
+    }
+
+    const marketService = new MarketService({ userInfo: { userId: context.userId } });
+    const sandboxService = new ServerSandboxService({
+      marketService,
+      topicId: context.topicId,
+      userId: context.userId,
+    });
+
+    return new CloudSandboxExecutionRuntime(sandboxService);
+  },
+  identifier: CloudSandboxIdentifier,
+};

package/src/server/services/toolExecution/serverRuntimes/index.ts

@@ -0,0 +1,55 @@
+/**
+ * Server Runtime Registry
+ *
+ * Central registry for all builtin tool server runtimes.
+ * Uses factory functions to support both:
+ * - Pre-instantiated runtimes (e.g., WebBrowsing - no per-request context needed)
+ * - Per-request runtimes (e.g., CloudSandbox - needs topicId, userId)
+ */
+import { type ToolExecutionContext } from '../types';
+import { cloudSandboxRuntime } from './cloudSandbox';
+import { type ServerRuntimeFactory, type ServerRuntimeRegistration } from './types';
+import { webBrowsingRuntime } from './webBrowsing';
+
+/**
+ * Registry of server runtime factories by identifier
+ */
+const serverRuntimeFactories = new Map<string, ServerRuntimeFactory>();
+
+/**
+ * Register server runtimes
+ */
+const registerRuntimes = (runtimes: ServerRuntimeRegistration[]) => {
+  for (const runtime of runtimes) {
+    serverRuntimeFactories.set(runtime.identifier, runtime.factory);
+  }
+};
+
+// Register all server runtimes
+registerRuntimes([webBrowsingRuntime, cloudSandboxRuntime]);
+
+// ==================== Registry API ====================
+
+/**
+ * Get a server runtime by identifier
+ * @param identifier - The tool identifier
+ * @param context - Execution context (required for per-request runtimes)
+ */
+export const getServerRuntime = (identifier: string, context: ToolExecutionContext): any => {
+  const factory = serverRuntimeFactories.get(identifier);
+  return factory?.(context);
+};
+
+/**
+ * Check if a server runtime exists for the given identifier
+ */
+export const hasServerRuntime = (identifier: string): boolean => {
+  return serverRuntimeFactories.has(identifier);
+};
+
+/**
+ * Get all registered server runtime identifiers
+ */
+export const getServerRuntimeIdentifiers = (): string[] => {
+  return Array.from(serverRuntimeFactories.keys());
+};

package/src/server/services/toolExecution/serverRuntimes/types.ts

@@ -0,0 +1,14 @@
+import { type ToolExecutionContext } from '../types';
+
+/**
+ * Factory function type for creating server runtimes
+ */
+export type ServerRuntimeFactory = (context: ToolExecutionContext) => any;
+
+/**
+ * Server runtime registration object
+ */
+export interface ServerRuntimeRegistration {
+  factory: ServerRuntimeFactory;
+  identifier: string;
+}

package/src/server/services/toolExecution/serverRuntimes/webBrowsing.ts

@@ -0,0 +1,20 @@
+import { WebBrowsingManifest } from '@lobechat/builtin-tool-web-browsing';
+import { WebBrowsingExecutionRuntime } from '@lobechat/builtin-tool-web-browsing/executionRuntime';
+
+import { SearchService } from '@/server/services/search';
+
+import { type ServerRuntimeRegistration } from './types';
+
+// Pre-instantiated (no per-request context needed)
+const runtime = new WebBrowsingExecutionRuntime({
+  searchService: new SearchService(),
+});
+
+/**
+ * WebBrowsing Server Runtime
+ * Pre-instantiated runtime (no per-request context needed)
+ */
+export const webBrowsingRuntime: ServerRuntimeRegistration = {
+  factory: () => runtime,
+  identifier: WebBrowsingManifest.identifier,
+};

package/src/server/services/toolExecution/types.ts

@@ -6,6 +6,8 @@ export interface ToolExecutionContext {
   /** Server database for LobeHub Skills execution */
   serverDB?: LobeChatDatabase;
   toolManifestMap: Record<string, LobeToolManifest>;
+  /** Topic ID for sandbox session management */
+  topicId?: string;
   userId?: string;
 }
 

package/src/server/sitemap.test.ts

@@ -59,7 +59,7 @@ describe('Sitemap', () => {
       );
       expect(pageSitemap).toContainEqual(
         expect.objectContaining({
-          url: getCanonicalUrl('/community/assistant'),
+          url: getCanonicalUrl('/community/agent'),
           changeFrequency: 'daily',
           priority: 0.7,
         }),
@@ -85,13 +85,13 @@ describe('Sitemap', () => {
       expect(assistantsSitemap.length).toBe(LOCALE_COUNT);
       expect(assistantsSitemap).toContainEqual(
         expect.objectContaining({
-          url: getCanonicalUrl('/community/assistant/test-assistant'),
+          url: getCanonicalUrl('/community/agent/test-assistant'),
           lastModified: '2023-01-01T00:00:00.000Z',
         }),
       );
       expect(assistantsSitemap).toContainEqual(
         expect.objectContaining({
-          url: getCanonicalUrl('/community/assistant/test-assistant?hl=zh-CN'),
+          url: getCanonicalUrl('/community/agent/test-assistant?hl=zh-CN'),
           lastModified: '2023-01-01T00:00:00.000Z',
         }),
       );
@@ -113,7 +113,7 @@ describe('Sitemap', () => {
       expect(firstPageSitemap.length).toBe(100 * LOCALE_COUNT); // 100 items * LOCALE_COUNT locales
       expect(firstPageSitemap).toContainEqual(
         expect.objectContaining({
-          url: getCanonicalUrl('/community/assistant/test-assistant-0'),
+          url: getCanonicalUrl('/community/agent/test-assistant-0'),
           lastModified: '2023-01-01T00:00:00.000Z',
         }),
       );
@@ -123,7 +123,7 @@ describe('Sitemap', () => {
       expect(secondPageSitemap.length).toBe(50 * LOCALE_COUNT); // 50 items * LOCALE_COUNT locales
       expect(secondPageSitemap).toContainEqual(
         expect.objectContaining({
-          url: getCanonicalUrl('/community/assistant/test-assistant-100'),
+          url: getCanonicalUrl('/community/agent/test-assistant-100'),
           lastModified: '2023-01-01T00:00:00.000Z',
         }),
       );

package/src/server/sitemap.ts

@@ -213,7 +213,7 @@ export class Sitemap {
       const sitmap = pageAssistants
         .filter((item) => item.identifier) // Filter out items with empty identifiers
         .map((item) =>
-          this._genSitemap(urlJoin('/community/assistant', item.identifier), {
+          this._genSitemap(urlJoin('/community/agent', item.identifier), {
             lastModified: item?.lastModified || LAST_MODIFIED,
           }),
         );
@@ -224,7 +224,7 @@ export class Sitemap {
     const sitmap = list
       .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
       .map((item) =>
-        this._genSitemap(urlJoin('/community/assistant', item.identifier), {
+        this._genSitemap(urlJoin('/community/agent', item.identifier), {
           lastModified: item?.lastModified || LAST_MODIFIED,
         }),
       );
@@ -311,7 +311,7 @@ export class Sitemap {
 
       /* ↑ cloud slot ↑ */
       ...this._genSitemap('/community', { changeFrequency: 'daily', priority: 0.7 }),
-      ...this._genSitemap('/community/assistant', { changeFrequency: 'daily', priority: 0.7 }),
+      ...this._genSitemap('/community/agent', { changeFrequency: 'daily', priority: 0.7 }),
       ...this._genSitemap('/community/mcp', { changeFrequency: 'daily', priority: 0.7 }),
       ...this._genSitemap('/community/plugin', { changeFrequency: 'daily', priority: 0.7 }),
       ...this._genSitemap('/community/model', { changeFrequency: 'daily', priority: 0.7 }),

package/src/services/{codeInterpreter.ts → cloudSandbox.ts}

@@ -6,9 +6,9 @@ import type {
   ExportAndUploadFileResult,
 } from '@/server/routers/tools/market';
 
-class CodeInterpreterService {
+class CloudSandboxService {
   /**
-   * Call a cloud code interpreter tool
+   * Call a cloud sandbox tool
    * @param toolName - The name of the tool to call (e.g., 'runCommand', 'writeLocalFile')
    * @param params - The parameters for the tool
    * @param context - Session context containing userId and topicId for isolation
@@ -51,4 +51,4 @@ class CodeInterpreterService {
   }
 }
 
-export const codeInterpreterService = new CodeInterpreterService();
+export const cloudSandboxService = new CloudSandboxService();

package/src/services/electron/remoteServer.ts

@@ -1,4 +1,5 @@
 import { type DataSyncConfig, type MarketAuthorizationParams } from '@lobechat/electron-client-ipc';
+
 import { ensureElectronIpc } from '@/utils/electron/ipc';
 
 class RemoteServerService {
@@ -36,6 +37,13 @@ class RemoteServerService {
   requestMarketAuthorization = async (params: MarketAuthorizationParams) => {
     return ensureElectronIpc().auth.requestMarketAuthorization(params);
   };
+
+  /**
+   * Cancel authorization
+   */
+  cancelAuthorization = async () => {
+    return ensureElectronIpc().auth.cancelAuthorization();
+  };
 }
 
 export const remoteServerService = new RemoteServerService();