fix: respect project paths and Vite+ build commands (#581)

Author: hyoban

packages/kit/src/node/utils.ts

@@ -1,5 +1,11 @@
 import type { ClientScriptEntry } from '../types/docks'
 import { Buffer } from 'node:buffer'
+import { isPackageExists } from 'local-pkg'
+
+/** Detect Vite+ from the project directory when selecting its toolchain commands. */
+export function isVitePlusInstalled(cwd: string): boolean {
+  return isPackageExists('vite-plus', { paths: [cwd] })
+}
 
 function toDataURL(code: string) {
   return `data:text/javascript;base64,${Buffer.from(code).toString('base64')}`

packages/oxc/src/node/__tests__/devframe.test.ts

@@ -0,0 +1,58 @@
+import type { DevframeNodeContext } from 'devframe/types'
+import type { ServerFunctions } from '../rpc'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'pathe'
+import { RpcFunctionsCollectorBase } from 'devframe/rpc'
+import { afterEach, describe, expect, it } from 'vitest'
+import { oxcDevframe } from '../devframe'
+
+const fixtures: string[] = []
+
+afterEach(async () => {
+  await Promise.all(fixtures.splice(0).map(dir => rm(dir, { recursive: true, force: true })))
+})
+
+async function createProject() {
+  const workspaceRoot = await mkdtemp(join(tmpdir(), 'oxc-monorepo-'))
+  fixtures.push(workspaceRoot)
+  const cwd = join(workspaceRoot, 'packages/app')
+  await mkdir(cwd, { recursive: true })
+  const ctx = { cwd, workspaceRoot } as DevframeNodeContext
+  const rpc = new RpcFunctionsCollectorBase<ServerFunctions, DevframeNodeContext>(ctx)
+  ctx.rpc = rpc as unknown as DevframeNodeContext['rpc']
+  await oxcDevframe.setup!(ctx, {} as never)
+  return { cwd, workspaceRoot, rpc }
+}
+
+describe('Oxc project context', () => {
+  it('discovers and reads the project configs when the workspace has its own configs', async () => {
+    const { cwd, workspaceRoot, rpc } = await createProject()
+    const configs = [
+      ['oxlint.config.ts', 'devtools-oxc:get-lint-config-file'],
+      ['oxfmt.config.ts', 'devtools-oxc:get-fmt-config-file'],
+    ] as const
+    for (const [filename] of configs) {
+      await writeFile(join(workspaceRoot, filename), 'export default { /* workspace */ }')
+      await writeFile(join(cwd, filename), 'export default { /* project */ }')
+    }
+
+    const discover = await rpc.getHandler('devtools-oxc:get-config-files')
+    const files = await discover()
+    expect(files).toEqual(
+      expect.arrayContaining(
+        configs.map(([path]) =>
+          expect.objectContaining({
+            path,
+            content: 'export default { /* project */ }',
+          }),
+        ),
+      ),
+    )
+    expect(files).toHaveLength(2)
+    for (const [, name] of configs) {
+      const readConfig = await rpc.getHandler(name)
+      await expect(readConfig()).resolves.toBe('export default { /* project */ }')
+    }
+  })
+})

packages/oxc/src/node/__tests__/workspace-paths.test.ts

@@ -0,0 +1,53 @@
+import type { DevframeNodeContext } from 'devframe/types'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'pathe'
+import { launchEditor } from 'devframe/utils/launch-editor'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { openInEditor } from '../rpc/functions/open-in-editor'
+import { oxfmtGetConfigFile } from '../rpc/functions/oxfmt-get-config-file'
+import { oxlintGetConfigFile } from '../rpc/functions/oxlint-get-config-file'
+
+vi.mock('devframe/utils/launch-editor', () => ({ launchEditor: vi.fn<typeof launchEditor>() }))
+
+const fixtures: string[] = []
+
+afterEach(async () => {
+  vi.clearAllMocks()
+  await Promise.all(fixtures.splice(0).map(dir => rm(dir, { recursive: true, force: true })))
+})
+
+describe('project-relative RPC paths', () => {
+  it.each(['', ':12', ':12:3'])('opens project files with position suffix "%s"', async suffix => {
+    const cwd = join(tmpdir(), 'oxc-workspace')
+    const { handler } = openInEditor.setup({ cwd } as DevframeNodeContext)
+
+    await handler(`src/index.ts${suffix}`)
+
+    expect(launchEditor).toHaveBeenCalledWith(join(cwd, `src/index.ts${suffix}`))
+  })
+
+  it('preserves absolute editor targets', async () => {
+    const { handler } = openInEditor.setup({ cwd: '/workspace' } as DevframeNodeContext)
+    const target = join(tmpdir(), 'external/index.ts:12:3')
+
+    await handler(target)
+
+    expect(launchEditor).toHaveBeenCalledWith(target)
+  })
+
+  it.each([
+    ['oxlint.config.ts', oxlintGetConfigFile],
+    ['oxfmt.config.ts', oxfmtGetConfigFile],
+  ] as const)('reads %s from the context directory', async (filename, definition) => {
+    const cwd = await mkdtemp(join(tmpdir(), 'oxc-workspace-config-'))
+    fixtures.push(cwd)
+    const content = 'export default { /* workspace config */ }'
+    await writeFile(join(cwd, filename), content)
+    const { handler } = definition.setup({ cwd } as DevframeNodeContext)
+
+    await expect(handler()).resolves.toBe(content)
+    await rm(join(cwd, filename))
+    await expect(handler()).resolves.toBeNull()
+  })
+})

packages/oxc/src/node/rpc/functions/open-in-editor.ts

@@ -1,4 +1,5 @@
 import { launchEditor } from 'devframe/utils/launch-editor'
+import { resolve } from 'pathe'
 import { defineOxcRpc } from '../_define'
 
 /**
@@ -10,10 +11,10 @@ import { defineOxcRpc } from '../_define'
 export const openInEditor = defineOxcRpc({
   name: 'devtools-oxc:open-in-editor',
   type: 'action',
-  setup: () => {
+  setup: context => {
     return {
       handler: async (target: string) => {
-        launchEditor(target)
+        launchEditor(resolve(context.cwd, target))
       },
     }
   },

packages/oxc/src/node/rpc/functions/overview.ts

@@ -1,6 +1,7 @@
+import { isVitePlusInstalled } from '@vitejs/devtools-kit/node'
 import { defineOxcRpc } from '../_define'
 import { x } from 'tinyexec'
-import { getVitePlusVersions, isVitePlusInstalled } from '../../utils/vite-plus'
+import { getVitePlusVersions } from '../../utils/vite-plus'
 import { needsOxlintMigration } from './oxlint-setup'
 
 type Package = {

packages/oxc/src/node/rpc/functions/oxfmt-get-config-file.ts

@@ -6,10 +6,10 @@ export const oxfmtGetConfigFile = defineOxcRpc({
   type: 'query',
   jsonSerializable: true,
   cacheable: true,
-  setup: () => {
+  setup: context => {
     return {
       handler: async () => {
-        const config = await getOxfmtConfig()
+        const config = await getOxfmtConfig(context.cwd)
         return config
       },
     }

packages/oxc/src/node/rpc/functions/oxfmt-run.ts

@@ -1,10 +1,10 @@
+import { isVitePlusInstalled } from '@vitejs/devtools-kit/node'
 import { existsSync } from 'node:fs'
 import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises'
 import { Diagnostic } from 'nostics'
 import { resolve } from 'pathe'
 import { x } from 'tinyexec'
 import { diagnostics } from '../../diagnostics'
-import { isVitePlusInstalled } from '../../utils/vite-plus'
 import { ensureOxcGitignored } from '../../utils/oxlint'
 import { defineOxcRpc } from '../_define'
 import { isGitDirty } from './oxfmt-setup'

packages/oxc/src/node/rpc/functions/oxlint-get-config-file.ts

@@ -6,10 +6,10 @@ export const oxlintGetConfigFile = defineOxcRpc({
   type: 'query',
   jsonSerializable: true,
   cacheable: true,
-  setup: () => {
+  setup: context => {
     return {
       handler: async () => {
-        const config = await getOxlintConfig()
+        const config = await getOxlintConfig(context.cwd)
         return config
       },
     }

packages/oxc/src/node/rpc/functions/oxlint-run.ts

@@ -1,10 +1,11 @@
+import { isVitePlusInstalled } from '@vitejs/devtools-kit/node'
 import { Diagnostic } from 'nostics'
 import { x } from 'tinyexec'
 import { defineOxcRpc } from '../_define'
 import { diagnostics } from '../../diagnostics'
 import { getOxcConfigFiles } from '../../utils/config-files'
 import { ensureOxcGitignored, parseOxlintOutput } from '../../utils/oxlint'
-import { getVitePlusVersions, isVitePlusInstalled } from '../../utils/vite-plus'
+import { getVitePlusVersions } from '../../utils/vite-plus'
 import { getLintResultsManager } from '../utils'
 
 export const oxlintRun = defineOxcRpc({

packages/oxc/src/node/utils/oxfmt.ts

@@ -2,8 +2,8 @@ import { readFile } from 'node:fs/promises'
 import { cwd } from 'node:process'
 import { resolve } from 'pathe'
 
-export async function getOxfmtConfig() {
-  const configPath = resolve(cwd(), 'oxfmt.config.ts')
+export async function getOxfmtConfig(root = cwd()) {
+  const configPath = resolve(root, 'oxfmt.config.ts')
   try {
     const config = await readFile(configPath, 'utf-8')
     return config