# Javascript Typescript Langserver

> Complete reference for the Language Server Protocol (LSP) methods and extensions supported by this language server.

---

# API Reference

Source: https://github.com/sourcegraph/javascript-typescript-langserver

Complete reference for the Language Server Protocol (LSP) methods and extensions supported by this language server.

## Standard LSP Methods

This server implements the core Language Server Protocol specification. For detailed protocol information, see: https://microsoft.github.io/language-server-protocol/

### Text Synchronization

#### `textDocument/didOpen`

Notification sent when a document is opened in the client.

```typescript
interface DidOpenTextDocumentParams {
  textDocument: TextDocumentItem
}

interface TextDocumentItem {
  uri: string
  languageId: string
  version: number
  text: string
}
```

#### `textDocument/didChange`

Notification sent when a document is modified.

```typescript
interface DidChangeTextDocumentParams {
  textDocument: VersionedTextDocumentIdentifier
  contentChanges: TextDocumentContentChangeEvent[]
}
```

#### `textDocument/didClose`

Notification sent when a document is closed.

```typescript
interface DidCloseTextDocumentParams {
  textDocument: TextDocumentIdentifier
}
```

### Language Features

#### `textDocument/hover`

Get hover information for a symbol at a position.

**Request:**
```typescript
interface HoverParams {
  textDocument: TextDocumentIdentifier
  position: Position
}
```

**Response:**
```typescript
interface Hover {
  contents: MarkedString | MarkedString[] | MarkupContent
  range?: Range
}
```

**Example:** Displays type information and JSDoc comments for the symbol at the cursor.

#### `textDocument/definition`

Navigate to the definition of a symbol.

**Request:**
```typescript
interface DefinitionParams {
  textDocument: TextDocumentIdentifier
  position: Position
}
```

**Response:**
```typescript
Location | Location[] | null
```

A `Location` includes the document URI and the range of the symbol definition.

#### `textDocument/typeDefinition`

Navigate to the type definition of a symbol.

**Request:**
```typescript
interface TypeDefinitionParams {
  textDocument: TextDocumentIdentifier
  position: Position
}
```

**Response:**
```typescript
Location | Location[] | null
```

Useful for following type aliases and interfaces.

#### `textDocument/references`

Find all references to a symbol in the workspace.

**Request:**
```typescript
interface ReferenceParams {
  textDocument: TextDocumentIdentifier
  position: Position
  context: ReferenceContext
}

interface ReferenceContext {
  includeDeclaration: boolean
}
```

**Response:**
```typescript
Location[] | null
```

#### `textDocument/documentSymbol`

List all symbols in the current document.

**Request:**
```typescript
interface DocumentSymbolParams {
  textDocument: TextDocumentIdentifier
}
```

**Response:**
```typescript
interface DocumentSymbol {
  name: string
  detail?: string
  kind: SymbolKind
  deprecated?: boolean
  range: Range
  selectionRange: Range
  children?: DocumentSymbol[]
}
```

Symbol kinds include: File, Module, Namespace, Package, Class, Method, Property, Field, Constructor, Enum, Interface, Function, Variable, Constant, String, Number, Boolean, Array, Object, Key, Null, EnumMember, Struct, Event, Operator, TypeParameter.

#### `workspace/symbol`

Search for symbols by name across the workspace.

**Request:**
```typescript
interface WorkspaceSymbolParams {
  query: string
}
```

**Response:**
```typescript
SymbolInformation[] | null
```

#### `textDocument/completion`

Get code completion suggestions at a position.

**Request:**
```typescript
interface CompletionParams {
  textDocument: TextDocumentIdentifier
  position: Position
  context?: CompletionContext
}

interface CompletionContext {
  triggerKind: CompletionTriggerKind
  triggerCharacter?: string
}
```

**Response:**
```typescript
interface CompletionList {
  isIncomplete: boolean
  items: CompletionItem[]
}

interface CompletionItem {
  label: string
  kind?: CompletionItemKind
  detail?: string
  documentation?: string | MarkupContent
  sortText?: string
  filterText?: string
  insertText?: string
  textEdit?: TextEdit
  additionalTextEdits?: TextEdit[]
  command?: Command
}
```

