@servicenow/sdk-build-core 4.4.1 → 4.6.0

package/src/telemetry/clients/abstract-client.ts

@@ -1,4 +1,14 @@
-import type { Telemetry, TelemetryEvent, TelemetryEventData, TimerMetric, InstanceSettings, Session } from '../types'
+import type {
+    Telemetry,
+    TelemetryEvent,
+    TelemetryEventData,
+    TimerMetric,
+    InstanceSettings,
+    Session,
+    Datapoint,
+    HeartbeatBody,
+} from '../types'
+import { NETWORK_TIMEOUT_MS, DatapointType } from '../types'
 import { AppSeeTimerMetric } from './util'
 
 export abstract class AbstractAppSeeClient implements Telemetry {
@@ -7,6 +17,7 @@ export abstract class AbstractAppSeeClient implements Telemetry {
     protected readonly hostname?: string | undefined
     protected session?: Session
     protected startPromise?: Promise<void>
+    protected userId?: string
 
     constructor(
         protected readonly config: InstanceSettings,
@@ -58,6 +69,96 @@ export abstract class AbstractAppSeeClient implements Telemetry {
         ])
     }
 
-    protected abstract doStart(): Promise<void>
-    protected abstract doSendEvent(events: TelemetryEvent | TelemetryEvent[]): void
+    protected doSendEvent(events: TelemetryEvent | TelemetryEvent[]): void {
+        try {
+            if (!this.session) {
+                return
+            }
+
+            const defaultValues = this.getDefaultDataValues()
+            const eventData = Array.isArray(events) ? events : [events]
+            const now = Date.now()
+            const hostname = this.hostname ? { hostname: this.hostname } : {}
+
+            const dataPoints = eventData.map<Datapoint>((d) => ({
+                t: DatapointType.Event,
+                d: now,
+                n: d.name,
+                p: { scopeId: d.appInfo?.scopeId, ...hostname, ...defaultValues, ...d.data },
+            }))
+
+            dataPoints.push({
+                t: DatapointType.User,
+                d: now,
+                n: this.userId ?? 'unknown',
+                p: this.getUserProps(hostname),
+            })
+
+            const body: HeartbeatBody = {
+                SessionId: this.session.SessionId,
+                DataPoints: dataPoints,
+                TabId: this.session.TabId || '0',
+                ClientTime: new Date().toISOString(),
+                ConfigReceivedTime: new Date().toISOString(),
+            }
+
+            fetch(new URL('/web/heartbeat', this.config.BaseUrl), {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
+            }).catch(() => {})
+        } catch (_error) {}
+    }
+
+    protected getHeaders() {
+        return {
+            APIKey: this.config.APIKey,
+            APIAuth: this.config.APIAuth,
+            BrowserId: '0',
+            ClientId: this.session?.ClientId || '0',
+            Version: this.sdkVersion || 'unknown',
+            'Content-Type': 'application/json',
+        }
+    }
+
+    protected async doStart(): Promise<void> {
+        try {
+            if (this.session) {
+                return
+            }
+
+            this.userId = await this.getUserHash()
+
+            const tabId = this.generateHexString()
+            const body = {
+                RequestId: this.generateHexString(),
+                TabId: tabId,
+                AppUserId: this.userId,
+                ClientTime: new Date().toISOString(),
+                TrackingLevel: 'Full',
+                ...this.getEnvironmentInfo(),
+            }
+
+            const response = await fetch(new URL('/web/config', this.config.BaseUrl), {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
+            })
+
+            const bodyResponse = await response.json()
+            if (response.ok) {
+                this.session = { ...bodyResponse, TabId: tabId }
+            } else {
+                throw new Error(`Failed to start session with status ${response.status}: ${bodyResponse.Error}`)
+            }
+        } catch (_error) {}
+    }
+
+    abstract getUserHash(): Promise<string>
+    abstract generateHexString(): string
+    abstract getEnvironmentInfo(): { SystemLocale: string; ScreenHeight: number; ScreenWidth: number }
+    abstract getDefaultDataValues(): TelemetryEventData<{ version: string; clientName: string }>
+    abstract getUserProps(hostname: Record<string, string>): TelemetryEventData
 }

package/src/telemetry/clients/browser-client.ts

