feat(chat): make chat general available

package.json

@@ -47,8 +47,7 @@
           "type": "webview",
           "id": "firecoder.chat-gui",
           "name": "",
-          "visibility": "visible",
-          "when": "config.firecoder.experimental.chat || config.firecoder.cloud.use"
+          "visibility": "visible"
         }
       ]
     },

src/common/auth/supabaseClient.ts

@@ -16,7 +16,6 @@ export const getSuppabaseClient = () => {
         autoRefreshToken: true,
         persistSession: true,
         detectSessionInUrl: false,
-        debug: true,
         storage: secretsStorage,
       },
     });

src/common/panel/chat.ts

@@ -5,6 +5,9 @@ import { getNonce } from "../utils/getNonce";
 import { chat } from "../chat";
 import { Chat, ChatMessage } from "../prompt/promptChat";
 import { state } from "../utils/state";
+import { configuration } from "../utils/configuration";
+import { TypeModelsChat, modelsChat, servers } from "../server";
+import { getSuppabaseClient } from "../auth/supabaseClient";
 
 export type MessageType =
   | {
@@ -29,6 +32,12 @@ type MessageToExtention =
       type: "abort-generate";
       id: string;
     }
+  | {
+      type: "get-settings";
+    }
+  | {
+      type: "enable-chat";
+    }
   | {
       type: "get-chat";
       chatId: string;
@@ -173,6 +182,16 @@ export class ChatPanel implements vscode.WebviewViewProvider {
               id: message.id,
             });
             break;
+          case "get-settings":
+            await this.handleGetSettings({
+              id: message.id,
+            });
+            break;
+          case "enable-chat":
+            await this.handleEnableChat({
+              id: message.id,
+            });
+            break;
           default:
             break;
         }
@@ -213,6 +232,40 @@ export class ChatPanel implements vscode.WebviewViewProvider {
     sendResponse("", true);
   }
 