#### `textDocument/signatureHelp`

Get function signature information.

**Request:**
```typescript
interface SignatureHelpParams {
  textDocument: TextDocumentIdentifier
  position: Position
  context?: SignatureHelpContext
}
```

**Response:**
```typescript
interface SignatureHelp {
  signatures: SignatureInformation[]
  activeSignature?: number
  activeParameter?: number
}

interface SignatureInformation {
  label: string
  documentation?: string | MarkupContent
  parameters?: ParameterInformation[]
  activeParameter?: number
}

interface ParameterInformation {
  label: string | [number, number]
  documentation?: string | MarkupContent
}
```

#### `textDocument/rename`

Rename a symbol and get all locations to update.

**Request:**
```typescript
interface RenameParams {
  textDocument: TextDocumentIdentifier
  position: Position
  newName: string
}
```

**Response:**
```typescript
interface WorkspaceEdit {
  changes?: { [uri: string]: TextEdit[] }
  documentChanges?: TextDocumentEdit[]
}

interface TextEdit {
  range: Range
  newText: string
}
```

#### `textDocument/diagnostic`

Get diagnostics (errors, warnings) for a document.

**Request:**
```typescript
interface DocumentDiagnosticParams {
  textDocument: TextDocumentIdentifier
}
```

**Response:**
```typescript
interface Diagnostic {
  range: Range
  severity?: DiagnosticSeverity
  code?: number | string
  source?: string
  message: string
  tags?: DiagnosticTag[]
  relatedInformation?: DiagnosticRelatedInformation[]
}
```

Severity levels: Error (1), Warning (2), Information (3), Hint (4).

### Custom Extensions

#### Files Extension

Request file contents from the client without direct file system access.

**Method:** `x/files`

Useful in cloud environments where files may not be directly accessible.

#### SymbolDescriptor Extension

Get descriptor information for a symbol and find all references.

**Method:** `x/references`

Request:
```typescript
interface SymbolDescriptorRequest {
  textDocument: TextDocumentIdentifier
  position: Position
}
```

Response includes descriptor information and reference locations.

#### Streaming Extension

Receive partial results progressively instead of waiting for complete results.

**Feature:** JSON Patches for progressive result delivery

Example: For large reference searches, results are streamed as they're found rather than batched.

**Method:** Supports `textDocument/references` with streaming

Uses JSON Patch format for incremental updates:
```json
{
  "jsonrpc": "2.0",
  "method": "$/progress",
  "params": {
    "token": "token-value",
    "value": [...]
  }
}
```

#### Packages Extension

Get information about project dependencies.

**Methods:**
- `x/dependencies` - Get all dependencies and their versions
- `x/dependents` - Get packages that depend on a symbol

## Data Types

### Position

```typescript
interface Position {
  line: number      // 0-based line number
  character: number // 0-based character offset
}
```

### Range

```typescript
interface Range {
  start: Position
  end: Position
}
```

### Location

```typescript
interface Location {
  uri: string // Document URI (e.g., "file:///path/to/file.ts")
  range: Range
}
```

### TextDocumentIdentifier

```typescript
interface TextDocumentIdentifier {
  uri: string
}
```

### VersionedTextDocumentIdentifier

```typescript
interface VersionedTextDocumentIdentifier extends TextDocumentIdentifier {
  version: number
}
```

## Error Handling

The server responds to requests with either a result or an error:

```typescript
interface ResponseError {
  code: number
  message: string
  data?: any
}
```

Common error codes:
- `-32700`: Parse error
- `-32600`: Invalid request
- `-32601`: Method not found
- `-32602`: Invalid params
- `-32603`: Internal error
- `-32000 to -32099`: Server error range

## Initialization Parameters

### Initialize Request

**Method:** `initialize`

