let displayValue: string

if (property.hasChildren || property.type === 'array' || property.type === 'object') {

if (property.type === 'array') {

// for arrays, show the length, like a var_dump would do

displayValue = `array(${property.hasChildren ? property.numberOfChildren : 0})`

} else if (property.type === 'object' && property.class) {

// for objects, show the class name as type (if specified)

displayValue = property.class

} else {

// edge case: show the type of the property as the value

displayValue = property.type

}

} else {

// for null, uninitialized, resource, etc. show the type

displayValue = property.value || property.type === 'string' ? property.value : property.type

if (property.type === 'string') {

displayValue = `"${displayValue}"`

} else if (property.type === 'bool') {

displayValue = Boolean(parseInt(displayValue, 10)).toString()

}

}

return displayValue

/** Name of the configuration */

name?: string

/** The address to bind to for listening for Xdebug connections (default: all IPv6 connections if available, else all IPv4 connections) or unix socket */

hostname?: string

/** The port where the adapter should listen for Xdebug connections (default: 9003) */

port?: number

/** Automatically stop target after launch. If not specified, target does not stop. */

stopOnEntry?: boolean

/** The source root on the server when doing remote debugging on a different host */

serverSourceRoot?: string

/** The path to the source root on this machine that is the equivalent to the serverSourceRoot on the server. */

localSourceRoot?: string

/** The path to the source root on this machine that is the equivalent to the serverSourceRoot on the server. */

pathMappings?: { [index: string]: string }

/** If true, will log all communication between VS Code and the adapter to the console */

log?: boolean

/** Array of glob patterns that errors should be ignored from */

ignore?: string[]

/** Array of glob patterns that exceptions should be ignored from */

ignoreExceptions?: string[]

/** Array of glob patterns that debugger should not step in */

skipFiles?: string[]

/** Xdebug configuration */

xdebugSettings?: { [featureName: string]: string | number }

/** proxy connection configuration */

proxy?: {

allowMultipleSessions: boolean

enable: boolean

host: string

key: string

port: number

timeout: number

}

/** Maximum allowed parallel debugging sessions */

maxConnections?: number

/** Xdebug cloud token */

xdebugCloudToken?: string

// CLI options

/** If set, launches the specified PHP script in CLI mode */

program?: string

/** Optional arguments passed to the debuggee. */

args?: string[]

/** Launch the debuggee in this working directory (specified as an absolute path). If omitted the debuggee is launched in its own directory. */

cwd?: string

/** Absolute path to the runtime executable to be used. Default is the runtime executable on the PATH. */

runtimeExecutable?: string

/** Optional arguments passed to the runtime executable. */

runtimeArgs?: string[]

/** Optional environment variables to pass to the debuggee. The string valued properties of the 'environmentVariables' are used as key/value pairs. */

env?: { [key: string]: string }

/** Absolute path to a file containing environment variable definitions. */

envFile?: string

/** If true launch the target in an external console. */

externalConsole?: boolean

/** The arguments that were given to launchRequest */

private _args: LaunchRequestArguments

/** The TCP server that listens for Xdebug connections */

private _server: net.Server

/** The child process of the launched PHP script, if launched by the debug adapter */

private _phpProcess?: childProcess.ChildProcess

/**

private _connections = new Map<number, xdebug.Connection>()

/** A counter for unique source IDs */

private _sourceIdCounter = 1

/** A map of VS Code source IDs to Xdebug file URLs for virtual files (dpgp://whatever) and the corresponding connection */

private _sources = new Map<number, { connection: xdebug.Connection; url: string }>()

/** A counter for unique stackframe IDs */

private _stackFrameIdCounter = 1

/** A map from unique stackframe IDs (even across connections) to Xdebug stackframes */

private _stackFrames = new Map<number, xdebug.StackFrame>()

/** A map from Xdebug connections to their current status */

private _statuses = new Map<xdebug.Connection, xdebug.StatusResponse>()

/** A counter for unique context, property and eval result properties (as these are all requested by a VariableRequest from VS Code) */

