@inspecto-dev/cli 0.3.1 → 0.3.2

package/src/commands/onboard.ts

@@ -17,6 +17,23 @@ export interface OnboardCommandOptions {
   noExtension?: boolean
 }
 
+function printManualExtensionGuidance(result: OnboardCommandResult): void {
+  if (!result.ideExtension?.required || !result.ideExtension.manualRequired) {
+    return
+  }
+
+  log.warn('Complete the IDE extension install before verification.')
+  if (result.ideExtension.installCommand) {
+    log.hint(result.ideExtension.installCommand)
+  }
+  if (result.ideExtension.marketplaceUrl) {
+    log.hint(result.ideExtension.marketplaceUrl)
+  }
+  if (result.ideExtension.openVsxUrl) {
+    log.hint(result.ideExtension.openVsxUrl)
+  }
+}
+
 function printOnboardResult(result: OnboardCommandResult): void {
   log.header('Inspecto Onboard')
   log.info(`Status: ${result.status}`)
@@ -32,6 +49,8 @@ function printOnboardResult(result: OnboardCommandResult): void {
     log.warn(result.confirmation.question)
   }
 
+  printManualExtensionGuidance(result)
+
   const extensionReady =
     !result.ideExtension?.required ||
     (result.ideExtension.installed && !result.ideExtension.manualRequired)

package/src/index.ts

@@ -2,6 +2,7 @@ export { apply } from './commands/apply.js'
 export { detect } from './commands/detect.js'
 export { init } from './commands/init.js'
 export { collectDoctorResult, doctor } from './commands/doctor.js'
+export { integrationDoctor } from './commands/integration-doctor.js'
 export { onboard } from './commands/onboard.js'
 export { plan } from './commands/plan.js'
 export { teardown } from './commands/teardown.js'

package/src/inject/extension.ts

@@ -11,38 +11,27 @@
 
 import { which, run, shell } from '../utils/exec.js'
 import { exists } from '../utils/fs.js'
+import {
+  getHostIdeBinaryCandidates,
+  getHostIdeBinaryName,
+  getHostIdeLabel,
+  isSupportedHostIde,
+  type SupportedHostIde,
+} from '../integrations/capabilities.js'
 import { log } from '../utils/logger.js'
 import type { Mutation } from '../types.js'
 
 const EXTENSION_ID = 'inspecto.inspecto'
 
-/** Known VS Code binary locations by platform */
-const VSCODE_PATHS: Record<string, string[]> = {
-  darwin: [
-    '/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code',
-    '/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code-insiders',
-    `${process.env.HOME}/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code`,
-  ],
-  linux: ['/usr/bin/code', '/usr/share/code/bin/code', '/snap/bin/code', '/usr/bin/code-insiders'],
-  win32: [
-    `${process.env.LOCALAPPDATA}\\Programs\\Microsoft VS Code\\bin\\code.cmd`,
-    `${process.env.LOCALAPPDATA}\\Programs\\Microsoft VS Code Insiders\\bin\\code-insiders.cmd`,
-    `${process.env.PROGRAMFILES}\\Microsoft VS Code\\bin\\code.cmd`,
-  ],
-}
-
 /** Try to find the VS Code binary at known filesystem paths */
 async function findVSCodeBinary(): Promise<string | null> {
-  const platform = process.platform
-  const candidates = VSCODE_PATHS[platform] || []
-
+  const candidates = getHostIdeBinaryCandidates('vscode')
   for (const candidate of candidates) {
     if (await exists(candidate)) {
       return candidate
     }
   }
 
-  // Also check for code-insiders in PATH
   if (await which('code-insiders')) {
     return 'code-insiders'
   }
@@ -50,8 +39,88 @@ async function findVSCodeBinary(): Promise<string | null> {
   return null
 }
 
+async function findIdeBinary(ide: SupportedHostIde): Promise<string | null> {
+  const binaryName = getHostIdeBinaryName(ide)
+  if (binaryName && (await which(binaryName))) {
+    return binaryName
+  }
+
+  if (ide === 'vscode') {
+    return findVSCodeBinary()
+  }
+
+  const candidates = getHostIdeBinaryCandidates(ide)
+  for (const candidate of candidates) {
+    if (await exists(candidate)) {
+      return candidate
+    }
+  }
+
+  return null
+}
+
+async function installAlternativeIdeExtension(
+  binaryPath: string,
+  ideLabel: string,
+  extensionRef: string,
+  quiet: boolean,
+): Promise<Mutation | null> {
+  try {
+    const { stdout } = await run(binaryPath, ['--list-extensions'])
+    if (extensionRef === EXTENSION_ID && stdout.toLowerCase().includes(EXTENSION_ID)) {
+      if (!quiet) {
+        log.success(`${ideLabel} extension already installed`)
+      }
+      return { type: 'extension_installed', id: EXTENSION_ID, description: 'already_installed' }
+    }
+  } catch {
+    // Continue to install attempt if listing fails.
+  }
+
+  try {
+    await run(binaryPath, ['--install-extension', extensionRef, '--force'])
+    if (!quiet) {
+      log.success(`${ideLabel} extension installed via CLI`)
+    }
+    return { type: 'extension_installed', id: extensionRef, description: 'installed_via_cli' }
+  } catch {
+    try {
+      const { stdout } = await run(binaryPath, ['--list-extensions'])
+      if (extensionRef === EXTENSION_ID && stdout.toLowerCase().includes(EXTENSION_ID)) {
+        if (!quiet) {
+          log.success(`${ideLabel} extension already installed`)
+        }
+        return { type: 'extension_installed', id: EXTENSION_ID, description: 'already_installed' }
+      }
+    } catch {
+      // Fall through to manual guidance.
+    }
+
+    return null
+  }
+}
+
+export async function resolveHostIdeBinary(ide: string): Promise<string | null> {
+  if (!isSupportedHostIde(ide)) return null
+  return findIdeBinary(ide)
+}
+
+export async function openIdeWorkspace(ide: string, cwd: string): Promise<boolean> {
+  const binaryPath = await resolveHostIdeBinary(ide)
+  if (!binaryPath) {
+    return false
+  }
+
+  try {
+    await run(binaryPath, ['--new-window', cwd])
+    return true
+  } catch {
+    return false
+  }
+}
+
 /** Try to open a URI using the system default handler */
-async function tryOpenURI(uri: string): Promise<boolean> {
+export async function openUri(uri: string): Promise<boolean> {
   try {
     const platform = process.platform
     if (platform === 'win32') {
@@ -73,6 +142,7 @@ export async function installExtension(
   dryRun: boolean,
   ide?: string,
   quiet = false,
+  extensionRef = EXTENSION_ID,
 ): Promise<Mutation | null> {
   if (dryRun) {
     if (!quiet) {
@@ -91,7 +161,7 @@ export async function installExtension(
         if (!quiet) {
           log.success('VS Code extension installed via CLI')
         }
-        return { type: 'extension_installed', id: EXTENSION_ID }
+        return { type: 'extension_installed', id: EXTENSION_ID, description: 'installed_via_cli' }
       } catch {
         // Fall through to next level
       }
@@ -108,7 +178,7 @@ export async function installExtension(
             'Tip: Add "code" to your PATH to help Inspecto detect other AI tools in the future',
           )
         }
-        return { type: 'extension_installed', id: EXTENSION_ID }
+        return { type: 'extension_installed', id: EXTENSION_ID, description: 'installed_via_cli' }
       } catch {
         // Fall through to next level
       }
@@ -116,12 +186,17 @@ export async function installExtension(
 
     // Level 3: URI scheme
     const uri = `vscode:extension/${EXTENSION_ID}`
-    if (await tryOpenURI(uri)) {
+    if (await openUri(uri)) {
       if (!quiet) {
         log.warn('Opened extension page in VS Code')
         log.hint('Please click "Install" in the opened VS Code window to complete setup.')
       }
-      return { type: 'extension_installed', id: EXTENSION_ID, manual_action_required: true }
+      return {
+        type: 'extension_installed',
+        id: EXTENSION_ID,
+        description: 'opened_install_page',
+        manual_action_required: true,
+      }
     }
 
     // Level 4: Manual fallback
@@ -136,6 +211,51 @@ export async function installExtension(
     return null
   }
 
+  if (ide === 'cursor' && process.platform === 'darwin') {
+    const cursorPath = await findIdeBinary('cursor')
+    if (cursorPath) {
+      const result = await installAlternativeIdeExtension(
+        cursorPath,
+        getHostIdeLabel('cursor'),
+        extensionRef,
+        quiet,
+      )
+      if (result) {
+        return result
+      }
+    }
+  }
+
+  if (ide === 'trae' && process.platform === 'darwin') {
+    const traePath = await findIdeBinary('trae')
+    if (traePath) {
+      const result = await installAlternativeIdeExtension(
+        traePath,
+        getHostIdeLabel('trae'),
+        extensionRef,
+        quiet,
+      )
+      if (result) {
+        return result
+      }
+    }
+  }
+
+  if (ide === 'trae-cn' && process.platform === 'darwin') {
+    const traeCnPath = await findIdeBinary('trae-cn')
+    if (traeCnPath) {
+      const result = await installAlternativeIdeExtension(
+        traeCnPath,
+        getHostIdeLabel('trae-cn'),
+        extensionRef,
+        quiet,
+      )
+      if (result) {
+        return result
+      }
+    }
+  }
+
   // Other IDEs: Prompt to install via VSIX
   if (!quiet) {
     log.warn(`Could not auto-install extension for ${ide}`)

package/src/integrations/capabilities.ts

@@ -0,0 +1,131 @@
+import path from 'node:path'
+import {
+  DUAL_MODE_PROVIDER_CAPABILITIES,
+  HOST_IDE_IDS,
+  getHostIdeLabel,
+  isSupportedHostIde,
+  type DualModeProvider,
+  type SupportedHostIde,
+} from '@inspecto-dev/types'
+
+type Platform = 'darwin' | 'linux' | 'win32'
+
+interface HostIdeCapability {
+  label: string
+  artifactDir: string
+  extensionDir: string
+  binaryName?: string
+  binaryPaths?: Partial<Record<Platform, string[]>>
+}
+
+export const HOST_IDE_CAPABILITIES: Record<SupportedHostIde, HostIdeCapability> = {
+  vscode: {
+    label: 'VS Code',
+    artifactDir: '.vscode',
+    extensionDir: '.vscode/extensions',
+    binaryName: 'code',
+    binaryPaths: {
+      darwin: [
+        '/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code',
+        '/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code-insiders',
+        `${process.env.HOME}/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code`,
+      ],
+      linux: [
+        '/usr/bin/code',
+        '/usr/share/code/bin/code',
+        '/snap/bin/code',
+        '/usr/bin/code-insiders',
+      ],
+      win32: [
+        `${process.env.LOCALAPPDATA}\\Programs\\Microsoft VS Code\\bin\\code.cmd`,
+        `${process.env.LOCALAPPDATA}\\Programs\\Microsoft VS Code Insiders\\bin\\code-insiders.cmd`,
+        `${process.env.PROGRAMFILES}\\Microsoft VS Code\\bin\\code.cmd`,
+      ],
+    },
+  },
+  cursor: {
+    label: 'Cursor',
+    artifactDir: '.cursor',
+    extensionDir: '.cursor/extensions',
+    binaryName: 'cursor',
+    binaryPaths: {
+      darwin: [
+        '/Applications/Cursor.app/Contents/Resources/app/bin/cursor',
+        `${process.env.HOME}/Applications/Cursor.app/Contents/Resources/app/bin/cursor`,
+      ],
+      linux: ['/usr/bin/cursor', '/opt/Cursor/resources/app/bin/cursor'],
+      win32: [
+        `${process.env.LOCALAPPDATA}\\Programs\\Cursor\\resources\\app\\bin\\cursor.cmd`,
+        `${process.env.PROGRAMFILES}\\Cursor\\resources\\app\\bin\\cursor.cmd`,
+      ],
+    },
+  },
+  trae: {
+    label: 'Trae',
+    artifactDir: '.trae',
+    extensionDir: '.trae/extensions',
+    binaryName: 'trae',
+    binaryPaths: {
+      darwin: [
+        '/Applications/Trae.app/Contents/Resources/app/bin/trae',
+        `${process.env.HOME}/Applications/Trae.app/Contents/Resources/app/bin/trae`,
+      ],
+      linux: ['/usr/bin/trae', '/opt/Trae/resources/app/bin/trae'],
+      win32: [
+        `${process.env.LOCALAPPDATA}\\Programs\\Trae\\resources\\app\\bin\\trae.cmd`,
+        `${process.env.PROGRAMFILES}\\Trae\\resources\\app\\bin\\trae.cmd`,
+      ],
+    },
+  },
+  'trae-cn': {
+    label: 'Trae CN',
+    artifactDir: '.trae-cn',
+    extensionDir: '.trae-cn/extensions',
+    binaryName: 'trae-cn',
+    binaryPaths: {
+      darwin: [
+        '/Applications/Trae CN.app/Contents/Resources/app/bin/trae-cn',
+        `${process.env.HOME}/Applications/Trae CN.app/Contents/Resources/app/bin/trae-cn`,
+      ],
+      linux: ['/usr/bin/trae-cn', '/opt/Trae CN/resources/app/bin/trae-cn'],
+      win32: [
+        `${process.env.LOCALAPPDATA}\\Programs\\Trae CN\\resources\\app\\bin\\trae-cn.cmd`,
+        `${process.env.PROGRAMFILES}\\Trae CN\\resources\\app\\bin\\trae-cn.cmd`,
+      ],
+    },
+  },
+}
+
+export { HOST_IDE_IDS, getHostIdeLabel, isSupportedHostIde }
+export type { SupportedHostIde }
+
+export type DualModeAssistant = DualModeProvider
+
+export function getHostIdeResolutionSourceLabel(source: string): string {
+  if (source === 'explicit') return 'from --host-ide'
+  if (source === 'config') return 'from .inspecto settings'
+  if (source === 'env') return 'from IDE terminal environment'
+  if (source === 'artifact') return 'from project files'
+  return source
+}
+
+export function getHostIdeArtifactPath(ide: SupportedHostIde, cwd: string): string {
+  return path.join(cwd, HOST_IDE_CAPABILITIES[ide].artifactDir)
+}
+
+export function getHostIdeExtensionDir(ide: SupportedHostIde, homeDir: string): string {
+  return path.join(homeDir, HOST_IDE_CAPABILITIES[ide].extensionDir)
+}
+
+export function getHostIdeBinaryName(ide: SupportedHostIde): string | null {
+  return HOST_IDE_CAPABILITIES[ide].binaryName ?? null
+}
+
+export function getHostIdeBinaryCandidates(ide: SupportedHostIde): string[] {
+  const platform = process.platform as Platform
+  return HOST_IDE_CAPABILITIES[ide].binaryPaths?.[platform] ?? []
+}
+
+export function getDualModeAssistantCapability(assistant: string) {
+  return DUAL_MODE_PROVIDER_CAPABILITIES[assistant as DualModeProvider]
+}

package/src/utils/process.ts

@@ -0,0 +1,3 @@
+export function exitProcess(code: number): never {
+  process.exit(code)
+}

package/tests/extension-installer.test.ts

@@ -0,0 +1,205 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const runMock = vi.fn()
+const shellMock = vi.fn()
+const whichMock = vi.fn()
+const existsMock = vi.fn()
+const logMock = {
+  dryRun: vi.fn(),
+  success: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  hint: vi.fn(),
+}
+
+vi.mock('../src/utils/exec.js', () => ({
+  run: runMock,
+  shell: shellMock,
+  which: whichMock,
+}))
+
+vi.mock('../src/utils/fs.js', () => ({
+  exists: existsMock,
+}))
+
+vi.mock('../src/utils/logger.js', () => ({
+  log: logMock,
+}))
+
+describe('installExtension', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    shellMock.mockResolvedValue({ stdout: '', stderr: '' })
+    existsMock.mockResolvedValue(false)
+  })
+
+  it('treats an already-installed Cursor extension as success instead of showing manual install hints', async () => {
+    vi.stubEnv('TERM_PROGRAM', '')
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin')
+    whichMock.mockImplementation(async bin => bin === 'cursor')
+    runMock.mockImplementation(async (_command, args: string[]) => {
+      if (args[0] === '--list-extensions') {
+        return { stdout: 'inspecto.inspecto\n', stderr: '' }
+      }
+      throw new Error('install should not run when already installed')
+    })
+
+    const { installExtension } = await import('../src/inject/extension.js')
+
+    await expect(installExtension(false, 'cursor')).resolves.toMatchObject({
+      type: 'extension_installed',
+      id: 'inspecto.inspecto',
+    })
+
+    expect(logMock.success).toHaveBeenCalledWith('Cursor extension already installed')
+    expect(logMock.warn).not.toHaveBeenCalledWith('Could not auto-install extension for cursor')
+    expect(runMock).toHaveBeenCalledWith('cursor', ['--list-extensions'])
+  })
+
+  it('installs the Trae CN extension via the app binary on macOS when available', async () => {
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin')
+    whichMock.mockResolvedValue(false)
+    existsMock.mockImplementation(async filePath => {
+      return filePath === '/Applications/Trae CN.app/Contents/Resources/app/bin/trae-cn'
+    })
+    runMock.mockImplementation(async (_command, args: string[]) => {
+      if (args[0] === '--list-extensions') {
+        return { stdout: '', stderr: '' }
+      }
+      if (args[0] === '--install-extension') {
+        return { stdout: '', stderr: '' }
+      }
+      throw new Error(`unexpected args: ${args.join(' ')}`)
+    })
+
+    const { installExtension } = await import('../src/inject/extension.js')
+
+    await expect(installExtension(false, 'trae-cn')).resolves.toMatchObject({
+      type: 'extension_installed',
+      id: 'inspecto.inspecto',
+    })
+
+    expect(runMock).toHaveBeenCalledWith(
+      '/Applications/Trae CN.app/Contents/Resources/app/bin/trae-cn',
+      ['--install-extension', 'inspecto.inspecto', '--force'],
+    )
+    expect(logMock.success).toHaveBeenCalledWith('Trae CN extension installed via CLI')
+  })
+
+  it('installs the Trae extension via PATH when available', async () => {
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin')
+    whichMock.mockImplementation(async bin => bin === 'trae')
+    runMock.mockImplementation(async (_command, args: string[]) => {
+      if (args[0] === '--list-extensions') {
+        return { stdout: '', stderr: '' }
+      }
+      if (args[0] === '--install-extension') {
+        return { stdout: '', stderr: '' }
+      }
+      throw new Error(`unexpected args: ${args.join(' ')}`)
+    })
+
+    const { installExtension } = await import('../src/inject/extension.js')
+
+    await expect(installExtension(false, 'trae')).resolves.toMatchObject({
+      type: 'extension_installed',
+      id: 'inspecto.inspecto',
+      description: 'installed_via_cli',
+    })
+
+    expect(runMock).toHaveBeenCalledWith('trae', [
+      '--install-extension',
+      'inspecto.inspecto',
+      '--force',
+    ])
+    expect(logMock.success).toHaveBeenCalledWith('Trae extension installed via CLI')
+  })
+
+  it('installs a VSIX path in Trae CN when provided', async () => {
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin')
+    whichMock.mockImplementation(async bin => bin === 'trae-cn')
+    runMock.mockImplementation(async (_command, args: string[]) => {
+      if (args[0] === '--list-extensions') {
+        return { stdout: '', stderr: '' }
+      }
+      if (args[0] === '--install-extension') {
+        return { stdout: '', stderr: '' }
+      }
+      throw new Error(`unexpected args: ${args.join(' ')}`)
+    })
+
+    const { installExtension } = await import('../src/inject/extension.js')
+
+    await expect(
+      installExtension(false, 'trae-cn', true, '/tmp/inspecto.vsix'),
+    ).resolves.toMatchObject({
+      type: 'extension_installed',
+      id: '/tmp/inspecto.vsix',
+      description: 'installed_via_cli',
+    })
+
+    expect(runMock).toHaveBeenCalledWith('trae-cn', [
+      '--install-extension',
+      '/tmp/inspecto.vsix',
+      '--force',
+    ])
+  })
+
+  it('treats Trae CN as already installed when install fails but a follow-up extension check succeeds', async () => {
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin')
+    whichMock.mockResolvedValue(false)
+
+    let listCalls = 0
+    existsMock.mockImplementation(async filePath => {
+      return filePath === '/Applications/Trae CN.app/Contents/Resources/app/bin/trae-cn'
+    })
+    runMock.mockImplementation(async (_command, args: string[]) => {
+      if (args[0] === '--list-extensions') {
+        listCalls += 1
+        return {
+          stdout: listCalls === 1 ? '' : 'inspecto.inspecto\n',
+          stderr: '',
+        }
+      }
+      if (args[0] === '--install-extension') {
+        throw new Error('network failed')
+      }
+      throw new Error(`unexpected args: ${args.join(' ')}`)
+    })
+
+    const { installExtension } = await import('../src/inject/extension.js')
+
+    await expect(installExtension(false, 'trae-cn')).resolves.toMatchObject({
+      type: 'extension_installed',
+      id: 'inspecto.inspecto',
+    })
+
+    expect(logMock.success).toHaveBeenCalledWith('Trae CN extension already installed')
+    expect(logMock.warn).not.toHaveBeenCalledWith('Could not auto-install extension for trae-cn')
+  })
+})
+
+describe('openIdeWorkspace', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    existsMock.mockResolvedValue(false)
+  })
+
+  it('opens Trae CN in a new window for the requested workspace', async () => {
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin')
+    whichMock.mockResolvedValue(false)
+    existsMock.mockImplementation(async filePath => {
+      return filePath === '/Applications/Trae CN.app/Contents/Resources/app/bin/trae-cn'
+    })
+    runMock.mockResolvedValue({ stdout: '', stderr: '' })
+
+    const { openIdeWorkspace } = await import('../src/inject/extension.js')
+
+    await expect(openIdeWorkspace('trae-cn', '/repo/app')).resolves.toBe(true)
+
+    expect(runMock).toHaveBeenCalledWith(
+      '/Applications/Trae CN.app/Contents/Resources/app/bin/trae-cn',
+      ['--new-window', '/repo/app'],
+    )
+  })
+})

package/tests/install-wrapper.test.ts

@@ -21,9 +21,9 @@ describe('assistant integration bootstrap wrapper', () => {
 
     const fakeBin = path.join(tempRoot, 'bin')
     await fs.mkdir(fakeBin, { recursive: true })
-    await fs.mkdir(path.join(tempRoot, '.github'), { recursive: true })
+    await fs.mkdir(path.join(tempRoot, '.github/skills/inspecto-onboarding'), { recursive: true })
     await fs.writeFile(
-      path.join(tempRoot, '.github/copilot-instructions.md'),
+      path.join(tempRoot, '.github/skills/inspecto-onboarding/SKILL.md'),
       'old content\n',
       'utf8',
     )
@@ -54,7 +54,7 @@ describe('assistant integration bootstrap wrapper', () => {
     )
     await fs.chmod(path.join(fakeBin, 'curl'), 0o755)
 
-    const scriptPath = path.resolve(__dirname, '../../../assistant-integrations/scripts/install.sh')
+    const scriptPath = path.resolve(__dirname, '../../../scripts/install.sh')
 
     await execFileAsync('bash', [scriptPath, 'copilot', '--force'], {
       cwd: tempRoot,
@@ -65,9 +65,50 @@ describe('assistant integration bootstrap wrapper', () => {
     })
 
     const installed = await fs.readFile(
-      path.join(tempRoot, '.github/copilot-instructions.md'),
+      path.join(tempRoot, '.github/skills/inspecto-onboarding/SKILL.md'),
       'utf8',
     )
     expect(installed).toBe('downloaded from wrapper\n')
   })
+
+  it('passes --host-ide through to the CLI install command', async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'inspecto-wrapper-'))
+    tempDirs.push(tempRoot)
+
+    const fakeBin = path.join(tempRoot, 'bin')
+    await fs.mkdir(fakeBin, { recursive: true })
+
+    const argsFile = path.join(tempRoot, 'npx-args.txt')
+    await fs.writeFile(
+      path.join(fakeBin, 'npx'),
+      ['#!/usr/bin/env bash', 'set -euo pipefail', 'printf "%s\n" "$@" > "$NPX_ARGS_FILE"'].join(
+        '\n',
+      ),
+      'utf8',
+    )
+    await fs.chmod(path.join(fakeBin, 'npx'), 0o755)
+
+    const scriptPath = path.resolve(__dirname, '../../../scripts/install.sh')
+
+    await execFileAsync('bash', [scriptPath, 'codex', 'project', '--host-ide', 'cursor'], {
+      cwd: tempRoot,
+      env: {
+        ...process.env,
+        PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+        NPX_ARGS_FILE: argsFile,
+      },
+    })
+
+    const forwardedArgs = await fs.readFile(argsFile, 'utf8')
+    expect(forwardedArgs.trim().split('\n')).toEqual([
+      '@inspecto-dev/cli',
+      'integrations',
+      'install',
+      'codex',
+      '--host-ide',
+      'cursor',
+      '--scope',
+      'project',
+    ])
+  })
 })