**Request:**
```typescript
interface InitializeParams {
  processId: number | null
  rootPath?: string | null
  rootUri: string | null
  initializationOptions?: any
  capabilities: ClientCapabilities
  trace?: TraceValue
  workspaceFolders?: WorkspaceFolder[] | null
}
```

**Response:**
```typescript
interface InitializeResult {
  capabilities: ServerCapabilities
  serverInfo?: ServerInfo
}

interface ServerCapabilities {
  textDocumentSync?: TextDocumentSyncOptions | TextDocumentSyncKind
  hoverProvider?: boolean | HoverOptions
  completionProvider?: CompletionOptions
  signatureHelpProvider?: SignatureHelpOptions
  definitionProvider?: boolean | DefinitionOptions
  typeDefinitionProvider?: boolean | TypeDefinitionOptions
  implementationProvider?: boolean | ImplementationOptions
  referencesProvider?: boolean | ReferenceOptions
  documentHighlightProvider?: boolean | DocumentHighlightOptions
  documentSymbolProvider?: boolean | DocumentSymbolOptions
  workspaceSymbolProvider?: boolean | WorkspaceSymbolOptions
  codeActionProvider?: boolean | CodeActionOptions
  codeLensProvider?: CodeLensOptions
  documentFormattingProvider?: boolean | DocumentFormattingOptions
  documentRangeFormattingProvider?: boolean | DocumentRangeFormattingOptions
  documentOnTypeFormattingProvider?: DocumentOnTypeFormattingOptions
  renameProvider?: boolean | RenameOptions
  foldingRangeProvider?: boolean | FoldingRangeOptions
  executeCommandProvider?: ExecuteCommandOptions
  selectionRangeProvider?: boolean | SelectionRangeOptions
  linkedEditingRangeProvider?: boolean | LinkedEditingRangeOptions
  workspace?: WorkspaceServerCapabilities
}
```

## Notifications

### Client-to-Server Notifications

- `textDocument/didOpen` - Document opened
- `textDocument/didChange` - Document changed
- `textDocument/didClose` - Document closed
- `textDocument/didSave` - Document saved (if supported)
- `workspace/didChangeConfiguration` - Configuration changed
- `workspace/didChangeWorkspaceFolders` - Workspace folders changed

### Server-to-Client Notifications

- `textDocument/publishDiagnostics` - Push diagnostics to client
- `$/progress` - Progress updates for long-running operations
- `$/logTrace` - Logging information

## OpenTracing Integration

When Jaeger is enabled, the server creates spans for all major operations:

```typescript
interface SpanContext {
  traceId: string
  spanId: string
  flags: number
  // ... additional fields
}
```

Pass span context through the `meta` field of requests for distributed tracing:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "textDocument/hover",
  "params": { ... },
  "meta": {
    "traceId": "...",
    "spanId": "..."
  }
}
```

View traces at http://localhost:16686 (when running with `--enable-jaeger`).

## Performance Characteristics

### Typical Response Times

- **Hover**: 0-50ms (local cache) to 100-500ms (new analysis)
- **Definition**: 50-200ms
- **References**: 100-500ms per 100 references
- **Completion**: 50-300ms
- **Rename**: 200-1000ms (depends on number of references)

### Memory Usage

- **Base**: ~100MB
- **Per 10 files**: ~5-10MB
- **Large projects (>1000 files)**: 500MB-1GB+

Adjust with `node --max-old-space-size=4096`.

## Completion Item Kinds

- Text (1)
- Method (2)
- Function (3)
- Constructor (4)
- Field (5)
- Variable (6)
- Class (7)
- Interface (8)
- Module (9)
- Property (10)
- Unit (11)
- Value (12)
- Enum (13)
- Keyword (14)
- Snippet (15)
- Color (16)
- File (17)
- Reference (18)
- Folder (19)
- EnumMember (20)
- Constant (21)
- Struct (22)
- Event (23)
- Operator (24)
- TypeParameter (25)

---

# Development Guide

Source: https://github.com/sourcegraph/javascript-typescript-langserver

Guide for developing and contributing to the JavaScript/TypeScript Language Server.

## Development Setup

### Prerequisites

- Node.js >= 6.0.0
- npm (comes with Node.js)
- Git
- A code editor or IDE

### Initial Setup

```bash
# Clone the repository
git clone https://github.com/sourcegraph/javascript-typescript-langserver.git
cd javascript-typescript-langserver