+  private async handleGetSettings({ id }: { id: string }) {
+    const settigns = await this.getSettings();
+
+    await this.postMessage({
+      type: "e2w-response",
+      id: id,
+      data: settigns,
+      done: true,
+    });
+  }
+
+  private async getSettings() {
+    const cloudUsing = configuration.get("cloud.use");
+    const cloudChatUsing = configuration.get("cloud.chat.use");
+    const chatServerIsWorking = Object.keys(modelsChat)
+      .map(
+        (chatModel) => servers[chatModel as TypeModelsChat].status === "started"
+      )
+      .some((serverIsWorking) => serverIsWorking);
+
+    const localChatUsing = configuration.get("experimental.chat");
+    const supabase = getSuppabaseClient();
+    const sesssion = await supabase.auth.getSession();
+    const userLoggined = sesssion.data.session ? true : false;
+
+    const chatEnabled =
+      (localChatUsing && chatServerIsWorking) || (cloudUsing && cloudChatUsing);
+
+    return {
+      chatEnabled: chatEnabled,
+      userLoggined: userLoggined,
+    };
+  }
+
   private async handleGetChat({ chatId, id }: { chatId: string; id: string }) {
     const sendResponse = (messageToResponse: Chat | null, done: boolean) => {
       this.postMessage({
@@ -270,7 +323,17 @@ export class ChatPanel implements vscode.WebviewViewProvider {
     await this.postMessage({
       type: "e2w-response",
       id: id,
-      data: "",
+      data: true,
+      done: true,
+    });
+  }
+
+  private async handleEnableChat({ id }: { id: string }) {
+    await configuration.set("experimental.chat", true);
+    await this.postMessage({
+      type: "e2w-response",
+      id: id,
+      data: true,
       done: true,
     });
   }

src/common/server/index.ts

@@ -17,7 +17,7 @@ const modelsBase = {
 };
 export type TypeModelsBase = keyof typeof modelsBase;
 
-const modelsChat = {
+export const modelsChat = {
   "chat-small": {
     port: 39725,
   },
@@ -197,7 +197,7 @@ class Server {
     });
 
     const isServerStarted = await this.checkServerStatusIntervalWithTimeout(
-      1000000
+      20000
     );
 
     if (!isServerStarted) {
@@ -217,7 +217,7 @@ class Server {
     return true;
   }
 
-  public async stopServer() {
+  public stopServer() {
     if (this.serverProcess) {
       const result = this.serverProcess.kill(9);
       if (result === false) {

src/common/utils/configuration.ts

@@ -87,11 +87,6 @@ interface ConfigurationPropertiesType
 }
 
 class Configuration {
-  // private configuration: vscode.WorkspaceConfiguration;
-  // constructor() {
-  //   this.configuration = vscode.workspace.getConfiguration("firecoder");
-  // }
-
   public get<T extends keyof ConfigurationPropertiesType>(
     property: T
   ): ConfigurationPropertiesType[T]["possibleValues"] {
@@ -100,6 +95,14 @@ class Configuration {
 
     return value ?? ConfigurationProperties[property]["default"];
   }
+
+  public async set<T extends keyof ConfigurationPropertiesType>(
+    property: T,
+    value: ConfigurationPropertiesType[T]["possibleValues"]
+  ) {
+    const configuration = vscode.workspace.getConfiguration("firecoder");
+    await configuration.update(property, value, true);
+  }
 }
 
 export const configuration = new Configuration();

src/extension.ts

@@ -70,18 +70,13 @@ export async function activate(context: vscode.ExtensionContext) {
   vscode.workspace.onDidChangeConfiguration(async (event) => {
     if (event.affectsConfiguration("firecoder.cloud.use")) {
       const cloudUse = configuration.get("cloud.use");
+      const supabase = getSuppabaseClient();
       if (cloudUse === true) {
-        const supabase = getSuppabaseClient();
-
         const data = await supabase.auth.getUser();
         if (data.error) {
           await login();
           return;
         }
-      } else {
-        const supabase = getSuppabaseClient();
-
-        await supabase.auth.signOut();
       }
     }
   });
@@ -94,87 +89,67 @@ export async function activate(context: vscode.ExtensionContext) {
     })
   );
 
-  vscode.workspace.onDidChangeConfiguration(async (event) => {
-    if (
-      event.affectsConfiguration("firecoder.cloud.use") ||
-      event.affectsConfiguration("firecoder.experimental.chat") ||
-      event.affectsConfiguration("firecoder.completion.manuallyMode") ||
-      event.affectsConfiguration("firecoder.completion.autoMode") ||
-      event.affectsConfiguration(
-        "firecoder.experimental.useGpu.linux.nvidia"
-      ) ||
-      event.affectsConfiguration("firecoder.experimental.useGpu.osx.metal") ||
-      event.affectsConfiguration(
-        "firecoder.experimental.useGpu.windows.nvidia"
-      ) ||
-      event.affectsConfiguration("firecoder.server.usePreRelease") ||
-      event.affectsConfiguration("firecoder.cloud.use.chat") ||
-      event.affectsConfiguration("firecoder.cloud.use.autocomplete")
-    ) {
-      Object.values(servers).forEach((server) => server.stopServer());
-
-      const completionServers =
-        configuration.get("cloud.use") &&
-        configuration.get("cloud.autocomplete.use")
-          ? []
-          : new Set([
-              configuration.get("completion.autoMode"),
-              configuration.get("completion.manuallyMode"),
-            ]);
-      const serversToStart = [
-        ...completionServers,
-        ...(configuration.get("experimental.chat") &&
-        configuration.get("cloud.use") &&
-        configuration.get("cloud.chat.use")
-          ? []
-          : ["chat-medium" as const]),
-      ];
-      await Promise.all(
-        serversToStart.map((serverType) => servers[serverType].startServer())
-      );
+  const startChat = async () => {
+    if (configuration.get("cloud.use") && configuration.get("cloud.chat.use")) {
+      Logger.info("Use cloud for chat.", {
+        component: "main",
+        sendTelemetry: true,
+      });
+    } else if (configuration.get("experimental.chat")) {
+      Logger.info("Use local for chat.", {
+        component: "main",
+        sendTelemetry: true,
+      });
+      try {
+        await servers["chat-medium"].startServer();
+      } catch (error) {
+        vscode.window.showErrorMessage((error as Error).message);
+        Logger.error(error, {
+          component: "server",
+          sendTelemetry: true,
+        });
+      }
+      Logger.info("Chat is ready to start.", {
+        component: "main",
+        sendTelemetry: true,
+      });
+    } else {
+      Logger.info("Chat is not enable", {
+        component: "main",
+        sendTelemetry: true,
+      });
     }
-  });
+  };
 
-  (async () => {
-    if (configuration.get("cloud.use")) {
-      Logger.info("Use cloud for chat and completions", {
+  const startCompletion = async (registerCompletionProvider: boolean) => {
+    if (
+      configuration.get("cloud.use") &&
+      configuration.get("cloud.autocomplete.use")
+    ) {
+      Logger.info("Use cloud for auto completions.", {
         component: "main",
         sendTelemetry: true,
       });
-
-      const InlineCompletionProvider = getInlineCompletionProvider(context);
-      vscode.languages.registerInlineCompletionItemProvider(
-        { pattern: "**" },
-        InlineCompletionProvider
-      );
     } else {
+      Logger.info("Use local for auto completions.", {
+        component: "main",
+        sendTelemetry: true,
+      });
       try {
-        const completionServers = configuration.get("cloud.use")
-          ? []
-          : new Set([
-              configuration.get("completion.autoMode"),
-              configuration.get("completion.manuallyMode"),
-            ]);
         const serversStarted = await Promise.all(
           [
-            ...completionServers,
-            ...(configuration.get("experimental.chat") &&
-            !configuration.get("cloud.use")
-              ? ["chat-medium" as const]
-              : []),
+            ...new Set([
+              configuration.get("completion.autoMode"),
+              configuration.get("completion.manuallyMode"),
+            ]),
           ].map((serverType) => servers[serverType].startServer())
         );
 
         if (serversStarted.some((serverStarted) => serverStarted)) {
-          Logger.info("Server inited", {
+          Logger.info("Servers inited", {
             component: "main",
             sendTelemetry: true,
           });
-          const InlineCompletionProvider = getInlineCompletionProvider(context);
-          vscode.languages.registerInlineCompletionItemProvider(
-            { pattern: "**" },
-            InlineCompletionProvider
-          );
         }
       } catch (error) {
         vscode.window.showErrorMessage((error as Error).message);
@@ -184,12 +159,45 @@ export async function activate(context: vscode.ExtensionContext) {
         });
       }
     }
+    if (registerCompletionProvider) {
+      const InlineCompletionProvider = getInlineCompletionProvider(context);
+      vscode.languages.registerInlineCompletionItemProvider(
+        { pattern: "**" },
+        InlineCompletionProvider
+      );
+    }
+  };
+
+  (async () => {
+    await Promise.all([startChat(), startCompletion(true)]);
 
     Logger.info("FireCoder is ready.", {
       component: "main",
       sendTelemetry: true,
     });
   })();
+
+  vscode.workspace.onDidChangeConfiguration(async (event) => {
+    if (
+      event.affectsConfiguration("firecoder.cloud.use") ||
+      event.affectsConfiguration("firecoder.cloud.chat.use") ||
+      event.affectsConfiguration("firecoder.cloud.autocomplete.use") ||
+      event.affectsConfiguration("firecoder.experimental.chat") ||
+      event.affectsConfiguration("firecoder.completion.manuallyMode") ||
+      event.affectsConfiguration("firecoder.completion.autoMode") ||
+      event.affectsConfiguration(
+        "firecoder.experimental.useGpu.linux.nvidia"
+      ) ||
+      event.affectsConfiguration("firecoder.experimental.useGpu.osx.metal") ||
+      event.affectsConfiguration(
+        "firecoder.experimental.useGpu.windows.nvidia"
+      ) ||
+      event.affectsConfiguration("firecoder.server.usePreRelease")
+    ) {
+      Object.values(servers).forEach((server) => server.stopServer());
+      await Promise.all([startChat(), startCompletion(false)]);
+    }
+  });
 }
 
 export function deactivate() {