feat: local engine management

core/src/browser/extension.ts

@@ -11,6 +11,7 @@
   Model = 'model',
   SystemMonitoring = 'systemMonitoring',
   HuggingFace = 'huggingFace',
+  Engine = 'engine',
 }
 
 export interface ExtensionType {
@@ -102,7 +103,7 @@
    * @property {Array} platform
    */
   compatibility(): Compatibility | undefined {
     return undefined
   }
 
   /**
@@ -110,8 +111,8 @@
    * @param models
    */
   async registerModels(models: Model[]): Promise<void> {
     for (const model of models) {
       ModelManager.instance().register(model)
     }
   }
 
@@ -122,8 +123,8 @@
    */
   async registerSettings(settings: SettingComponentProps[]): Promise<void> {
     if (!this.name) {
       console.error('Extension name is not defined')
       return
     }
 
     const extensionSettingFolderPath = await joinPath([
@@ -141,18 +142,18 @@
 
       // Persists new settings
       if (await fs.existsSync(settingFilePath)) {
         const oldSettings = JSON.parse(await fs.readFileSync(settingFilePath, 'utf-8'))
         settings.forEach((setting) => {
           // Keep setting value
           if (setting.controllerProps && Array.isArray(oldSettings))
             setting.controllerProps.value = oldSettings.find(
               (e: any) => e.key === setting.key
             )?.controllerProps?.value
         })
       }
       await fs.writeFileSync(settingFilePath, JSON.stringify(settings, null, 2))
     } catch (err) {
       console.error(err)
     }
   }
 
@@ -196,23 +197,23 @@
    * @returns
    */
   async getSettings(): Promise<SettingComponentProps[]> {
     if (!this.name) return []
 
     const settingPath = await joinPath([
       await getJanDataFolderPath(),
       this.settingFolderName,
       this.name,
       this.settingFileName,
     ])
 
     try {
       if (!(await fs.existsSync(settingPath))) return []
       const content = await fs.readFileSync(settingPath, 'utf-8')
       const settings: SettingComponentProps[] = JSON.parse(content)
       return settings
     } catch (err) {
       console.warn(err)
       return []
     }
   }
 

core/src/browser/extensions/enginesManagement.ts

@@ -0,0 +1,91 @@
+import {
+  InferenceEngine,
+  Engines,
+  EngineVariant,
+  EngineReleased,
+  DefaultEngineVariant,
+} from '../../types'
+import { BaseExtension, ExtensionTypeEnum } from '../extension'
+
+/**
+ * Engine management extension. Persists and retrieves engine management.
+ * @abstract
+ * @extends BaseExtension
+ */
+export abstract class EngineManagementExtension extends BaseExtension {
+  type(): ExtensionTypeEnum | undefined {
+    return ExtensionTypeEnum.Engine
+  }
+
+  /**
+   * @returns A Promise that resolves to an object of list engines.
+   */
+  abstract getEngines(): Promise<Engines>
+
+  /**
+   * @param name - Inference engine name.
+   * @returns A Promise that resolves to an array of installed engine.
+   */
+  abstract getInstalledEngines(name: InferenceEngine): Promise<EngineVariant[]>
+
+  /**
+   * @param name - Inference engine name.
+   * @param version - Version of the engine.
+   * @param platform - Optional to sort by operating system. macOS, linux, windows.
+   * @returns A Promise that resolves to an array of latest released engine by version.
+   */
+  abstract getReleasedEnginesByVersion(
+    name: InferenceEngine,
+    version: string,
+    platform?: string
+  ): Promise<EngineReleased[]>
+
+  /**
+   * @param name - Inference engine name.
+   * @param platform - Optional to sort by operating system. macOS, linux, windows.
+   * @returns A Promise that resolves to an array of latest released engine.
+   */
+  abstract getLatestReleasedEngine(
+    name: InferenceEngine,
+    platform?: string
+  ): Promise<EngineReleased[]>
+
+  /**
+   * @param name - Inference engine name.
+   * @returns A Promise that resolves to intall of engine.
+   */
+  abstract installEngine(
+    name: InferenceEngine,
+    engineConfig: { variant: string; version?: string }
+  ): Promise<{ messages: string }>
+
+  /**
+   * @param name - Inference engine name.
+   * @returns A Promise that resolves to unintall of engine.
+   */
+  abstract uninstallEngine(
+    name: InferenceEngine,
+    engineConfig: { variant: string; version: string }
+  ): Promise<{ messages: string }>
+
+  /**
+   * @param name - Inference engine name.
+   * @returns A Promise that resolves to an object of default engine.
+   */
+  abstract getDefaultEngineVariant(name: InferenceEngine): Promise<DefaultEngineVariant>
+
+  /**
+   * @body variant - string
+   * @body version - string
+   * @returns A Promise that resolves to set default engine.
+   */
+  abstract setDefaultEngineVariant(
+    name: InferenceEngine,
+    engineConfig: { variant: string; version: string }
+  ): Promise<{ messages: string }>
+
+  /**
+   * @returns A Promise that resolves to update engine.
+   */
+  abstract updateEngine(name: InferenceEngine): Promise<{ messages: string }>
+}

core/src/browser/extensions/index.ts

@@ -28,3 +28,8 @@ export { ModelExtension } from './model'
  * Base AI Engines.
  */
 export * from './engines'
+
+/**
+ *  Engines Management
+ */
+export * from './enginesManagement'

core/src/types/engine/index.ts

@@ -0,0 +1,28 @@
+import { InferenceEngine } from '../../types'
+
+export type Engines = {
+  [key in InferenceEngine]: EngineVariant[]
+}
+
+export type EngineVariant = {
+  engine: InferenceEngine
+  name: string
+  version: string
+}
+
+export type DefaultEngineVariant = {
+  engine: InferenceEngine
+  variant: string
+  version: string
+}
+
+export type EngineReleased = {
+  created_at: string
+  download_count: number
+  name: string
+  size: number
+}
+
+export enum EngineEvent {
+  OnEngineUpdate = 'OnEngineUpdate',
+}

core/src/types/index.ts

@@ -10,3 +10,4 @@ export * from './huggingface'
 export * from './miscellaneous'
 export * from './api'
 export * from './setting'
+export * from './engine'

extensions/engine-management-extension/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+}

extensions/engine-management-extension/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@janhq/engine-management-extension",
+  "productName": "Engine Management",
+  "version": "1.0.0",
+  "description": "This extension enables manage engines",
+  "main": "dist/index.js",
+  "author": "Jan <[email protected]>",
+  "license": "MIT",
+  "scripts": {
+    "test": "jest",
+    "build": "tsc -b . && webpack --config webpack.config.js",
+    "build:publish": "rimraf *.tgz --glob && yarn build && npm pack && cpx *.tgz ../../pre-install"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./main": "./dist/module.js"
+  },
+  "devDependencies": {
+    "cpx": "^1.5.0",
+    "rimraf": "^3.0.2",
+    "ts-loader": "^9.5.0",
+    "webpack": "^5.88.2",
+    "webpack-cli": "^5.1.4"
+  },
+  "dependencies": {
+    "@janhq/core": "file:../../core",
+    "ky": "^1.7.2",
+    "p-queue": "^8.0.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist/*",
+    "package.json",
+    "README.md"
+  ],
+  "bundleDependencies": []
+}