# Install dependencies
npm install

# Verify installation
npm run build
```

## Project Structure

```
javascript-typescript-langserver/
├── src/                      # TypeScript source code
│   ├── language-server.ts   # Main server entry point
│   ├── typescript-service.ts # TypeScript API wrapper
│   ├── lsp/                 # LSP protocol implementation
│   └── test/                # Test files
├── lib/                      # Compiled JavaScript (generated)
├── package.json              # Project metadata and scripts
├── tsconfig.json             # TypeScript configuration
├── tslint.json               # Linting rules
├── README.md                 # Project documentation
└── CONTRIBUTING.md           # Contribution guidelines
```

## Build and Compilation

### Development Build

For a single compilation pass:

```bash
npm run build
```

This compiles TypeScript source files in `src/` to JavaScript in `lib/`.

### Watch Mode

For continuous compilation during development:

```bash
npm run watch
```

The build will automatically recompile whenever source files change. This is the recommended setup for active development.

### Clean Build

Remove compiled files and rebuild from scratch:

```bash
npm run clean
npm run build
```

## Running Tests

### Run All Tests

```bash
npm test
```

This runs all test files matching the pattern `lib/test/**/*.js`.

Test configuration:
- Timeout: 7000ms per test
- Slow threshold: 2000ms (tests slower than this are marked as slow)

### Run Specific Tests

```bash
# Run tests in a specific file
npm test -- lib/test/hover.test.js

# Run tests matching a pattern
npm test -- lib/test/completion*.js
```

### Test Coverage

Generate coverage report:

```bash
npm run cover
```

This creates a coverage report showing what percentage of code is tested.

## Code Quality

### Linting

The project uses TSLint for code quality checks:

```bash
npm run lint
```

This runs both TSLint and Prettier checks.

### TypeScript Linting

```bash
npm run tslint
```

TSLint configuration is in `tslint.json`. Common rules checked:
- No unused variables
- No console statements (should use logging)
- Proper semicolon usage
- Consistent naming conventions

### Code Formatting

The project uses Prettier for consistent code formatting:

```bash
npm run prettier
```

This will:
- Check which files don't match the format
- With `--write` flag (if configured), it can auto-fix formatting

Format configuration:
- 2-space indentation
- Single quotes
- Trailing commas

## Debugging

### Enable Trace Logging

Run the server with the `--trace` flag to see all requests and responses:

```bash
node lib/language-server --trace
```

Output will include:
- All incoming LSP requests
- All outgoing responses
- Diagnostic messages

### File Logging

Log to a file for easier analysis:

```bash
node lib/language-server --logfile debug.log
```

### OpenTracing with Jaeger

For performance profiling:

1. Start Jaeger locally:
```bash
docker run -d -p5775:5775/udp -p6831:6831/udp -p6832:6832/udp \
  -p5778:5778 -p16686:16686 -p14268:14268 jaegertracing/all-in-one:latest
```

2. Run server with Jaeger enabled:
```bash
node lib/language-server --enable-jaeger
```

3. Open http://localhost:16686 to view traces

Jaeger shows:
- Operation spans with timing
- Nested operation hierarchy
- Performance bottlenecks

### Debug Console Output

The server sends JSON-RPC messages to stdout. To analyze requests:

```bash
node lib/language-server 2>debug.log | jq .
```

(Requires `jq` for JSON formatting)

## Making Changes

### 1. Create a Feature Branch

```bash
git checkout -b feature/your-feature-name
```

Branch naming conventions:
- `feature/` for new features
- `fix/` for bug fixes
- `docs/` for documentation
- `test/` for test additions

### 2. Make Your Changes

Edit TypeScript files in the `src/` directory. Watch mode will automatically recompile:

```bash
npm run watch
```

### 3. Test Your Changes

```bash
npm test
npm run lint
```

All tests must pass and code must pass linting before creating a PR.

### 4. Commit with Proper Format

Commit messages should follow this format:

```
<subsystem>: <what changed>

