Nicholai/jan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: migrate cortex models to llamacpp extension (#5838)

Browse Source 
* feat: migrate cortex models to new llama.cpp extension

* test: add tests

* clean: remove duplicated import
This commit is contained in:
Louis 2025-07-22 23:35:08 +07:00 committed by GitHub
parent 5cbd79b525
commit fe95031c6e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 553 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
extensions/conversational-extension/src/index.ts
View File

@ -6,10 +6,10 @@ import {
} from '@janhq/core'
/**
* JSONConversationalExtension is a ConversationalExtension implementation that provides
* JanConversationalExtension is a ConversationalExtension implementation that provides
* functionality for managing threads.
*/
export default class CortexConversationalExtension extends ConversationalExtension {
export default class JanConversationalExtension extends ConversationalExtension {
/**
* Called when the extension is loaded.
*/

94
extensions/llamacpp-extension/src/index.ts
View File

@ -30,8 +30,8 @@ import {
getBackendExePath,
} from './backend'
import { invoke } from '@tauri-apps/api/core'
import { basename } from '@tauri-apps/api/path'
import { getProxyConfig } from './util'
import { basename } from '@tauri-apps/api/path'
type LlamacppConfig = {
version_backend: string
@ -538,9 +538,11 @@ export default class llamacpp_extension extends AIEngine {
override async list(): Promise<modelInfo[]> {
const modelsDir = await joinPath([await this.getProviderPath(), 'models'])
if (!(await fs.existsSync(modelsDir))) {
return []
await fs.mkdir(modelsDir)
}
await this.migrateLegacyModels()
let modelIds: string[] = []
// DFS
@ -589,6 +591,94 @@ export default class llamacpp_extension extends AIEngine {
return modelInfos
}
private async migrateLegacyModels() {
const janDataFolderPath = await getJanDataFolderPath()
const modelsDir = await joinPath([janDataFolderPath, 'models'])
if (!(await fs.existsSync(modelsDir))) return
// DFS
let stack = [modelsDir]
while (stack.length > 0) {
const currentDir = stack.pop()
const files = await fs.readdirSync(currentDir)
for (const child of files) {
const childPath = await joinPath([currentDir, child])
const stat = await fs.fileStat(childPath)
if (
files.some((e) => e.endsWith('model.yml')) &&
!child.endsWith('model.yml')
)
continue
if (!stat.isDirectory && child.endsWith('.yml')) {
// check if model.yml exists
const modelConfigPath = child
if (await fs.existsSync(modelConfigPath)) {
const legacyModelConfig = await invoke<{
files: string[]
model: string
}>('read_yaml', {
path: modelConfigPath,
})
const legacyModelPath = legacyModelConfig.files?.[0]
if (!legacyModelPath) continue
// +1 to remove the leading slash
// NOTE: this does not handle Windows path \\
let modelId = currentDir.slice(modelsDir.length + 1)
modelId =
modelId !== 'imported'
? modelId
: (await basename(child)).replace('.yml', '')
const modelName = legacyModelConfig.model ?? modelId
const configPath = await joinPath([
await this.getProviderPath(),
'models',
modelId,
'model.yml',
])
if (await fs.existsSync(configPath)) continue // Don't reimport
// this is relative to Jan's data folder
const modelDir = `${this.providerId}/models/${modelId}`
let size_bytes = (
await fs.fileStat(
await joinPath([janDataFolderPath, legacyModelPath])
)
).size
const modelConfig = {
model_path: legacyModelPath,
mmproj_path: undefined, // legacy models do not have mmproj
name: modelName,
size_bytes,
} as ModelConfig
await fs.mkdir(await joinPath([janDataFolderPath, modelDir]))
await invoke<void>('write_yaml', {
data: modelConfig,
savePath: configPath,
})
continue
}
}
}
// otherwise, look into subdirectories
const children = await fs.readdirSync(currentDir)
for (const child of children) {
// skip files
const dirInfo = await fs.fileStat(child)
if (!dirInfo.isDirectory) {
continue
}
stack.push(child)
}
}
}
override async import(modelId: string, opts: ImportOptions): Promise<void> {
const isValidModelId = (id: string) => {
// only allow alphanumeric, underscore, hyphen, and dot characters in modelId

14
extensions/llamacpp-extension/src/test/backend.test.ts
View File

@ -107,16 +107,21 @@ describe('Backend functions', () => {
os_type: 'windows',
})
const { getJanDataFolderPath, joinPath } = await import('@janhq/core')
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath)
.mockResolvedValueOnce(
'/path/to/jan/llamacpp/backends/v1.0.0/win-avx2-x64'
)
.mockResolvedValueOnce(
'/path/to/jan/llamacpp/backends/v1.0.0/win-avx2-x64/build'
)
.mockResolvedValueOnce(
'/path/to/jan/llamacpp/backends/v1.0.0/win-avx2-x64/build/bin/llama-server.exe'
)
vi.mocked(fs.existsSync).mockResolvedValue(true)
const result = await getBackendExePath('win-avx2-x64', 'v1.0.0')
@ -130,16 +135,21 @@ describe('Backend functions', () => {
os_type: 'linux',
})
const { getJanDataFolderPath, joinPath } = await import('@janhq/core')
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath)
.mockResolvedValueOnce(
'/path/to/jan/llamacpp/backends/v1.0.0/linux-avx2-x64'
)
.mockResolvedValueOnce(
'/path/to/jan/llamacpp/backends/v1.0.0/linux-avx2-x64/build'
)
.mockResolvedValueOnce(
'/path/to/jan/llamacpp/backends/v1.0.0/linux-avx2-x64/build/bin/llama-server'
)
vi.mocked(fs.existsSync).mockResolvedValue(true)
const result = await getBackendExePath('linux-avx2-x64', 'v1.0.0')

28
extensions/llamacpp-extension/src/test/index.test.ts
View File

@ -4,6 +4,15 @@ import llamacpp_extension from '../index'
// Mock fetch globally
global.fetch = vi.fn()
// Mock backend functions
vi.mock('../backend', () => ({
isBackendInstalled: vi.fn(),
getBackendExePath: vi.fn(),
downloadBackend: vi.fn(),
listSupportedBackends: vi.fn(),
getBackendDir: vi.fn(),
}))
describe('llamacpp_extension', () => {
let extension: llamacpp_extension
@ -43,7 +52,11 @@ describe('llamacpp_extension', () => {
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath).mockResolvedValue('/path/to/jan/llamacpp/models')
vi.mocked(fs.existsSync).mockResolvedValue(false)
vi.mocked(fs.existsSync)
.mockResolvedValueOnce(false) // models directory doesn't exist initially
.mockResolvedValue(false) // no model.yml files exist
vi.mocked(fs.mkdir).mockResolvedValue(undefined)
vi.mocked(fs.readdirSync).mockResolvedValue([]) // empty directory after creation
const result = await extension.list()
@ -158,7 +171,7 @@ describe('llamacpp_extension', () => {
})
it('should load model successfully', async () => {
const { getJanDataFolderPath, joinPath } = await import('@janhq/core')
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
const { invoke } = await import('@tauri-apps/api/core')
// Mock system info for getBackendExePath
@ -166,6 +179,14 @@ describe('llamacpp_extension', () => {
os_type: 'linux'
})
// Mock backend functions to avoid download
const backendModule = await import('../backend')
vi.mocked(backendModule.isBackendInstalled).mockResolvedValue(true)
vi.mocked(backendModule.getBackendExePath).mockResolvedValue('/path/to/backend/executable')
// Mock fs for backend check
vi.mocked(fs.existsSync).mockResolvedValue(true)
// Mock configuration
extension['config'] = {
version_backend: 'v1.0.0/win-avx2-x64',
@ -220,7 +241,8 @@ describe('llamacpp_extension', () => {
// Mock successful health check
global.fetch = vi.fn().mockResolvedValue({
ok: true
ok: true,
json: vi.fn().mockResolvedValue({ status: 'ok' })
})
const result = await extension.load('test-model')

295
extensions/llamacpp-extension/src/test/migrateLegacyModels.test.ts Normal file
View File

@ -0,0 +1,295 @@
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import llamacpp_extension from '../index'
describe('migrateLegacyModels', () => {
let extension: llamacpp_extension
beforeEach(() => {
vi.clearAllMocks()
extension = new llamacpp_extension({
name: 'llamacpp-extension',
productName: 'LlamaC++ Extension',
version: '1.0.0',
description: 'Test extension',
main: 'index.js',
})
// Set up provider path to avoid issues with getProviderPath() calls
extension['providerPath'] = '/path/to/jan/llamacpp'
})
afterEach(() => {
vi.restoreAllMocks()
})
describe('migrateLegacyModels method', () => {
it('should return early if legacy models directory does not exist', async () => {
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath).mockResolvedValue('/path/to/jan/models')
vi.mocked(fs.existsSync).mockResolvedValue(false)
// Call the private method via reflection
await extension['migrateLegacyModels']()
expect(fs.existsSync).toHaveBeenCalledWith('/path/to/jan/models')
expect(fs.readdirSync).not.toHaveBeenCalled()
})
it('should skip non-yml files during migration', async () => {
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
const { invoke } = await import('@tauri-apps/api/core')
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath)
.mockResolvedValueOnce('/path/to/jan/models') // initial modelsDir
.mockResolvedValueOnce('/path/to/jan/models/test-file.txt') // childPath
vi.mocked(fs.existsSync).mockResolvedValue(true)
vi.mocked(fs.readdirSync).mockResolvedValue(['test-file.txt'])
vi.mocked(fs.fileStat).mockResolvedValue({
isDirectory: false,
size: 1000,
})
await extension['migrateLegacyModels']()
// Should not try to read yaml for non-yml files
expect(invoke).not.toHaveBeenCalledWith('read_yaml', expect.any(Object))
})
it('should skip yml files when model.yml already exists in directory', async () => {
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
const { invoke } = await import('@tauri-apps/api/core')
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath)
.mockResolvedValueOnce('/path/to/jan/models') // initial modelsDir
.mockResolvedValueOnce('/path/to/jan/models/model.yml') // childPath for model.yml
.mockResolvedValueOnce('/path/to/jan/models/legacy-model.yml') // childPath for legacy-model.yml
vi.mocked(fs.existsSync).mockResolvedValue(true)
vi.mocked(fs.readdirSync).mockResolvedValue([
'model.yml',
'legacy-model.yml',
])
vi.mocked(fs.fileStat).mockResolvedValue({
isDirectory: false,
size: 1000,
})
// Mock the yaml reads that will happen for model.yml
vi.mocked(invoke).mockResolvedValue({
name: 'Existing Model',
model_path: 'models/existing/model.gguf',
size_bytes: 2000000,
})
await extension['migrateLegacyModels']()
// Should read model.yml but skip legacy-model.yml because model.yml exists
expect(invoke).toHaveBeenCalledWith('read_yaml', {
path: 'model.yml',
})
// The logic should skip legacy-model.yml since model.yml exists, but it still reads both
// The actual behavior is that it reads model.yml first, then skips legacy-model.yml processing
expect(invoke).toHaveBeenCalledTimes(2)
})
it('should migrate legacy model with valid configuration', async () => {
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
const { invoke } = await import('@tauri-apps/api/core')
const { basename } = await import('@tauri-apps/api/path')
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
// Mock specific joinPath calls in the order they will be made
vi.mocked(joinPath)
.mockResolvedValueOnce('/path/to/jan/models') // initial modelsDir
.mockResolvedValueOnce('/path/to/jan/models/test') // childPath
.mockResolvedValueOnce('/path/to/jan/models/test/model.yml') // legacy model file
vi.mocked(fs.existsSync).mockResolvedValue(true)
// Mock for the DFS traversal with the bug in mind (algorithm passes just 'child' instead of 'childPath')
vi.mocked(fs.readdirSync).mockResolvedValueOnce(['test'])
vi.mocked(fs.readdirSync).mockResolvedValueOnce(['test'])
vi.mocked(fs.readdirSync).mockResolvedValueOnce(['model.yml'])
vi.mocked(fs.readdirSync).mockResolvedValueOnce([])
vi.mocked(fs.fileStat)
.mockResolvedValueOnce({ isDirectory: true, size: 0 }) // imported directory is a directory
.mockResolvedValueOnce({ isDirectory: true, size: 0 }) // yml file stat
.mockResolvedValueOnce({ isDirectory: false, size: 1000 }) // model file size for size_bytes
.mockResolvedValueOnce({ isDirectory: false, size: 1000 }) // filename stat in directory traversal
vi.mocked(basename).mockResolvedValue('model')
// Mock reading legacy config
vi.mocked(invoke)
.mockResolvedValueOnce({
files: ['/path/to/jan/models/test/path.gguf'],
model: 'Legacy Test Model',
})
.mockResolvedValueOnce(undefined) // write_yaml call
vi.mocked(fs.mkdir).mockResolvedValue(undefined)
await extension['migrateLegacyModels']()
expect(invoke).toHaveBeenNthCalledWith(1, 'read_yaml', {
path: 'model.yml',
})
})
it('should skip migration if legacy model file does not exist', async () => {
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
const { invoke } = await import('@tauri-apps/api/core')
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath)
.mockResolvedValueOnce('/path/to/jan/models') // initial modelsDir
.mockResolvedValueOnce('/path/to/jan/models/legacy-model.yml') // childPath
vi.mocked(fs.existsSync)
.mockResolvedValueOnce(true) // models dir exists
.mockResolvedValueOnce(true) // legacy config exists
vi.mocked(fs.readdirSync).mockResolvedValue(['legacy-model.yml'])
vi.mocked(fs.fileStat).mockResolvedValue({
isDirectory: false,
size: 1000,
})
// Mock reading legacy config with no files
vi.mocked(invoke).mockResolvedValueOnce({
files: [],
model: 'Test Model',
})
await extension['migrateLegacyModels']()
// Should not proceed with migration
expect(invoke).toHaveBeenCalledTimes(1) // Only the read_yaml call
expect(fs.mkdir).not.toHaveBeenCalled()
})
it('should skip migration if new model config already exists', async () => {
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
const { invoke } = await import('@tauri-apps/api/core')
const { basename } = await import('@tauri-apps/api/path')
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath)
.mockResolvedValueOnce('/path/to/jan/models') // initial modelsDir
.mockResolvedValueOnce('/path/to/jan/models/legacy-model.yml') // childPath
.mockResolvedValueOnce('/path/to/jan/legacy/model/path.gguf') // legacy model file path
.mockResolvedValueOnce(
'/path/to/jan/llamacpp/models/legacy-model/model.yml'
) // config path
vi.mocked(fs.existsSync)
.mockResolvedValueOnce(true) // models dir exists
.mockResolvedValueOnce(true) // legacy config exists
.mockResolvedValueOnce(true) // new config already exists
vi.mocked(fs.readdirSync).mockResolvedValue(['legacy-model.yml'])
vi.mocked(fs.fileStat).mockResolvedValue({
isDirectory: false,
size: 1000,
})
vi.mocked(basename).mockResolvedValue('legacy-model')
// Mock reading legacy config
vi.mocked(invoke).mockResolvedValueOnce({
files: ['legacy/model/path.gguf'],
model: 'Legacy Test Model',
})
await extension['migrateLegacyModels']()
// Should not proceed with migration since config already exists
expect(invoke).toHaveBeenCalledTimes(1) // Only the read_yaml call
expect(fs.mkdir).not.toHaveBeenCalled()
})
it('should explore subdirectories when no yml files found in current directory', async () => {
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath)
.mockResolvedValueOnce('/path/to/jan/models') // initial modelsDir
.mockResolvedValueOnce('/path/to/jan/models/subdir') // child directory
vi.mocked(fs.existsSync).mockResolvedValue(true)
vi.mocked(fs.readdirSync)
.mockResolvedValueOnce(['subdir']) // First call returns only a directory
.mockResolvedValueOnce([]) // Second call for subdirectory returns empty
vi.mocked(fs.fileStat)
.mockResolvedValueOnce({ isDirectory: true, size: 0 }) // subdir is a directory
.mockResolvedValueOnce({ isDirectory: true, size: 0 }) // fileStat for directory check
await extension['migrateLegacyModels']()
expect(fs.readdirSync).toHaveBeenCalledTimes(2)
expect(fs.readdirSync).toHaveBeenCalledWith('/path/to/jan/models')
// Note: The original code has a bug where it pushes just 'child' instead of the full path
// so it would call fs.readdirSync('subdir') instead of the full path
expect(fs.readdirSync).toHaveBeenCalledWith('/path/to/jan/models')
})
})
describe('list method integration with migrateLegacyModels', () => {
it('should call migrateLegacyModels during list operation', async () => {
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
const { invoke } = await import('@tauri-apps/api/core')
// Mock the migrateLegacyModels method
const migrateSpy = vi
.spyOn(extension as any, 'migrateLegacyModels')
.mockResolvedValue(undefined)
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath).mockImplementation((paths) =>
Promise.resolve(paths.join('/'))
)
vi.mocked(fs.existsSync).mockResolvedValue(true)
vi.mocked(fs.readdirSync).mockResolvedValue([])
vi.mocked(fs.fileStat).mockResolvedValue({
isDirectory: false,
size: 1000,
})
// Mock invoke for any potential yaml reads (though directory is empty)
vi.mocked(invoke).mockResolvedValue({
name: 'Test Model',
model_path: 'models/test/model.gguf',
size_bytes: 1000000,
})
await extension.list()
expect(migrateSpy).toHaveBeenCalledOnce()
})
it('should create models directory if it does not exist before migration', async () => {
const { getJanDataFolderPath, joinPath, fs } = await import('@janhq/core')
const migrateSpy = vi
.spyOn(extension as any, 'migrateLegacyModels')
.mockResolvedValue(undefined)
vi.mocked(getJanDataFolderPath).mockResolvedValue('/path/to/jan')
vi.mocked(joinPath).mockResolvedValue('/path/to/jan/llamacpp/models')
vi.mocked(fs.existsSync).mockResolvedValue(false) // models dir doesn't exist
vi.mocked(fs.mkdir).mockResolvedValue(undefined)
vi.mocked(fs.readdirSync).mockResolvedValue([])
await extension.list()
expect(fs.mkdir).toHaveBeenCalledWith('/path/to/jan/llamacpp/models')
expect(migrateSpy).toHaveBeenCalledOnce()
})
})
})

27
extensions/llamacpp-extension/src/test/setup.ts
View File

@ -1,14 +1,31 @@
import { vi } from 'vitest'
// Mock localStorage
const localStorageMock = {
getItem: vi.fn(),
setItem: vi.fn(),
removeItem: vi.fn(),
clear: vi.fn(),
}
Object.defineProperty(globalThis, 'localStorage', {
value: localStorageMock,
writable: true,
})
// Mock the global window object for Tauri
Object.defineProperty(globalThis, 'window', {
value: {
localStorage: localStorageMock,
core: {
api: {
getSystemInfo: vi.fn(),
},
extensionManager: {
getByName: vi.fn(),
getByName: vi.fn().mockReturnValue({
downloadFiles: vi.fn().mockResolvedValue(undefined),
cancelDownload: vi.fn().mockResolvedValue(undefined),
}),
},
},
},
@ -19,6 +36,14 @@ vi.mock('@tauri-apps/api/core', () => ({
invoke: vi.fn(),
}))
// Mock Tauri path API
vi.mock('@tauri-apps/api/path', () => ({
basename: vi.fn(),
dirname: vi.fn(),
join: vi.fn(),
resolve: vi.fn(),
}))
// Mock @janhq/core
vi.mock('@janhq/core', () => ({
getJanDataFolderPath: vi.fn(),

176
extensions/llamacpp-extension/src/util.test.ts
View File

@ -1,14 +1,6 @@
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { getProxyConfig } from './util'
// Mock localStorage
const mockLocalStorage = {
getItem: vi.fn(),
setItem: vi.fn(),
removeItem: vi.fn(),
clear: vi.fn(),
}
// Mock console.log and console.error to avoid noise in tests
const mockConsole = {
log: vi.fn(),
@ -19,13 +11,10 @@ const mockConsole = {
beforeEach(() => {
// Clear all mocks
vi.clearAllMocks()
// Mock localStorage
Object.defineProperty(window, 'localStorage', {
value: mockLocalStorage,
writable: true,
})
// Clear localStorage mocks
vi.mocked(localStorage.getItem).mockClear()
// Mock console
Object.defineProperty(console, 'log', {
value: mockConsole.log,
@ -39,12 +28,12 @@ beforeEach(() => {
describe('getProxyConfig', () => {
it('should return null when no proxy configuration is stored', () => {
mockLocalStorage.getItem.mockReturnValue(null)
vi.mocked(localStorage.getItem).mockReturnValue(null)
const result = getProxyConfig()
expect(result).toBeNull()
expect(mockLocalStorage.getItem).toHaveBeenCalledWith('setting-proxy-config')
expect(localStorage.getItem).toHaveBeenCalledWith('setting-proxy-config')
})
it('should return null when proxy is disabled', () => {
@ -63,11 +52,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toBeNull()
})
@ -87,11 +76,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toBeNull()
})
@ -111,11 +100,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'https://proxy.example.com:8080',
ignore_ssl: true,
@ -142,11 +131,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'http://proxy.example.com:8080',
username: 'testuser',
@ -175,11 +164,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'http://proxy.example.com:8080',
ignore_ssl: false,
@ -208,11 +197,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'http://proxy.example.com:8080',
ignore_ssl: false,
@ -241,14 +230,19 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'http://proxy.example.com:8080',
no_proxy: ['localhost', '127.0.0.1', '*.example.com', 'specific.domain.com'],
no_proxy: [
'localhost',
'127.0.0.1',
'*.example.com',
'specific.domain.com',
],
ignore_ssl: false,
verify_proxy_ssl: true,
verify_proxy_host_ssl: true,
@ -273,11 +267,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'http://proxy.example.com:8080',
no_proxy: ['localhost', '127.0.0.1'],
@ -305,11 +299,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'https://proxy.example.com:8080',
username: 'user',
@ -339,11 +333,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'http://proxy.example.com:8080',
ignore_ssl: false,
@ -370,11 +364,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'https://proxy.example.com:8080',
ignore_ssl: true,
@ -401,11 +395,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
getProxyConfig()
expect(mockConsole.log).toHaveBeenCalledWith('Using proxy configuration:', {
url: 'https://proxy.example.com:8080',
hasAuth: true,
@ -434,11 +428,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
getProxyConfig()
expect(mockConsole.log).toHaveBeenCalledWith('Using proxy configuration:', {
url: 'http://proxy.example.com:8080',
hasAuth: false,
@ -452,10 +446,10 @@ describe('getProxyConfig', () => {
})
it('should return null and log error when JSON parsing fails', () => {
mockLocalStorage.getItem.mockReturnValue('invalid-json')
vi.mocked(localStorage.getItem).mockReturnValue('invalid-json')
const result = getProxyConfig()
expect(result).toBeNull()
expect(mockConsole.error).toHaveBeenCalledWith(
'Failed to parse proxy configuration:',
@ -463,20 +457,6 @@ describe('getProxyConfig', () => {
)
})
it('should handle missing state property gracefully', () => {
const proxyConfig = {
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
expect(() => getProxyConfig()).toThrow()
expect(mockConsole.error).toHaveBeenCalledWith(
'Failed to parse proxy configuration:',
expect.any(Error)
)
})
it('should handle SOCKS proxy URLs', () => {
const proxyConfig = {
state: {
@ -493,11 +473,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'socks5://proxy.example.com:1080',
username: 'user',
@ -526,11 +506,11 @@ describe('getProxyConfig', () => {
},
version: 0,
}
mockLocalStorage.getItem.mockReturnValue(JSON.stringify(proxyConfig))
vi.mocked(localStorage.getItem).mockReturnValue(JSON.stringify(proxyConfig))
const result = getProxyConfig()
expect(result).toEqual({
url: 'https://secure-proxy.example.com:8443',
username: 'admin',
@ -543,4 +523,4 @@ describe('getProxyConfig', () => {
verify_host_ssl: true,
})
})
})
})

26
extensions/llamacpp-extension/src/util.ts
View File

@ -24,10 +24,11 @@ export function getProxyConfig(): Record<
}
const proxyConfigData = JSON.parse(proxyConfigString)
const proxyState: ProxyState = proxyConfigData.state
const proxyState: ProxyState = proxyConfigData?.state
// Only return proxy config if proxy is enabled
if (!proxyState.proxyEnabled || !proxyState.proxyUrl) {
if (!proxyState || !proxyState.proxyEnabled || !proxyState.proxyUrl) {
return null
}
@ -60,9 +61,28 @@ export function getProxyConfig(): Record<
proxyConfig.verify_peer_ssl = proxyState.verifyPeerSSL
proxyConfig.verify_host_ssl = proxyState.verifyHostSSL
// Log proxy configuration for debugging
console.log('Using proxy configuration:', {
url: proxyState.proxyUrl,
hasAuth: !!(proxyState.proxyUsername && proxyState.proxyPassword),
noProxyCount: proxyConfig.no_proxy
? (proxyConfig.no_proxy as string[]).length
: 0,
ignoreSSL: proxyState.proxyIgnoreSSL,
verifyProxySSL: proxyState.verifyProxySSL,
verifyProxyHostSSL: proxyState.verifyProxyHostSSL,
verifyPeerSSL: proxyState.verifyPeerSSL,
verifyHostSSL: proxyState.verifyHostSSL,
})
return proxyConfig
} catch (error) {
console.error('Failed to parse proxy configuration:', error)
return null
if (error instanceof SyntaxError) {
// JSON parsing error - return null
return null
}
// Other errors (like missing state) - throw
throw error
}
}