| import { describe, expect, it } from 'bun:test' |
| import { mkdtemp, rm, writeFile } from 'node:fs/promises' |
| import { join } from 'node:path' |
| import { tmpdir } from 'node:os' |
| import { createOpenTargetService } from '../services/openTargetService.js' |
|
|
| async function makeDir(prefix = 'cc-haha-open-target-') { |
| return mkdtemp(join(tmpdir(), prefix)) |
| } |
|
|
| function createService( |
| platform: NodeJS.Platform, |
| options: { |
| commands?: Record<string, boolean> |
| commandPaths?: Record<string, string | null> |
| paths?: Record<string, boolean> |
| plistValues?: Record<string, string | null> |
| dirNames?: Record<string, string[]> |
| textFiles?: Record<string, string | null> |
| launchResult?: { code: number; stdout: string; stderr: string } |
| iconData?: Uint8Array |
| ttlMs?: number |
| now?: { value: number } |
| } = {}, |
| ) { |
| const launched: Array<{ command: string; args: string[] }> = [] |
| const convertedIcons: Array<{ iconPath: string; size: number }> = [] |
| let commandProbes = 0 |
| let pathProbes = 0 |
| const now = options.now ?? { value: 100 } |
|
|
| const service = createOpenTargetService({ |
| platform, |
| ttlMs: options.ttlMs ?? 1_000, |
| now: () => now.value, |
| commandExists: async (command) => { |
| commandProbes += 1 |
| return options.commands?.[command] === true || Boolean(options.commandPaths?.[command]) |
| }, |
| resolveCommand: async (command) => { |
| const commandPath = options.commandPaths?.[command] |
| if (commandPath !== undefined) return commandPath |
| return options.commands?.[command] === true ? command : null |
| }, |
| pathExists: async (targetPath) => { |
| pathProbes += 1 |
| return options.paths?.[targetPath] === true |
| }, |
| launch: async (command, args) => { |
| launched.push({ command, args }) |
| return options.launchResult ?? { code: 0, stdout: '', stderr: '' } |
| }, |
| readDirNames: async (targetPath) => options.dirNames?.[targetPath] ?? [], |
| readTextFile: async (targetPath) => options.textFiles?.[targetPath] ?? null, |
| readPlistValue: async (plistPath) => options.plistValues?.[plistPath] ?? null, |
| convertIconToPng: async (iconPath, size) => { |
| convertedIcons.push({ iconPath, size }) |
| return options.iconData ?? new Uint8Array([1, 2, 3]) |
| }, |
| }) |
|
|
| return { |
| service, |
| launched, |
| convertedIcons, |
| now, |
| get commandProbes() { |
| return commandProbes |
| }, |
| get pathProbes() { |
| return pathProbes |
| }, |
| } |
| } |
|
|
| describe('openTargetService', () => { |
| it('returns only detected IDE targets plus Finder on macOS', async () => { |
| const { service } = createService('darwin', { |
| paths: { |
| '/Applications/Visual Studio Code.app': true, |
| '/Applications/Sublime Text.app': true, |
| }, |
| }) |
|
|
| const result = await service.listTargets() |
|
|
| expect(result.platform).toBe('darwin') |
| expect(result.targets.map((target) => target.id)).toEqual([ |
| 'vscode', |
| 'sublime', |
| 'finder', |
| ]) |
| expect(result.primaryTargetId).toBe('vscode') |
| expect(result.targets.find((target) => target.id === 'finder')?.kind).toBe('file_manager') |
| expect(result.targets.find((target) => target.id === 'vscode')?.iconUrl) |
| .toBe('/api/open-targets/icons/vscode') |
| }) |
|
|
| it('does not treat macOS command shims as installed IDEs without the app bundle', async () => { |
| const { service } = createService('darwin', { |
| commands: { |
| code: true, |
| goland: true, |
| pycharm: true, |
| }, |
| }) |
|
|
| const result = await service.listTargets() |
|
|
| expect(result.targets.map((target) => target.id)).toEqual(['finder']) |
| expect(result.primaryTargetId).toBe('finder') |
| }) |
|
|
| it('falls back to Explorer when no Windows IDE is detected', async () => { |
| const { service } = createService('win32') |
|
|
| const result = await service.listTargets() |
|
|
| expect(result.targets.map((target) => target.id)).toEqual(['explorer']) |
| expect(result.primaryTargetId).toBe('explorer') |
| expect(result.targets[0]?.iconUrl).toBe('/api/open-targets/icons/explorer') |
| }) |
|
|
| it('does not include stale Windows command shims without the app executable', async () => { |
| const { service } = createService('win32', { |
| commandPaths: { |
| 'code.cmd': 'C:\\Users\\nanmi\\AppData\\Local\\Programs\\Microsoft VS Code\\bin\\code.cmd', |
| 'goland.cmd': 'C:\\Users\\nanmi\\AppData\\Local\\JetBrains\\Toolbox\\scripts\\goland.cmd', |
| }, |
| }) |
|
|
| const result = await service.listTargets() |
|
|
| expect(result.targets.map((target) => target.id)).toEqual(['explorer']) |
| expect(result.primaryTargetId).toBe('explorer') |
| }) |
|
|
| it('detects Windows IDEs only when a real executable is resolved', async () => { |
| const commandPath = 'C:\\Users\\nanmi\\AppData\\Local\\Programs\\Microsoft VS Code\\bin\\code.cmd' |
| const executablePath = 'C:\\Users\\nanmi\\AppData\\Local\\Programs\\Microsoft VS Code\\Code.exe' |
| const { service } = createService('win32', { |
| commandPaths: { |
| 'code.cmd': commandPath, |
| }, |
| paths: { |
| [executablePath]: true, |
| }, |
| }) |
|
|
| const result = await service.listTargets() |
|
|
| expect(result.targets.map((target) => target.id)).toEqual(['vscode', 'explorer']) |
| expect(result.primaryTargetId).toBe('vscode') |
| }) |
|
|
| it('only includes the Linux file-manager fallback when xdg-open is available', async () => { |
| const withoutXdg = createService('linux') |
| expect((await withoutXdg.service.listTargets()).targets).toEqual([]) |
|
|
| const withXdg = createService('linux', { |
| commands: { 'xdg-open': true }, |
| }) |
| expect((await withXdg.service.listTargets()).targets.map((target) => target.id)).toEqual([ |
| 'file-manager', |
| ]) |
| }) |
|
|
| it('caches detection results until the TTL expires', async () => { |
| const now = { value: 100 } |
| const state = createService('linux', { |
| commands: { code: true }, |
| now, |
| }) |
|
|
| await state.service.listTargets() |
| const initialProbes = state.commandProbes |
| expect(initialProbes).toBeGreaterThan(0) |
|
|
| await state.service.listTargets() |
| expect(state.commandProbes).toBe(initialProbes) |
|
|
| now.value = 5_000 |
| await state.service.listTargets() |
| expect(state.commandProbes).toBeGreaterThan(initialProbes) |
| }) |
|
|
| it('rejects unknown targets', async () => { |
| const dir = await makeDir() |
| const { service } = createService('darwin', { commands: { code: true } }) |
|
|
| try { |
| await expect(service.openTarget({ targetId: 'terminal', path: dir })) |
| .rejects.toMatchObject({ code: 'OPEN_TARGET_UNKNOWN' }) |
| } finally { |
| await rm(dir, { recursive: true, force: true }) |
| } |
| }) |
|
|
| it('rejects non-directory paths', async () => { |
| const dir = await makeDir() |
| const file = join(dir, 'note.txt') |
| await writeFile(file, 'not a directory') |
| const { service } = createService('darwin', { |
| paths: { '/Applications/Visual Studio Code.app': true }, |
| }) |
|
|
| try { |
| await expect(service.openTarget({ targetId: 'vscode', path: file })) |
| .rejects.toMatchObject({ code: 'OPEN_TARGET_PATH_NOT_DIRECTORY' }) |
| } finally { |
| await rm(dir, { recursive: true, force: true }) |
| } |
| }) |
|
|
| it('launches command-first targets with argument arrays and the path as one argument', async () => { |
| const dir = await makeDir('cc-haha open-target-') |
| const { service, launched } = createService('linux', { |
| commands: { code: true }, |
| }) |
|
|
| try { |
| await service.openTarget({ targetId: 'vscode', path: dir }) |
|
|
| expect(launched).toEqual([{ command: 'code', args: [dir] }]) |
| } finally { |
| await rm(dir, { recursive: true, force: true }) |
| } |
| }) |
|
|
| it('opens macOS app bundles through open -a instead of command shims', async () => { |
| const dir = await makeDir() |
| const { service, launched } = createService('darwin', { |
| commands: { cursor: true }, |
| paths: { '/Applications/Cursor.app': true }, |
| }) |
|
|
| try { |
| await service.openTarget({ targetId: 'cursor', path: dir }) |
|
|
| expect(launched).toEqual([ |
| { command: 'open', args: ['-a', '/Applications/Cursor.app', dir] }, |
| ]) |
| } finally { |
| await rm(dir, { recursive: true, force: true }) |
| } |
| }) |
|
|
| it('opens Windows command-shim targets through the resolved executable', async () => { |
| const dir = await makeDir() |
| const commandPath = 'C:\\Users\\nanmi\\AppData\\Local\\Programs\\Microsoft VS Code\\bin\\code.cmd' |
| const executablePath = 'C:\\Users\\nanmi\\AppData\\Local\\Programs\\Microsoft VS Code\\Code.exe' |
| const { service, launched } = createService('win32', { |
| commandPaths: { |
| 'code.cmd': commandPath, |
| }, |
| paths: { |
| [executablePath]: true, |
| }, |
| }) |
|
|
| try { |
| await service.openTarget({ targetId: 'vscode', path: dir }) |
|
|
| expect(launched).toEqual([{ command: executablePath, args: [dir] }]) |
| } finally { |
| await rm(dir, { recursive: true, force: true }) |
| } |
| }) |
|
|
| it('opens Windows Explorer through the file-manager fallback', async () => { |
| const dir = await makeDir() |
| const { service, launched } = createService('win32') |
|
|
| try { |
| await service.openTarget({ targetId: 'explorer', path: dir }) |
|
|
| expect(launched).toEqual([{ command: 'cmd.exe', args: ['/d', '/c', 'start', '', dir] }]) |
| } finally { |
| await rm(dir, { recursive: true, force: true }) |
| } |
| }) |
|
|
| it('reports launch failures instead of returning success', async () => { |
| const dir = await makeDir() |
| const { service } = createService('darwin', { |
| paths: { '/Applications/Visual Studio Code.app': true }, |
| launchResult: { code: 1, stdout: '', stderr: 'failed' }, |
| }) |
|
|
| try { |
| await expect(service.openTarget({ targetId: 'vscode', path: dir })) |
| .rejects.toMatchObject({ code: 'OPEN_TARGET_LAUNCH_FAILED' }) |
| } finally { |
| await rm(dir, { recursive: true, force: true }) |
| } |
| }) |
|
|
| it('extracts macOS target icons from the detected app bundle icon file', async () => { |
| const iconPath = '/Applications/Visual Studio Code.app/Contents/Resources/Code.icns' |
| const state = createService('darwin', { |
| paths: { |
| '/Applications/Visual Studio Code.app': true, |
| [iconPath]: true, |
| }, |
| plistValues: { |
| '/Applications/Visual Studio Code.app/Contents/Info.plist': 'Code.icns', |
| }, |
| iconData: new Uint8Array([9, 8, 7]), |
| }) |
|
|
| const icon = await state.service.getTargetIcon('vscode') |
|
|
| expect(icon.contentType).toBe('image/png') |
| expect(Array.from(icon.data)).toEqual([9, 8, 7]) |
| expect(state.convertedIcons).toEqual([{ iconPath, size: 64 }]) |
|
|
| await state.service.getTargetIcon('vscode') |
| expect(state.convertedIcons).toHaveLength(1) |
| }) |
|
|
| it('uses Finder system icon for the macOS file-manager fallback', async () => { |
| const finderIcon = '/System/Library/CoreServices/Finder.app/Contents/Resources/Finder.icns' |
| const state = createService('darwin', { |
| paths: { |
| [finderIcon]: true, |
| }, |
| }) |
|
|
| await state.service.getTargetIcon('finder') |
|
|
| expect(state.convertedIcons).toEqual([{ iconPath: finderIcon, size: 64 }]) |
| }) |
|
|
| it('extracts Windows target icons from the resolved application executable', async () => { |
| const commandPath = 'C:\\Users\\nanmi\\AppData\\Local\\Programs\\Microsoft VS Code\\bin\\code.cmd' |
| const iconPath = 'C:\\Users\\nanmi\\AppData\\Local\\Programs\\Microsoft VS Code\\Code.exe' |
| const state = createService('win32', { |
| commandPaths: { |
| 'code.cmd': commandPath, |
| }, |
| paths: { |
| [iconPath]: true, |
| }, |
| iconData: new Uint8Array([4, 5, 6]), |
| }) |
|
|
| const icon = await state.service.getTargetIcon('vscode') |
|
|
| expect(icon.contentType).toBe('image/png') |
| expect(Array.from(icon.data)).toEqual([4, 5, 6]) |
| expect(state.convertedIcons).toEqual([{ iconPath, size: 64 }]) |
| }) |
|
|
| it('uses the Windows Explorer executable icon for the file-manager fallback', async () => { |
| const explorerPath = 'C:\\Windows\\explorer.exe' |
| const state = createService('win32', { |
| commandPaths: { |
| 'explorer.exe': explorerPath, |
| }, |
| paths: { |
| [explorerPath]: true, |
| }, |
| }) |
|
|
| await state.service.getTargetIcon('explorer') |
|
|
| expect(state.convertedIcons).toEqual([{ iconPath: explorerPath, size: 64 }]) |
| }) |
|
|
| it('extracts Linux target icons from matching desktop entries', async () => { |
| const desktopPath = '/usr/share/applications/code.desktop' |
| const iconPath = '/usr/share/pixmaps/code.png' |
| const state = createService('linux', { |
| commands: { |
| code: true, |
| }, |
| dirNames: { |
| '/usr/share/applications': ['code.desktop'], |
| }, |
| textFiles: { |
| [desktopPath]: [ |
| '[Desktop Entry]', |
| 'Name=Visual Studio Code', |
| 'Exec=/usr/bin/code --reuse-window %F', |
| 'Icon=code', |
| ].join('\n'), |
| }, |
| paths: { |
| [iconPath]: true, |
| }, |
| }) |
|
|
| await state.service.getTargetIcon('vscode') |
|
|
| expect(state.convertedIcons).toEqual([{ iconPath, size: 64 }]) |
| }) |
|
|
| it('uses the Linux folder icon for the file-manager fallback when available', async () => { |
| const folderIcon = '/usr/share/icons/hicolor/64x64/apps/folder.png' |
| const state = createService('linux', { |
| commands: { |
| 'xdg-open': true, |
| }, |
| dirNames: { |
| '/usr/share/icons': ['hicolor'], |
| }, |
| paths: { |
| [folderIcon]: true, |
| }, |
| }) |
|
|
| await state.service.getTargetIcon('file-manager') |
|
|
| expect(state.convertedIcons).toEqual([{ iconPath: folderIcon, size: 64 }]) |
| }) |
| }) |
|
|