<why this change was made>

Fixes #<issue-number>
```

Example:

```
hover: add support for const assertions

When hovering over a const assertion, display the literal type
rather than the inferred type to match TypeScript behavior.

Fixes #123
```

### 5. Push and Create a Pull Request

```bash
git push origin feature/your-feature-name
```

Then create a PR on GitHub with a clear description of your changes.

## Subsystem Guide

Common subsystems for commit messages:

- `hover` - Hover information display
- `definition` - Go to definition implementation
- `completion` - Code completion features
- `diagnostics` - Error and warning reporting
- `rename` - Symbol renaming
- `references` - Find references
- `symbols` - Symbol listing and search
- `lsp` - Core LSP protocol
- `typescript` - TypeScript integration
- `test` - Test additions or fixes
- `docs` - Documentation
- `ci` - Continuous integration
- `build` - Build system changes

## Common Development Tasks

### Adding a New LSP Feature

1. Implement handler in `src/lsp/`
2. Add tests in `src/test/`
3. Update capabilities in server initialization
4. Document in API_REFERENCE.md

Example: Adding `textDocument/implementation`

```typescript
// src/lsp/implementation.ts
export function handleImplementation(
  params: ImplementationParams,
  ts: TypeScriptService
): Location[] | null {
  // Implementation code
}
```

### Adding a Test

```typescript
// src/test/implementation.test.ts
import * as assert from 'assert'
import { createTestServer } from './helper'

describe('Implementation', () => {
  it('should find implementations of interface', async () => {
    const { server, files } = await createTestServer()

    const locations = await server.implementation({
      textDocument: { uri: files.interface },
      position: { line: 0, character: 0 }
    })

    assert.ok(locations)
    assert.equal(locations.length, 1)
  })
})
```

### Updating TypeScript Support

The server includes a bundled TypeScript version in `package.json`. To update:

1. Update the TypeScript version in `package.json`
2. Run `npm install`
3. Run `npm test` to ensure compatibility
4. Commit with message like: `build: update TypeScript to 5.0.0`

## Git Workflow

### Fork and Clone

```bash
# Fork on GitHub, then clone your fork
git clone https://github.com/your-username/javascript-typescript-langserver.git
cd javascript-typescript-langserver

# Add upstream remote
git remote add upstream https://github.com/sourcegraph/javascript-typescript-langserver.git
```

### Keep Your Fork Updated

```bash
# Fetch latest changes
git fetch upstream

# Rebase your branch
git rebase upstream/master
```

### Sync Before Submitting PR

```bash
git fetch upstream
git rebase upstream/master
git push origin feature/your-feature-name --force-with-lease
```

## Contributing Guidelines

### Before Starting

1. Check for existing issues/PRs
2. Create an issue for new features (unless it's a bug fix)
3. Discuss major changes in the issue first

### Code Quality Standards

- All tests must pass: `npm test`
- Code must pass linting: `npm run lint`
- Code must be formatted with Prettier: `npm run prettier`
- New features should include tests
- Documentation should be updated

### PR Review Process

1. Automated tests must pass
2. Code review by maintainers
3. Approval and merge

### Commit Message Guidelines

See the format specification in CONTRIBUTING.md:

```
<subsystem>: <what changed>

<why this change was made>

Fixes #<issue>
```

No commits over 70 characters on first line.

## Certificate of Origin

By contributing, you agree to the Developer Certificate of Origin (DCO):

```
Developer Certificate of Origin
Version 1.1

Copyright (C) 2004, 2006 The Linux Foundation and its
contributors. 1 Letterman Drive Suite D4700, San Francisco, CA,
94129

Everyone is permitted to copy and distribute verbatim copies of
this license document, but changing it is not allowed.