private _variableIdCounter = 1

/** A map from unique VS Code variable IDs to Xdebug statuses for virtual error stack frames */

private _errorStackFrames = new Map<number, xdebug.StatusResponse>()

/** A map from unique VS Code variable IDs to Xdebug statuses for virtual error scopes */

private _errorScopes = new Map<number, xdebug.StatusResponse>()

/** A map from unique VS Code variable IDs to an Xdebug contexts */

private _contexts = new Map<number, xdebug.Context>()

/** A map from unique VS Code variable IDs to a Xdebug properties */

private _properties = new Map<number, xdebug.Property>()

/** A map from unique VS Code variable IDs to Xdebug eval result properties, because property children returned from eval commands are always inlined */

private _evalResultProperties = new Map<number, xdebug.EvalResultProperty>()

/** A flag to indicate that the adapter has already processed the stopOnEntry step request */

private _hasStoppedOnEntry = false

/** A map from Xdebug connection id to state of skipping files */

private _skippingFiles = new Map<number, boolean>()

/** Breakpoint Manager to map VS Code to Xdebug breakpoints */

private _breakpointManager = new BreakpointManager()

/** Breakpoint Adapters */

private _breakpointAdapters = new Map<xdebug.Connection, BreakpointAdapter>()

/**

private _logPointManager = new LogPointManager()

/** The proxy initialization and termination connection. */

private _proxyConnect: ProxyConnect

/** Optional cloud connection */

private _xdebugCloudConnection: XdebugCloudConnection

/** the promise that gets resolved once we receive the done request */

private _donePromise: Promise<void>

/** resolves the done promise */

private _donePromiseResolveFn: () => void

constructor() {

super()

this.setDebuggerColumnsStartAt1(true)

this.setDebuggerLinesStartAt1(true)

this.setDebuggerPathFormat('uri')

}

protected initializeRequest(

response: VSCodeDebugProtocol.InitializeResponse,

args: VSCodeDebugProtocol.InitializeRequestArguments

): void {

response.body = {

supportsConfigurationDoneRequest: true,

supportsEvaluateForHovers: true,

supportsConditionalBreakpoints: true,

supportsFunctionBreakpoints: true,

supportsLogPoints: true,

supportsHitConditionalBreakpoints: true,

supportsSetVariable: true,

exceptionBreakpointFilters: [

{

filter: 'Notice',

label: 'Notices',

},

{

filter: 'Warning',

label: 'Warnings',

},

{

filter: 'Error',

label: 'Errors',

},

{

filter: 'Exception',

label: 'Exceptions',

},

{

filter: '*',

label: 'Everything',

},

],

supportTerminateDebuggee: true,

supportsDelayedStackTraceLoading: false,

}

this.sendResponse(response)

}

protected attachRequest(

response: VSCodeDebugProtocol.AttachResponse,

args: VSCodeDebugProtocol.AttachRequestArguments

): void {

this.sendErrorResponse(response, new Error('Attach requests are not supported'))

this.shutdown()

}