@@ -1,5 +1,4 @@
-import type { TelemetryEvent, TelemetryEventData, Datapoint, HeartbeatBody } from '../types'
-import { NETWORK_TIMEOUT_MS, DatapointType, type InstanceSettings } from '../types'
+import type { TelemetryEventData, InstanceSettings } from '../types'
 import { AbstractAppSeeClient } from './abstract-client'
 
 export class BrowserTelemetryClient extends AbstractAppSeeClient {
@@ -22,9 +21,8 @@ export class BrowserTelemetryClient extends AbstractAppSeeClient {
     }
 
     private readonly ideVersion: string | undefined
-    private userId?: string
 
-    private async getUserHash() {
+    override async getUserHash(): Promise<string> {
         const userUniqueId = await this.getUserIdentifier()
         const bytes = new TextEncoder().encode(userUniqueId)
         const byteHash = await crypto.subtle.digest('SHA-256', bytes)
@@ -52,109 +50,28 @@ export class BrowserTelemetryClient extends AbstractAppSeeClient {
         }
     }
 
-    private generateHexString(): string {
+    override generateHexString(): string {
         return crypto.randomUUID()
     }
 
-    override async doStart(): Promise<void> {
-        try {
-            if (this.session) {
-                return
-            }
-
-            this.userId = await this.getUserHash()
-
-            const tabId = this.generateHexString()
-            const body = {
-                RequestId: this.generateHexString(),
-                TabId: tabId,
-                SystemLocale: navigator.language ?? 'unknown',
-                AppUserId: this.userId,
-                ScreenHeight: typeof screen !== 'undefined' ? screen.height : 0,
-                ScreenWidth: typeof screen !== 'undefined' ? screen.width : 0,
-                ClientTime: new Date().toISOString(),
-                TrackingLevel: 'Full',
-            }
-
-            const response = await fetch(new URL('/web/config', this.config.BaseUrl), {
-                method: 'POST',
-                headers: this.getHeaders(),
-                body: JSON.stringify(body),
-                signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
-            })
-
-            const bodyResponse = await response.json()
-            if (response.ok) {
-                this.session = { ...bodyResponse, TabId: tabId }
-            } else {
-                throw new Error(`Failed to start session with status ${response.status}: ${bodyResponse.Error}`)
-            }
-        } catch (_error) {}
-    }
-
-    override doSendEvent(events: TelemetryEvent | TelemetryEvent[]): void {
-        try {
-            if (!this.session) {
-                return
-            }
-
-            const defaultValues = this.getDefaultDataValues()
-            const eventData = Array.isArray(events) ? events : [events]
-            const now = Date.now()
-            const hostname = this.hostname ? { hostname: this.hostname } : {}
-
-            const dataPoints = eventData.map<Datapoint>((d) => ({
-                t: DatapointType.Event,
-                d: now,
-                n: d.name,
-                p: { scopeId: d.appInfo?.scopeId, ...hostname, ...defaultValues, ...d.data },
-            }))
-
-            const userProps = { hostname } //does CI make sense for browser environment ??
-
-            dataPoints.push({
-                t: DatapointType.User,
-                d: now,
-                n: this.userId!,
-                p: userProps,
-            })
-
-            const body: HeartbeatBody = {
-                SessionId: this.session.SessionId,
-                DataPoints: dataPoints,
-                TabId: this.session.TabId || '0',
-                ClientTime: new Date().toISOString(),
-                ConfigReceivedTime: new Date().toISOString(),
-            }
-
-            fetch(new URL('/web/heartbeat', this.config.BaseUrl), {
-                method: 'POST',
-                headers: this.getHeaders(),
-                body: JSON.stringify(body),
-                signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
-            }).catch(() => {})
-        } catch (_error) {}
-    }
-
-    private getHeaders() {
+    override getEnvironmentInfo() {
         return {
-            APIKey: this.config.APIKey,
-            APIAuth: this.config.APIAuth,
-            BrowserId: '0',
-            ClientId: this.session?.ClientId || '0',
-            Version: this.sdkVersion || 'unknown',
-            'Content-Type': 'application/json',
+            SystemLocale: navigator.language ?? 'unknown',
+            ScreenHeight: typeof screen !== 'undefined' ? screen.height : 0,
+            ScreenWidth: typeof screen !== 'undefined' ? screen.width : 0,
         }
     }
 
-    private getDefaultDataValues() {
-        const defaultValues: TelemetryEventData = {
+    override getDefaultDataValues() {
+        return {
             browser: navigator.userAgent || 'unknown',
             version: this.sdkVersion || 'unknown',
             clientName: this.clientName,
             ideVersion: this.ideVersion || 'unknown',
         }
+    }
 
-        return defaultValues
+    override getUserProps(hostname: Record<string, string>): TelemetryEventData {
+        return { ...hostname }
     }
 }

package/src/telemetry/clients/node-client.ts

@@ -1,26 +1,8 @@
 import * as os from 'os'
 import ciInfo from 'ci-info'
-import { NETWORK_TIMEOUT_MS, DatapointType } from '../types'
-import type { TelemetryEvent, TelemetryEventData, Datapoint, HeartbeatBody, InstanceSettings } from '../types'
+import type { TelemetryEventData, InstanceSettings } from '../types'
 import { AbstractAppSeeClient } from './abstract-client'
 
-function generateHexString() {
-    // biome-ignore lint/style/noRestrictedImports: <explanation>
-    const crypto = require('node:crypto')
-    return crypto.randomBytes(16).toString('hex')
-}
-
-async function getUserHash() {
-    const user = `${os.userInfo().username}:${os.hostname()}`
-    if (!user) {
-        return 'unknown'
-    }
-
-    const bytes = new TextEncoder().encode(user)
-    const byteHash = await crypto.subtle.digest('SHA-256', bytes)
-    return Buffer.from(byteHash).toString('hex')
-}
-
 export class NodeTelemetryClient extends AbstractAppSeeClient {
     constructor(
         config: InstanceSettings,
@@ -32,120 +14,63 @@ export class NodeTelemetryClient extends AbstractAppSeeClient {
         })
     }
 
-    private userId?: string
-
-    override async doStart(): Promise<void> {
-        try {
-            if (this.session) {
-                return
-            }
-
-            this.userId = await getUserHash()
-
-            const tabId = generateHexString()
-            const body = {
-                RequestId: generateHexString(),
-                TabId: tabId,
-                SystemLocale: (process.env['LANG'] || 'unknown').split('.')[0],
-                AppUserId: this.userId,
-                ScreenHeight: 0,
-                ScreenWidth: 0,
-                ClientTime: new Date().toISOString(),
-                TrackingLevel: 'Full',
-            }
-
-            const response = await fetch(new URL('/web/config', this.config.BaseUrl), {
-                method: 'POST',
-                headers: this.getHeaders(),
-                body: JSON.stringify(body),
-                signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
-            })
-
-            const bodyResponse = await response.json()
-            if (response.ok) {
-                this.session = { ...bodyResponse, TabId: tabId }
-            } else {
-                throw new Error(`Failed to start session with status ${response.status}: ${bodyResponse.Error}`)
-            }
-        } catch (_error) {
-            //ignore
+    override async getUserHash(): Promise<string> {
+        const user = `${os.userInfo().username}:${os.hostname()}`
+        if (!user) {
+            return 'unknown'
         }
-    }
-
-    override doSendEvent(events: TelemetryEvent | TelemetryEvent[]): void {
-        try {
-            //Check if we have a session
-            if (!this.session) {
-                return
-            }
 
-            const defaultValues = this.getDefaultDataValues()
-            const eventData = Array.isArray(events) ? events : [events]
-            const now = Date.now()
-            const hostname = this.hostname ? { hostname: this.hostname } : {}
-
-            const dataPoints = eventData.map<Datapoint>((d) => ({
-                t: DatapointType.Event,
-                d: now,
-                n: d.name,
-                p: { scopeId: d.appInfo?.scopeId, ...hostname, ...defaultValues, ...d.data },
-            }))
-
-            const userProps = this.applyCITelemetry({ ...hostname })
-
-            dataPoints.push({
-                t: DatapointType.User,
-                d: now,
-                n: this.userId!,
-                p: userProps,
-            })
-
-            const body: HeartbeatBody = {
-                SessionId: this.session.SessionId,
-                DataPoints: dataPoints,
-                TabId: this.session.TabId || '0',
-                ClientTime: new Date().toISOString(),
-                ConfigReceivedTime: new Date().toISOString(),
-            }
+        const bytes = new TextEncoder().encode(user)
+        const byteHash = await crypto.subtle.digest('SHA-256', bytes)
+        return Buffer.from(byteHash).toString('hex')
+    }
 
-            fetch(new URL('/web/heartbeat', this.config.BaseUrl), {
-                method: 'POST',
-                headers: this.getHeaders(),
-                body: JSON.stringify(body),
-                signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
-            }).catch(() => {})
-        } catch (_error) {
-            //ignore errors from telemetry
-        }
+    override generateHexString(): string {
+        // biome-ignore lint/style/noRestrictedImports: node:crypto is not available via sdk-build-core
+        const nodeCrypto = require('node:crypto')
+        return nodeCrypto.randomBytes(16).toString('hex')
     }
 
-    private getHeaders() {
+    override getEnvironmentInfo() {
         return {
-            APIKey: this.config.APIKey,
-            APIAuth: this.config.APIAuth,
-            BrowserId: '0',
-            ClientId: this.session?.ClientId || '0',
-            Version: this.sdkVersion || 'unknown',
-            'Content-Type': 'application/json',
+            SystemLocale: (process.env['LANG'] || 'unknown').split('.')[0] ?? 'unknown',
+            ScreenHeight: 0,
+            ScreenWidth: 0,
         }
     }
 
-    private getDefaultDataValues() {
-        const defaultValues: TelemetryEventData = {
+    override getDefaultDataValues() {
+        const codingAgentData: TelemetryEventData<{ codingAgent?: string }> = {}
+        if (process.env['GEMINI_CLI']) {
+            codingAgentData.codingAgent = 'gemini'
+        } else if (process.env['CLAUDECODE']) {
+            codingAgentData.codingAgent = 'claudecode'
+        } else if (process.env['CODEX_CI']) {
+            codingAgentData.codingAgent = 'codex'
+        }
+
+        return {
             os: os.type(),
             version: this.sdkVersion || 'unknown',
             nodeVersion: process.version,
             clientName: this.clientName,
+            ...codingAgentData,
+            ...this.applyCITelemetry(),
         }
+    }
 
-        return this.applyCITelemetry(defaultValues)
+    override getUserProps(hostname: Record<string, string>): TelemetryEventData {
+        return {
+            hostname,
+            ...this.applyCITelemetry(),
+        }
     }
 
-    private applyCITelemetry(data: TelemetryEventData) {
+    private applyCITelemetry() {
         if (ciInfo.isCI) {
-            return { ...data, ci: true, ciName: ciInfo.name, ciPR: ciInfo.isPR }
+            return { ci: true, ciName: ciInfo.name, ciPR: ciInfo.isPR }
         }
 
-        return data
+        return {}
     }
 }

package/src/telemetry/factory.ts

@@ -10,16 +10,13 @@ export class TelemetryFactory {
         type?: 'node' | 'browser'
         attributes?: { sdkVersion?: string; clientName?: string; hostname?: string; ideVersion?: string }
     }): Telemetry {
+        if (process.env['NODE_ENV'] === 'test' || !options || !options.type) {
+            return new NoOpTelemetry()
+        }
+
         const config = getAppSeeConfig()
 
-        if (
-            process.env['NODE_ENV'] === 'test' ||
-            !options ||
-            !options.type ||
-            !config.APIKey ||
-            !config.APIAuth ||
-            !config.BaseUrl
-        ) {
+        if (!config.APIKey || !config.APIAuth || !config.BaseUrl) {
             return new NoOpTelemetry()
         }
 

package/src/telemetry/types.ts

@@ -56,6 +56,7 @@ export interface TimerMetric {
     end(eventData?: Pick<TelemetryEvent, 'appInfo' | 'data'>): TelemetryEvent
 }
 
-export type TelemetryEventData = Record<string, unknown>
+export type TelemetryEventData<T extends Record<string, unknown> = Record<string, unknown>> = T &
+    Record<string, unknown>
 
 export type TelemetryEvent = { name: string; appInfo?: { scopeId?: string }; data?: TelemetryEventData }

package/src/typescript.ts

@@ -159,6 +159,10 @@ export const SupportedKinds = {
         name: 'FunctionExpression',
         node: {} as ts.FunctionExpression,
     },
+    [ts.SyntaxKind.ParenthesizedExpression]: {
+        name: 'ParenthesizedExpression',
+        node: {} as ts.ParenthesizedExpression,
+    },
     [ts.SyntaxKind.FunctionDeclaration]: {
         name: 'FunctionDeclaration',
         node: {} as ts.FunctionDeclaration,
@@ -351,6 +355,10 @@ export const SupportedKinds = {
         name: 'PrefixUnaryExpression',
         node: {} as ts.PrefixUnaryExpression,
     },
+    [ts.SyntaxKind.ReturnStatement]: {
+        name: 'ReturnStatement',
+        node: {} as ts.ReturnStatement,
+    },
 } satisfies {
     [K in ts.SyntaxKind]?: {
         name: keyof typeof ts.SyntaxKind
@@ -475,7 +483,10 @@ export function remove(target: ts.Node): void {
         }
     }
 
-    throw new Error(`Unable to remove "${getUnsupportedKindName(target)}" node: ${target.getText()}`)
+    // It is possible that multiple plugins could attempt to remove the same node. To support this, only error if target is unsupported
+    if (!isSupportedNode(target)) {
+        throw new Error(`Unable to remove "${getUnsupportedKindName(target)}" node: ${target.getText()}`)
+    }
 }
 
 /**

package/src/xml.ts

@@ -104,8 +104,11 @@ export function recordXml(
                 But when fluent generates the XML from source it creates XML with   which makes the XML invalid since `nbsp` is not defined.
 
                 So we are replacing   with   to ensure the XML is valid.
+                Note: This only applies to plain text content. CDATA sections do not parse
+                entity references, so   is valid as-is inside CDATA.
             */
-            const sanitizedValue = stringValue.replaceAll(' ', ' ')
+            const sanitizedValue =
+                contentType === 'plain' ? stringValue.replaceAll(' ', ' ') : stringValue
 
             const columnNameElement: Element = {
                 type: 'element',