Developer's Certificate of Origin 1.1

By making a contribution to this project, I certify that:

(a) The contribution was created in whole or in part by me and I
    have the right to submit it under the open source license
    indicated in the file; or

(b) The contribution is based upon previous work that, to the
    extent I can control it, is subject to the same open source
    license as the previous work, or a lesser license as set out
    in the file (as I should be known).
```

Your commits will be checked for DCO compliance.

## Resources

- **Language Server Protocol Spec**: https://microsoft.github.io/language-server-protocol/
- **TypeScript Handbook**: https://www.typescriptlang.org/docs/
- **TSLint Documentation**: https://palantir.github.io/tslint/
- **Prettier Documentation**: https://prettier.io/docs/
- **GitHub Repository**: https://github.com/sourcegraph/javascript-typescript-langserver

## Troubleshooting

### Tests Timeout

If tests timeout (>7000ms):
- Check for async operations not awaited
- Look for infinite loops or dead code
- Use `--reporter tap` for more verbose output

### Module Resolution Issues

If you see module not found errors:
```bash
npm install
npm run build
```

### Memory Issues During Build

For large builds on low-memory systems:
```bash
node --max-old-space-size=2048 node_modules/.bin/tsc
```

### TypeScript Compilation Errors

Check TypeScript configuration:
```bash
cat tsconfig.json
npm list typescript
```

Update if needed:
```bash
npm update typescript
```

---

# Installation and Setup Guide

Source: https://github.com/sourcegraph/javascript-typescript-langserver

## Installation Methods

### npm Global Installation

Install the language server globally to use with multiple projects:

```bash
npm install -g javascript-typescript-langserver
```

Then run:

```bash
language-server
```

### npm Project Installation

Install as a local development dependency:

```bash
npm install --save-dev javascript-typescript-langserver
```

Add to your `package.json` scripts:

```json
{
  "scripts": {
    "lsp": "node node_modules/.bin/language-server"
  }
}
```

Then run:

```bash
npm run lsp
```

### From Source

Clone and build from the GitHub repository:

```bash
git clone https://github.com/sourcegraph/javascript-typescript-langserver.git
cd javascript-typescript-langserver
npm install
npm run build
node lib/language-server
```

## Requirements

- **Node.js**: >= 6.0.0
- **npm**: any recent version
- **Disk space**: ~200MB for dependencies and build artifacts

## Build from Source

### Prerequisites

- Git
- Node.js >= 6.0.0
- npm or yarn

### Build Steps

```bash
# Clone the repository
git clone https://github.com/sourcegraph/javascript-typescript-langserver.git
cd javascript-typescript-langserver

# Install dependencies
npm install

# Compile TypeScript to JavaScript
npm run build

# Verify the build
ls -la lib/
```

### Watch Mode (for Development)

For continuous compilation during development:

```bash
npm run watch
```

This will recompile on any changes to source files.

## Running the Server

### STDIO Mode

The most common way to run the server is over standard input/output (STDIO):

```bash
language-server
```

or from source:

```bash
node lib/language-server-stdio
```

The server will:
1. Read LSP messages from stdin
2. Process requests
3. Write responses to stdout
4. Write diagnostics and notifications as JSON-RPC messages

### TCP Mode

For networking scenarios, run the server on a TCP port:

```bash
language-server --port 2089
```

or from source:

```bash
node lib/language-server --port 2089
```

The server will listen on `localhost:2089` for TCP connections from LSP clients.

### Custom Port

Specify a different port:

```bash
language-server --port 3000
```

## Configuration

### Command Line Options

```
Options:
  -h, --help            Show help information
  -V, --version         Show version number
  -s, --strict          Enable strict mode type checking
  -p, --port [port]     TCP port to use (default: 2089)
  -c, --cluster [num]   Number of concurrent worker processes
                        (default: number of CPU cores)
  -t, --trace           Print all requests and responses
  -l, --logfile [file]  Log output to file
  -j, --enable-jaeger   Enable OpenTracing with Jaeger