extensions/engine-management-extension/src/@types/global.d.ts

@@ -0,0 +1,15 @@
+export {}
+declare global {
+  declare const API_URL: string
+  declare const CORTEX_ENGINE_VERSION: string
+  declare const SOCKET_URL: string
+
+  interface Core {
+    api: APIFunctions
+    events: EventEmitter
+  }
+  interface Window {
+    core?: Core | undefined
+    electronAPI?: any | undefined
+  }
+}

extensions/engine-management-extension/src/index.ts

@@ -0,0 +1,184 @@
+import {
+  EngineManagementExtension,
+  InferenceEngine,
+  DefaultEngineVariant,
+  Engines,
+  EngineVariant,
+  EngineReleased,
+} from '@janhq/core'
+import ky, { HTTPError } from 'ky'
+import PQueue from 'p-queue'
+
+/**
+ * JSONEngineManagementExtension is a EngineManagementExtension implementation that provides
+ * functionality for managing engines.
+ */
+export default class JSONEngineManagementExtension extends EngineManagementExtension {
+  queue = new PQueue({ concurrency: 1 })
+
+  /**
+   * Called when the extension is loaded.
+   */
+  async onLoad() {
+    this.queue.add(() => this.healthz())
+    try {
+      await this.getDefaultEngineVariant(InferenceEngine.cortex_llamacpp)
+    } catch (error) {
+      if (error instanceof HTTPError && error.response.status === 400) {
+        await this.setDefaultEngineVariant(InferenceEngine.cortex_llamacpp, {
+          variant: 'mac-arm64',
+          version: `${CORTEX_ENGINE_VERSION}`,
+        })
+      } else {
+        console.error('An unexpected error occurred:', error)
+      }
+    }
+  }
+
+  /**
+   * Called when the extension is unloaded.
+   */
+  onUnload() {}
+
+  /**
+   * @returns A Promise that resolves to an object of list engines.
+   */
+  async getEngines(): Promise<Engines> {
+    return this.queue.add(() =>
+      ky
+        .get(`${API_URL}/v1/engines`)
+        .json<Engines>()
+        .then((e) => e)
+    ) as Promise<Engines>
+  }
+
+  /**
+   * @param name - Inference engine name.
+   * @returns A Promise that resolves to an array of installed engine.
+   */
+  async getInstalledEngines(name: InferenceEngine): Promise<EngineVariant[]> {
+    return this.queue.add(() =>
+      ky
+        .get(`${API_URL}/v1/engines/${name}`)
+        .json<EngineVariant[]>()
+        .then((e) => e)
+    ) as Promise<EngineVariant[]>
+  }
+
+  /**
+   * @param name - Inference engine name.
+   * @param version - Version of the engine.
+   * @param platform - Optional to sort by operating system. macOS, linux, windows.
+   * @returns A Promise that resolves to an array of latest released engine by version.
+   */
+  async getReleasedEnginesByVersion(
+    name: InferenceEngine,
+    version: string,
+    platform?: string
+  ) {
+    return this.queue.add(() =>
+      ky
+        .get(`${API_URL}/v1/engines/${name}/releases/${version}`)
+        .json<EngineReleased[]>()
+        .then((e) =>
+          platform ? e.filter((r) => r.name.includes(platform)) : e
+        )
+    ) as Promise<EngineReleased[]>
+  }
+
+  /**
+   * @param name - Inference engine name.
+   * @param platform - Optional to sort by operating system. macOS, linux, windows.
+   * @returns A Promise that resolves to an array of latest released engine by version.
+   */
+  async getLatestReleasedEngine(name: InferenceEngine, platform?: string) {
+    return this.queue.add(() =>
+      ky
+        .get(`${API_URL}/v1/engines/${name}/releases/latest`)
+        .json<EngineReleased[]>()
+        .then((e) =>
+          platform ? e.filter((r) => r.name.includes(platform)) : e
+        )
+    ) as Promise<EngineReleased[]>
+  }
+
+  /**
+   * @param name - Inference engine name.
+   * @returns A Promise that resolves to intall of engine.
+   */
+  async installEngine(
+    name: InferenceEngine,
+    engineConfig: { variant: string; version?: string }
+  ) {
+    return this.queue.add(() =>
+      ky
+        .post(`${API_URL}/v1/engines/${name}/install`, { json: engineConfig })
+        .then((e) => e)
+    ) as Promise<{ messages: string }>
+  }
+
+  /**
+   * @param name - Inference engine name.
+   * @returns A Promise that resolves to unintall of engine.
+   */
+  async uninstallEngine(
+    name: InferenceEngine,
+    engineConfig: { variant: string; version: string }
+  ) {
+    return this.queue.add(() =>
+      ky
+        .delete(`${API_URL}/v1/engines/${name}/install`, { json: engineConfig })
+        .then((e) => e)
+    ) as Promise<{ messages: string }>
+  }
+
+  /**
+   * @param name - Inference engine name.
+   * @returns A Promise that resolves to an object of default engine.
+   */
+  async getDefaultEngineVariant(name: InferenceEngine) {
+    return this.queue.add(() =>
+      ky
+        .get(`${API_URL}/v1/engines/${name}/default`)
+        .json<{ messages: string }>()
+        .then((e) => e)
+    ) as Promise<DefaultEngineVariant>
+  }
+
+  /**
+   * @body variant - string
+   * @body version - string
+   * @returns A Promise that resolves to set default engine.
+   */
+  async setDefaultEngineVariant(
+    name: InferenceEngine,
+    engineConfig: { variant: string; version: string }
+  ) {
+    return this.queue.add(() =>
+      ky
+        .post(`${API_URL}/v1/engines/${name}/default`, { json: engineConfig })
+        .then((e) => e)
+    ) as Promise<{ messages: string }>
+  }
+
+  /**
+   * @returns A Promise that resolves to update engine.
+   */
+  async updateEngine(name: InferenceEngine) {
+    return this.queue.add(() =>
+      ky.post(`${API_URL}/v1/engines/${name}/update`).then((e) => e)
+    ) as Promise<{ messages: string }>
+  }
+
+  /**
+   * Do health check on cortex.cpp
+   * @returns
+   */
+  healthz(): Promise<void> {
+    return ky
+      .get(`${API_URL}/healthz`, {
+        retry: { limit: 20, delay: () => 500, methods: ['get'] },
+      })
+      .then(() => {})
+  }
+}