Provided by: node-typescript_4.9.5+ds1-2_all 
NAME
tsserver - TypeScript standalone server
The TypeScript standalone server (aka tsserver) is a node executable that encapsulates the TypeScript
compiler and language services, and exposes them through a JSON protocol. tsserver is well suited for
editors and IDE support.
October 2023 TSSERVER(1)
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────
NAME
Protocol
Definition
The server communication protocol is defined in the ts.server.protocol namespace, declared in
`tsserverlibrary.d.ts`.
The executable can be found in lib folder under the typescript package.
npm install --save typescript
ls node_modules\typescript\lib\tsserver.js
Message format
tsserver listens on stdin and writes messages back to stdout.
Requests are JSON following the protocol definition. Here is an example request to open a file
c:/DefinitelyTyped/gregorian-calendar/index.d.ts:
{"seq":1,"type":"request","command":"open","arguments":{"file":"c:/DefinitelyTyped/gregorian-calendar/index.d.ts"}}
Responses are augmented JSON format. The Message starts with a header with the content length followed by
a line separator (\r\n) followed by the response body as a JSON string:
Here is an example of a response for a quickinfo command:
Content-Length: 116
{"seq":0,"type":"response","command":"quickinfo","request_seq":2,"success":false,"message":"No content available."}
Similarly events have the same format as a response.
Here is an example event for error message:
Content-Length: 261
{"seq":0,"type":"event","event":"semanticDiag","body":{"file":"c:/DefinitelyTyped/gregorian-calendar/index.d.ts","diagnostics":[{"start":{"line":264,"offset":44},"end":{"line":264,"offset":50},"text":"Binding element 'Object'
implicitly has an 'any' type."}]}}
Commands
tsserver supports a set of commands. The full list of commands supported by the server can be found under
ts.server.protocol.CommandTypes.
Each command is associated with a request and a response interface. For instance command "completions"
corresponds to request interface CompletionsRequest, and response interface defined in
CompletionsResponse.
October 2023 TSSERVER(1)
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────
NAME
Sample implementations
Sublime text plugin
TypeScript-Sublime-Plugin is a Sublime text plugin written in Python that uses tsserver.
Visual Studio Code
VS Code' s TypeScript support is implemented in TypeScript using tsserver.
Tide
Tide is an elisp implementation for emacs plugin using tsserver
Neovim
nvim-typescript is a neovim plugin using tsserver
October 2023 TSSERVER(1)
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────
NAME
Advanced topics
Logging
tsserver logging is configured through the TSS_LOG environment variable.
TSS_LOG can have the following format:
[-level <terse | normal | requestTime | verbose>]
[-traceToConsole <true | false>]
[-logToFile <true | false>]
[-file <log file path>]
Note: file defaults to __dirname\.log<PID> if not specified
Example: set TSS_LOG=-level verbose -file c:\tmp\tsserver.log
Cancellation
tsserver on startup will try to load module ./cancellationToken from the containing directory. This
module should export a factory function that accepts a list of command line arguments and returns
HostCancellationToken. tsserver will use this token to check if in-flight operation should be cancelled.
NOTE: This token will be used for all operations so if one operation is cancelled and cancellation was
reported through the token then when another operation is started - token should be reset into the
non-cancelled state.
Default implementation of the cancellation token uses the presence of named pipes as a way to signal
cancellation.
• Before spawning the server, the client generates a unique name. This name is passed to the server as a
cancellationPipeName command line argument.
• If some operation on the client side should be cancelled - client opens a named pipe with a name
generated on step 1. Nothing needs to be written in the pipe - default cancellation token will
interpret the presence of named pipe as a cancellation request.
• After receiving acknowledgment from the server, the client closes the pipe so it can use the same pipe
name for the next operation.
Server can split execution of some commands (like geterr) in a few steps that will be executed with a
delay. This allows it to react on user actions more promptly and not run heavy computations if their
results will not be used. However, it introduces a tricky moment in support of cancellations. By allowing
request to be suspended and resumed later we break the invariant that was the cornerstone for default
implementation of cancellation. Namely now requests can overlap so one pipe name can no longer be used
because client have no reason what request is currently executing and will be cancelled. To deal with
this issue tsserver allows pipe name to be computed dynamically based on current request id. To enable
this the client need to provide a value that ends with * as the --cancellationPipeName argument. If
provided cancellation pipe name ends with * then default implementation of cancellation token will build
expected pipe name as <cancellationPipeName argument without *><currentRequestId>. This will allow client
to signal any request it thinks is in flight by creating a named pipe with a proper name. Note that
server will always send requestCompleted message to denote that asynchronous request was completed
(either by running to completion or via cancellation) so the client can close named pipe once this
message is received.
Commandline options
--cancellationPipeName
Name of the pipe used as a request cancellation semaphore. See Cancellation for more information.
--syntaxOnly
A streamlined mode for when the server will only be answering syntactic queries.
--suppressDiagnosticEvents
Opt out of receiving events when new diagnostics are discovered (i.e. must request them explicitly).
--eventPort
Port used for receiving events. If non is specified events are sent to stdout.
--useSingleInferredProject
Put all open .ts and .js files that do not have a .tsconfig file in a common project
--noGetErrOnBackgroundUpdate
Opt out of starting getErr on projectsUpdatedInBackground event
--locale
The locale to use to show error messages, e.g. en-us.
Possible values are: English (US): en, Czech: cs, German: de, Spanish: es, French: fr, Italian: it, Japanese: ja, Korean: ko, Polish: pl,
Portuguese(Brazil): pt-BR, Russian: ru, Turkish: tr, Simplified Chinese: zh-CN, Traditional Chinese: zh-TW
October 2023 TSSERVER(1)
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────
NAME
Project System
There are three kinds of projects:
Configured Project
Configured projects are defined by a configuration file, which can be either tsconfig.json file or a
jTshconfig.jsonieccompileraoptionsdtoibesusedtforlthisoproject..
tsconfig.jsonmdocumentation.n in the
External Project
Theehostnis responsiblerfornsupplyingptheflistrofefilesrintthisaproject and compiler.options to use.
Currently VS is the only consumer of this type of project, to model the TS/JS files in a .csproj project.
Inferred Project
Iffarfilepdoescnotahavehatconfigurationefilee(tsconfig.jsonJorfjsconfig.json) in the current directory or
any parent directories, the server will create an inferred project for it.
The server will include the loose file, then includes all other files included by triple slash references
and module imports from the original file transitively.
Thephosticanosetothewdefaultstof anfinferrediproject.inferred projects.
Relationship Among These Projects
In general, the relationship can be summarized as configured projects > external projects > inferred
projects.
For example, if file1.ts belongs to an inferred project, but later a new tsconfig.json also includes this
Then. after the tsconfig.json file is found, file1.ts will no longer belong to the previous inferred
Ifofile1.ts usedntolbecthetrootofileurof ptheecinferredd.project, that inferred project will now be
destroyed; otherwise it will remain with one fewer file.
For another example, if a tsconfig.json file is created to include some files used to belong to an
external project (let's call it EP1), then in the current implementation EP1 will be destroyed, all its
files either go to the new configured project or will belong to a new inferred project the next time it
is opened.
One thing to notice is that one file can belong to multiple projects of the same kind at the same time.
E.g., a file can be included by multiple configured projects / inferred projects / external projects.
October 2023 TSSERVER(1)