```

### Examples

#### Enable Strict Mode

```bash
language-server --strict
```

#### Run on Port 3000 with Logging

```bash
language-server --port 3000 --logfile lsp.log
```

#### Use 4 Worker Processes

```bash
language-server --cluster 4
```

#### Enable Jaeger Tracing and TCP on Port 4000

```bash
language-server --port 4000 --enable-jaeger
```

#### Print All Requests and Responses

```bash
language-server --trace
```

## Integration with Editors

### Visual Studio Code

Install the `vscode-javascript-typescript` extension:

```bash
code --install-extension sourcegraph.vscode-javascript-typescript
```

Or install manually from the VS Code Marketplace.

### NeoVim

Use `LanguageClient-neovim` plugin:

```vim
" Install with vim-plug
Plug 'autozimu/LanguageClient-neovim', {
    \ 'branch': 'next',
    \ 'do': 'bash install.sh',
    \ }

" Configure for this language server
let g:LanguageClient_serverCommands = {
    \ 'javascript': ['language-server'],
    \ 'typescript': ['language-server'],
    \ }
```

### Sublime Text

Install via Package Control with the `LSP` package:

1. Install `LSP` package via Package Control
2. Configure clients in LSP settings:

```json
{
  "clients": {
    "js-ts": {
      "command": ["language-server"],
      "languages": [
        {"languageId": "javascript", "scopes": ["source.js"], "syntaxes": ["Packages/JavaScript/JavaScript.sublime-syntax"]},
        {"languageId": "typescript", "scopes": ["source.ts"], "syntaxes": ["Packages/TypeScript/TypeScript.sublime-syntax"]}
      ]
    }
  }
}
```

### Vim/Neovim with coc.nvim

Install coc-tsserver or configure with a custom LSP client:

```vim
:CocConfig
```

Add to coc-settings.json:

```json
{
  "languageserver": {
    "javascript-typescript": {
      "command": "language-server",
      "filetypes": ["javascript", "typescript", "jsx", "tsx"],
      "initializationOptions": {},
      "settings": {}
    }
  }
}
```

## Troubleshooting Installation

### Command Not Found

If `language-server` is not found after global installation:

```bash
# Check npm global installation directory
npm config get prefix

# Add to PATH if needed
export PATH="$(npm config get prefix)/bin:$PATH"
```

### Permission Errors on macOS/Linux

If you get permission errors during installation:

```bash
# Use npm with sudo (not recommended)
sudo npm install -g javascript-typescript-langserver

# Or fix npm permissions (recommended)
# See https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally
```

### TypeScript Version Conflicts

The language server includes its own bundled TypeScript version. If you have conflicts with local TypeScript:

- Ensure your project's TypeScript version is compatible
- Consider using the local `node_modules` TypeScript if available
- Check for version mismatches in `package.json`

### Build Errors on Windows

If you encounter build errors on Windows:

1. Ensure you have Visual C++ build tools installed
2. Install node-gyp globally: `npm install -g node-gyp`
3. Try rebuilding: `npm rebuild`

### Memory Issues

For large projects, increase Node.js memory:

```bash
node --max-old-space-size=4096 lib/language-server
```

## Verifying Installation

After installation, verify the server works:

```bash
# Check version
language-server --version

# Start the server
language-server --port 2089 &

# Test with a simple request (requires a JSON-RPC client)
# In another terminal, you can test connectivity:
nc localhost 2089
```

## Development Setup

For contributing to the project:

```bash
# Clone the repository
git clone https://github.com/sourcegraph/javascript-typescript-langserver.git
cd javascript-typescript-langserver

# Install dependencies
npm install

# Run tests
npm test

# Run linters
npm run lint

# Watch for changes during development
npm run watch

# Build for distribution
npm run build
```

## Next Steps

- Read the [README.md](README.md) for features and API documentation
- Check [CONTRIBUTING.md](CONTRIBUTING.md) for development guidelines
- Review the Language Server Protocol specification: https://microsoft.github.io/language-server-protocol/