protected async launchRequest(

response: VSCodeDebugProtocol.LaunchResponse,

args: LaunchRequestArguments

): Promise<void> {

if (args.localSourceRoot && args.serverSourceRoot) {

let pathMappings: { [index: string]: string } = {}

if (args.pathMappings) {

pathMappings = args.pathMappings

}

pathMappings[args.serverSourceRoot] = args.localSourceRoot

args.pathMappings = pathMappings

}

this._args = args

this._donePromise = new Promise<void>((resolve, reject) => {

this._donePromiseResolveFn = resolve

})

/** launches the script as CLI */

const launchScript = async (port: number | string): Promise<void> => {

// check if program exists

if (args.program) {

await new Promise<void>((resolve, reject) =>

fs.access(args.program!, fs.constants.F_OK, err => (err ? reject(err) : resolve()))

)

}

const runtimeArgs = (args.runtimeArgs || []).map(v => v.replace('${port}', port.toString()))

const runtimeExecutable = args.runtimeExecutable || 'php'

const programArgs = args.args || []

const program = args.program ? [args.program] : []

const cwd = args.cwd || process.cwd()

const env = Object.fromEntries(

Object.entries({ ...process.env, ...getConfiguredEnvironment(args) }).map(v => [

v[0],

v[1]?.replace('${port}', port.toString()),

])

)

// launch in CLI mode

if (args.externalConsole) {

const script = await Terminal.launchInTerminal(

cwd,

[runtimeExecutable, ...runtimeArgs, ...program, ...programArgs],

env

)

if (script) {

// we only do this for CLI mode. In normal listen mode, only a thread exited event is send.

script.on('exit', (code: number | null) => {

this.sendEvent(new vscode.ExitedEvent(code ?? 0))

this.sendEvent(new vscode.TerminatedEvent())

})

}

} else {

const script = childProcess.spawn(runtimeExecutable, [...runtimeArgs, ...program, ...programArgs], {

cwd,

env,

})

// redirect output to debug console

script.stdout.on('data', (data: Buffer) => {

this.sendEvent(new vscode.OutputEvent(data.toString(), 'stdout'))

})

script.stderr.on('data', (data: Buffer) => {

this.sendEvent(new vscode.OutputEvent(data.toString(), 'stderr'))

})

// we only do this for CLI mode. In normal listen mode, only a thread exited event is send.

script.on('exit', (code: number | null) => {

this.sendEvent(new vscode.ExitedEvent(code ?? 0))

this.sendEvent(new vscode.TerminatedEvent())

})

script.on('error', (error: Error) => {

this.sendEvent(new vscode.OutputEvent(util.inspect(error) + '\n'))

})

this._phpProcess = script

}

}

/** sets up a TCP server to listen for Xdebug connections */

const createServer = (): Promise<number | string> =>

new Promise<number | string>((resolve, reject) => {

const server = (this._server = net.createServer())

// eslint-disable-next-line @typescript-eslint/no-misused-promises

server.on('connection', async (socket: net.Socket) => {

try {

// new Xdebug connection

// first check if we have a limit on connections

if (args.maxConnections ?? 0 > 0) {

if (this._connections.size >= args.maxConnections!) {

if (args.log) {

this.sendEvent(

new vscode.OutputEvent(

`new connection from ${

),

true

)

}

socket.end()

return

}

}

const connection = new xdebug.Connection(socket)

if (this._args.log) {

this.sendEvent(

new vscode.OutputEvent(

`new connection ${connection.id} from ${socket.remoteAddress || 'unknown'}\n`

),

true

)

}

this.setupConnection(connection)

try {

await this.initializeConnection(connection)

} catch (error) {

this.sendEvent(

new vscode.OutputEvent(

`Failed initializing connection ${connection.id}: ${

'stderr'

)

)

this.disposeConnection(connection)

socket.destroy()

}

} catch (error) {

this.sendEvent(

new vscode.OutputEvent(

`Error in socket server: ${

'stderr'

)

)

this.shutdown()

}

})

server.on('error', (error: Error) => {

this.sendEvent(new vscode.OutputEvent(util.inspect(error) + '\n'))

reject(error)

})

server.on('listening', () => {

if (args.log) {

this.sendEvent(new vscode.OutputEvent(`Listening on ${util.inspect(server.address())}\n`), true)

}

if (typeof server.address() === 'string') {

resolve(<string>server.address())

} else {

const port = (server.address() as net.AddressInfo).port

resolve(port)

}

})

if (

args.port !== undefined &&

(args.hostname?.toLowerCase()?.startsWith('unix://') === true ||

args.hostname?.startsWith('\\\\') === true)

) {

throw new Error('Cannot have port and socketPath set at the same time')

}

if (args.hostname?.toLowerCase()?.startsWith('unix://') === true) {

server.listen(args.hostname.substring(7))

} else if (args.hostname?.startsWith('\\\\') === true) {

server.listen(args.hostname)

} else {

const listenPort = args.port === undefined ? 9003 : args.port

server.listen(listenPort, args.hostname)

}

})

try {

// Some checks

if (

args.env &&

Object.keys(args.env).length !== 0 &&

args.program === undefined &&

args.runtimeArgs === undefined

) {

throw new Error(

`Cannot set env without running a program.\nPlease remove env from [${

)

}

if (

(args.hostname?.toLowerCase()?.startsWith('unix://') === true ||

args.hostname?.startsWith('\\\\') === true) &&

args.proxy?.enable === true

) {

throw new Error('Proxy does not support socket path listen, only port.')

}

let port = <number | string>0

if (!args.noDebug) {

if (args.xdebugCloudToken) {

port = 9021

await this.setupXdebugCloud(args.xdebugCloudToken)

} else {

port = await createServer()

if (typeof port === 'number' && args.proxy?.enable === true) {

await this.setupProxy(port)

}

}

}

if (args.program || args.runtimeArgs) {

await launchScript(port)

}

} catch (error) {

this.sendErrorResponse(response, error as Error)

return

}

this.sendResponse(response)

// request breakpoints

this.sendEvent(new vscode.InitializedEvent())

}

private setupConnection(connection: xdebug.Connection): void {

this._connections.set(connection.id, connection)

connection.on('warning', (warning: string) => {

this.sendEvent(new vscode.OutputEvent(warning + '\n'))

})

connection.on('error', (error: Error) => {

if (error && this._args?.log) {

this.sendEvent(new vscode.OutputEvent(`connection ${connection.id}: ${error.message}\n`))

}

})

connection.on('close', () => this.disposeConnection(connection))

connection.on('log', (text: string) => {

if (this._args && this._args.log) {

const log = `xd(${connection.id}) ${text}\n`

this.sendEvent(new vscode.OutputEvent(log), true)

}

})

}

private async initializeConnection(connection: xdebug.Connection): Promise<void> {

const initPacket = await connection.waitForInitPacket()

// support for breakpoints

let feat: xdebug.FeatureGetResponse

const supportedEngine =

initPacket.engineName === 'Xdebug' &&

semver.valid(initPacket.engineVersion, { loose: true }) &&

semver.gte(initPacket.engineVersion, '3.0.0', { loose: true })

const supportedEngine32 =

initPacket.engineName === 'Xdebug' &&

semver.valid(initPacket.engineVersion, { loose: true }) &&

semver.gte(initPacket.engineVersion, '3.2.0', { loose: true })

if (

supportedEngine ||

((feat = await connection.sendFeatureGetCommand('resolved_breakpoints')) && feat.supported === '1')

) {

await connection.sendFeatureSetCommand('resolved_breakpoints', '1')

}

if (

supportedEngine ||

((feat = await connection.sendFeatureGetCommand('notify_ok')) && feat.supported === '1')

) {

await connection.sendFeatureSetCommand('notify_ok', '1')

connection.on('notify_user', (notify: xdebug.UserNotify) => this.handleUserNotify(notify, connection))

}

if (

supportedEngine ||

((feat = await connection.sendFeatureGetCommand('extended_properties')) && feat.supported === '1')

) {

await connection.sendFeatureSetCommand('extended_properties', '1')

}

if (

supportedEngine32 ||

((feat = await connection.sendFeatureGetCommand('breakpoint_include_return_value')) &&

feat.supported === '1')

) {

await connection.sendFeatureSetCommand('breakpoint_include_return_value', '1')

}

// override features from launch.json

try {

const xdebugSettings = this._args.xdebugSettings || {}

// Required defaults for indexedVariables

xdebugSettings.max_children = xdebugSettings.max_children || 100

await Promise.all(

Object.keys(xdebugSettings).map(setting =>

connection.sendFeatureSetCommand(setting, xdebugSettings[setting])

)

)

this._args.xdebugSettings = xdebugSettings

} catch (error) {

throw new Error(`Error applying xdebugSettings: ${String(error instanceof Error ? error.message : error)}`)

}

this.sendEvent(new vscode.ThreadEvent('started', connection.id))

// wait for all breakpoints

await this._donePromise

const bpa = new BreakpointAdapter(connection, this._breakpointManager)

bpa.on('dapEvent', event => this.sendEvent(event))

this._breakpointAdapters.set(connection, bpa)

// sync breakpoints to connection

await bpa.process()

let xdebugResponse: xdebug.StatusResponse

// either tell VS Code we stopped on entry or run the script

if (this._args.stopOnEntry) {

// do one step to the first statement

this._hasStoppedOnEntry = false

xdebugResponse = await connection.sendStepIntoCommand()

} else {

xdebugResponse = await connection.sendRunCommand()

}

await this._checkStatus(xdebugResponse)

}

private disposeConnection(connection: xdebug.Connection): void {

if (this._connections.has(connection.id)) {

if (this._args.log) {

this.sendEvent(new vscode.OutputEvent(`connection ${connection.id} closed\n`))

}

this.sendEvent(new vscode.ContinuedEvent(connection.id, false))

this.sendEvent(new vscode.ThreadEvent('exited', connection.id))

connection

.close()

.catch(err => this.sendEvent(new vscode.OutputEvent(`connection ${connection.id}: ${err as string}\n`)))

this._connections.delete(connection.id)

this._statuses.delete(connection)

this._breakpointAdapters.delete(connection)

this._skippingFiles.delete(connection.id)

}

}

private async setupXdebugCloud(token: string): Promise<void> {

this._xdebugCloudConnection = new XdebugCloudConnection(token)

this._xdebugCloudConnection.on('log', (text: string) => {

if (this._args && this._args.log) {

const log = `xdc ${text}\n`

this.sendEvent(new vscode.OutputEvent(log), true)

}

})

this._xdebugCloudConnection.on('connection', (connection: xdebug.Connection) => {

this.setupConnection(connection)

if (this._args.log) {

this.sendEvent(new vscode.OutputEvent(`new connection ${connection.id} from cloud\n`), true)

}

this.initializeConnection(connection).catch(error => {

this.sendEvent(

new vscode.OutputEvent(

`Failed initializing connection ${connection.id}: ${

'stderr'

)

)

this.disposeConnection(connection)

})

})

try {

const xdc = new XdebugCloudConnection(token)

xdc.on('log', (text: string) => {

if (this._args && this._args.log) {

const log = `xdc2 ${text}\n`

this.sendEvent(new vscode.OutputEvent(log), true)

}

})

await xdc.connectAndStop()

} catch (error) {

// just ignore

}

await this._xdebugCloudConnection.connect()

this._xdebugCloudConnection.once('close', () => {

this.sendEvent(new vscode.TerminatedEvent())

})

}

private async setupProxy(idePort: number): Promise<void> {

this._proxyConnect = new ProxyConnect(

this._args.proxy!.host,

this._args.proxy!.port,

idePort,

this._args.proxy!.allowMultipleSessions,

this._args.proxy!.key,

this._args.proxy!.timeout

)

const proxyConsole = (str: string) => this.sendEvent(new vscode.OutputEvent(str + '\n'), true)

this._proxyConnect.on('log_request', proxyConsole)

this._proxyConnect.on('log_response', proxyConsole)

this._proxyConnect.on('log_error', (error: Error) => {

this.sendEvent(new vscode.OutputEvent('PROXY ERROR: ' + error.message + '\n', 'stderr'))

})

return this._proxyConnect.sendProxyInitCommand()

}

/**

private async _checkStatus(response: xdebug.StatusResponse): Promise<void> {

const connection = response.connection

this._statuses.set(connection, response)

if (response.status === 'stopping') {

const response = await connection.sendStopCommand()

await this._checkStatus(response)

} else if (response.status === 'stopped') {

this._connections.delete(connection.id)

this._statuses.delete(connection)

this._breakpointAdapters.delete(connection)

this.sendEvent(new vscode.ThreadEvent('exited', connection.id))

await connection.close()

} else if (response.status === 'break') {

// First sync breakpoints

const bpa = this._breakpointAdapters.get(connection)

if (bpa) {

await bpa.process()

}

// StoppedEvent reason can be 'step', 'breakpoint', 'exception' or 'pause'

let stoppedEventReason: 'step' | 'breakpoint' | 'exception' | 'pause' | 'entry'

let exceptionText: string | undefined

if (response.exception) {

// If one of the ignore patterns matches, ignore this exception

if (

// ignore files

(this._args.ignore &&

this._args.ignore.some(glob =>

minimatch(convertDebuggerPathToClient(response.fileUri).replace(/\\/g, '/'), glob)

)) ||

// ignore exception class name

(this._args.ignoreExceptions &&

shouldIgnoreException(response.exception.name, this._args.ignoreExceptions))

) {

const response = await connection.sendRunCommand()

await this._checkStatus(response)

return

}

stoppedEventReason = 'exception'

exceptionText = response.exception.name + ': ' + response.exception.message // this seems to be ignored currently by VS Code

} else if (this._args.stopOnEntry && !this._hasStoppedOnEntry) {

stoppedEventReason = 'entry'

this._hasStoppedOnEntry = true

} else if (response.command.startsWith('step')) {

await this._processLogPoints(response)

// check just my code

if (

this._args.skipFiles &&

isPositiveMatchInGlobs(

convertDebuggerPathToClient(response.fileUri).replace(/\\/g, '/'),

this._args.skipFiles

)

) {

if (!this._skippingFiles.has(connection.id)) {

this._skippingFiles.set(connection.id, true)

}

if (this._skippingFiles.get(connection.id)) {

let stepResponse

switch (response.command) {

case 'step_out':

stepResponse = await connection.sendStepOutCommand()

break

case 'step_over':

stepResponse = await connection.sendStepOverCommand()

break

default:

stepResponse = await connection.sendStepIntoCommand()

}

await this._checkStatus(stepResponse)

return

}

this._skippingFiles.delete(connection.id)

}

stoppedEventReason = 'step'

} else {

if (await this._processLogPoints(response)) {

const responseCommand = await connection.sendRunCommand()

await this._checkStatus(responseCommand)

return

}

stoppedEventReason = 'breakpoint'

}

const event: VSCodeDebugProtocol.StoppedEvent = new vscode.StoppedEvent(

stoppedEventReason,

connection.id,

exceptionText

)

event.body.allThreadsStopped = false

this.sendEvent(event)

}

}

private async _processLogPoints(response: xdebug.StatusResponse): Promise<boolean> {

const connection = response.connection

if (this._logPointManager.hasLogPoint(response.fileUri, response.line)) {

const logMessage = await this._logPointManager.resolveExpressions(

response.fileUri,

response.line,

async (expr: string): Promise<string> => {

const evaluated = await connection.sendEvalCommand(expr)

return formatPropertyValue(evaluated.result)

}

)

this.sendEvent(new vscode.OutputEvent(logMessage + '\n', 'console'))

return true

}

return false

}

/** Logs all requests before dispatching */

protected dispatchRequest(request: VSCodeDebugProtocol.Request): void {

if (this._args?.log) {

const log = `-> ${request.command}Request\n${util.inspect(request, { depth: Infinity, compact: true })}\n\n`

super.sendEvent(new vscode.OutputEvent(log))

}

super.dispatchRequest(request)

}

public sendEvent(event: VSCodeDebugProtocol.Event, bypassLog: boolean = false): void {

if (this._args?.log && !bypassLog) {

const log = `<- ${event.event}Event\n${util.inspect(event, { depth: Infinity, compact: true })}\n\n`

super.sendEvent(new vscode.OutputEvent(log))

}

super.sendEvent(event)

}

public sendResponse(response: VSCodeDebugProtocol.Response): void {

if (this._args?.log) {

const log = `<- ${response.command}Response\n${util.inspect(response, {