@xortex/xcode 3.0.0

package/utils/errors.ts

@@ -0,0 +1,238 @@
+import { APIUserAbortError } from '@anthropic-ai/sdk'
+
+export class ClaudeError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = this.constructor.name
+  }
+}
+
+export class MalformedCommandError extends Error {}
+
+export class AbortError extends Error {
+  constructor(message?: string) {
+    super(message)
+    this.name = 'AbortError'
+  }
+}
+
+/**
+ * True iff `e` is any of the abort-shaped errors the codebase encounters:
+ * our AbortError class, a DOMException from AbortController.abort()
+ * (.name === 'AbortError'), or the SDK's APIUserAbortError. The SDK class
+ * is checked via instanceof because minified builds mangle class names —
+ * constructor.name becomes something like 'nJT' and the SDK never sets
+ * this.name, so string matching silently fails in production.
+ */
+export function isAbortError(e: unknown): boolean {
+  return (
+    e instanceof AbortError ||
+    e instanceof APIUserAbortError ||
+    (e instanceof Error && e.name === 'AbortError')
+  )
+}
+
+/**
+ * Custom error class for configuration file parsing errors
+ * Includes the file path and the default configuration that should be used
+ */
+export class ConfigParseError extends Error {
+  filePath: string
+  defaultConfig: unknown
+
+  constructor(message: string, filePath: string, defaultConfig: unknown) {
+    super(message)
+    this.name = 'ConfigParseError'
+    this.filePath = filePath
+    this.defaultConfig = defaultConfig
+  }
+}
+
+export class ShellError extends Error {
+  constructor(
+    public readonly stdout: string,
+    public readonly stderr: string,
+    public readonly code: number,
+    public readonly interrupted: boolean,
+  ) {
+    super('Shell command failed')
+    this.name = 'ShellError'
+  }
+}
+
+export class TeleportOperationError extends Error {
+  constructor(
+    message: string,
+    public readonly formattedMessage: string,
+  ) {
+    super(message)
+    this.name = 'TeleportOperationError'
+  }
+}
+
+/**
+ * Error with a message that is safe to log to telemetry.
+ * Use the long name to confirm you've verified the message contains no
+ * sensitive data (file paths, URLs, code snippets).
+ *
+ * Single-arg: same message for user and telemetry
+ * Two-arg: different messages (e.g., full message has file path, telemetry doesn't)
+ *
+ * @example
+ * // Same message for both
+ * throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(
+ *   'MCP server "slack" connection timed out'
+ * )
+ *
+ * // Different messages
+ * throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(
+ *   `MCP tool timed out after ${ms}ms`,  // Full message for logs/user
+ *   'MCP tool timed out'                  // Telemetry message
+ * )
+ */
+export class TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS extends Error {
+  readonly telemetryMessage: string
+
+  constructor(message: string, telemetryMessage?: string) {
+    super(message)
+    this.name = 'TelemetrySafeError'
+    this.telemetryMessage = telemetryMessage ?? message
+  }
+}
+
+export function hasExactErrorMessage(error: unknown, message: string): boolean {
+  return error instanceof Error && error.message === message
+}
+
+/**
+ * Normalize an unknown value into an Error.
+ * Use at catch-site boundaries when you need an Error instance.
+ */
+export function toError(e: unknown): Error {
+  return e instanceof Error ? e : new Error(String(e))
+}
+
+/**
+ * Extract a string message from an unknown error-like value.
+ * Use when you only need the message (e.g., for logging or display).
+ */
+export function errorMessage(e: unknown): string {
+  return e instanceof Error ? e.message : String(e)
+}
+
+/**
+ * Extract the errno code (e.g., 'ENOENT', 'EACCES') from a caught error.
+ * Returns undefined if the error has no code or is not an ErrnoException.
+ * Replaces the `(e as NodeJS.ErrnoException).code` cast pattern.
+ */
+export function getErrnoCode(e: unknown): string | undefined {
+  if (e && typeof e === 'object' && 'code' in e && typeof e.code === 'string') {
+    return e.code
+  }
+  return undefined
+}
+
+/**
+ * True if the error is ENOENT (file or directory does not exist).
+ * Replaces `(e as NodeJS.ErrnoException).code === 'ENOENT'`.
+ */
+export function isENOENT(e: unknown): boolean {
+  return getErrnoCode(e) === 'ENOENT'
+}
+
+/**
+ * Extract the errno path (the filesystem path that triggered the error)
+ * from a caught error. Returns undefined if the error has no path.
+ * Replaces the `(e as NodeJS.ErrnoException).path` cast pattern.
+ */
+export function getErrnoPath(e: unknown): string | undefined {
+  if (e && typeof e === 'object' && 'path' in e && typeof e.path === 'string') {
+    return e.path
+  }
+  return undefined
+}
+
+/**
+ * Extract error message + top N stack frames from an unknown error.
+ * Use when the error flows to the model as a tool_result — full stack
+ * traces are ~500-2000 chars of mostly-irrelevant internal frames and
+ * waste context tokens. Keep the full stack in debug logs instead.
+ */
+export function shortErrorStack(e: unknown, maxFrames = 5): string {
+  if (!(e instanceof Error)) return String(e)
+  if (!e.stack) return e.message
+  // V8/Bun stack format: "Name: message\n    at frame1\n    at frame2..."
+  // First line is the message; subsequent "    at " lines are frames.
+  const lines = e.stack.split('\n')
+  const header = lines[0] ?? e.message
+  const frames = lines.slice(1).filter(l => l.trim().startsWith('at '))
+  if (frames.length <= maxFrames) return e.stack
+  return [header, ...frames.slice(0, maxFrames)].join('\n')
+}
+
+/**
+ * True if the error means the path is missing, inaccessible, or
+ * structurally unreachable — use in catch blocks after fs operations to
+ * distinguish expected "nothing there / no access" from unexpected errors.
+ *
+ * Covers:
+ *  ENOENT    — path does not exist
+ *  EACCES    — permission denied
+ *  EPERM     — operation not permitted
+ *  ENOTDIR   — a path component is not a directory (e.g. a file named
+ *              `.claude` exists where a directory is expected)
+ *  ELOOP     — too many symlink levels (circular symlinks)
+ */
+export function isFsInaccessible(e: unknown): e is NodeJS.ErrnoException {
+  const code = getErrnoCode(e)
+  return (
+    code === 'ENOENT' ||
+    code === 'EACCES' ||
+    code === 'EPERM' ||
+    code === 'ENOTDIR' ||
+    code === 'ELOOP'
+  )
+}
+
+export type AxiosErrorKind =
+  | 'auth' // 401/403 — caller typically sets skipRetry
+  | 'timeout' // ECONNABORTED
+  | 'network' // ECONNREFUSED/ENOTFOUND
+  | 'http' // other axios error (may have status)
+  | 'other' // not an axios error
+
+/**
+ * Classify a caught error from an axios request into one of a few buckets.
+ * Replaces the ~20-line isAxiosError → 401/403 → ECONNABORTED → ECONNREFUSED
+ * chain duplicated across sync-style services (settingsSync, policyLimits,
+ * remoteManagedSettings, teamMemorySync).
+ *
+ * Checks the `.isAxiosError` marker property directly (same as
+ * axios.isAxiosError()) to keep this module dependency-free.
+ */
+export function classifyAxiosError(e: unknown): {
+  kind: AxiosErrorKind
+  status?: number
+  message: string
+} {
+  const message = errorMessage(e)
+  if (
+    !e ||
+    typeof e !== 'object' ||
+    !('isAxiosError' in e) ||
+    !e.isAxiosError
+  ) {
+    return { kind: 'other', message }
+  }
+  const err = e as {
+    response?: { status?: number }
+    code?: string
+  }
+  const status = err.response?.status
+  if (status === 401 || status === 403) return { kind: 'auth', status, message }
+  if (err.code === 'ECONNABORTED') return { kind: 'timeout', status, message }
+  if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') {
+    return { kind: 'network', status, message }
+  }
+  return { kind: 'http', status, message }
+}

package/utils/exampleCommands.ts

@@ -0,0 +1,184 @@
+import memoize from 'lodash-es/memoize.js'
+import sample from 'lodash-es/sample.js'
+import { getCwd } from '../utils/cwd.js'
+import { getCurrentProjectConfig, saveCurrentProjectConfig } from './config.js'
+import { env } from './env.js'
+import { execFileNoThrowWithCwd } from './execFileNoThrow.js'
+import { getIsGit, gitExe } from './git.js'
+import { logError } from './log.js'
+import { getGitEmail } from './user.js'
+
+// Patterns that mark a file as non-core (auto-generated, dependency, or config).
+// Used to filter example-command filename suggestions deterministically
+// instead of shelling out to Haiku.
+const NON_CORE_PATTERNS = [
+  // lock / dependency manifests
+  /(?:^|\/)(?:package-lock\.json|yarn\.lock|bun\.lock|bun\.lockb|pnpm-lock\.yaml|Pipfile\.lock|poetry\.lock|Cargo\.lock|Gemfile\.lock|go\.sum|composer\.lock|uv\.lock)$/,
+  // generated / build artifacts
+  /\.generated\./,
+  /(?:^|\/)(?:dist|build|out|target|node_modules|\.next|__pycache__)\//,
+  /\.(?:min\.js|min\.css|map|pyc|pyo)$/,
+  // data / docs / config extensions (not "write a test for" material)
+  /\.(?:json|ya?ml|toml|xml|ini|cfg|conf|env|lock|txt|md|mdx|rst|csv|log|svg)$/i,
+  // configuration / metadata
+  /(?:^|\/)\.?(?:eslintrc|prettierrc|babelrc|editorconfig|gitignore|gitattributes|dockerignore|npmrc)/,
+  /(?:^|\/)(?:tsconfig|jsconfig|biome|vitest\.config|jest\.config|webpack\.config|vite\.config|rollup\.config)\.[a-z]+$/,
+  /(?:^|\/)\.(?:github|vscode|idea|claude)\//,
+  // docs / changelogs (not "how does X work" material)
+  /(?:^|\/)(?:CHANGELOG|LICENSE|CONTRIBUTING|CODEOWNERS|README)(?:\.[a-z]+)?$/i,
+]
+
+function isCoreFile(path: string): boolean {
+  return !NON_CORE_PATTERNS.some(p => p.test(path))
+}
+
+/**
+ * Counts occurrences of items in an array and returns the top N items
+ * sorted by count in descending order, formatted as a string.
+ */
+export function countAndSortItems(items: string[], topN: number = 20): string {
+  const counts = new Map<string, number>()
+  for (const item of items) {
+    counts.set(item, (counts.get(item) || 0) + 1)
+  }
+  return Array.from(counts.entries())
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, topN)
+    .map(([item, count]) => `${count.toString().padStart(6)} ${item}`)
+    .join('\n')
+}
+
+/**
+ * Picks up to `want` basenames from a frequency-sorted list of paths,
+ * skipping non-core files and spreading across different directories.
+ * Returns empty array if fewer than `want` core files are available.
+ */
+export function pickDiverseCoreFiles(
+  sortedPaths: string[],
+  want: number,
+): string[] {
+  const picked: string[] = []
+  const seenBasenames = new Set<string>()
+  const dirTally = new Map<string, number>()
+
+  // Greedy: on each pass allow +1 file per directory. Keeps the
+  // top-5 from collapsing into a single hot folder while still
+  // letting a dominant folder contribute multiple files if the
+  // repo is narrow.
+  for (let cap = 1; picked.length < want && cap <= want; cap++) {
+    for (const p of sortedPaths) {
+      if (picked.length >= want) break
+      if (!isCoreFile(p)) continue
+      const lastSep = Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'))
+      const base = lastSep >= 0 ? p.slice(lastSep + 1) : p
+      if (!base || seenBasenames.has(base)) continue
+      const dir = lastSep >= 0 ? p.slice(0, lastSep) : '.'
+      if ((dirTally.get(dir) ?? 0) >= cap) continue
+      picked.push(base)
+      seenBasenames.add(base)
+      dirTally.set(dir, (dirTally.get(dir) ?? 0) + 1)
+    }
+  }
+
+  return picked.length >= want ? picked : []
+}
+
+async function getFrequentlyModifiedFiles(): Promise<string[]> {
+  if (process.env.NODE_ENV === 'test') return []
+  if (env.platform === 'win32') return []
+  if (!(await getIsGit())) return []
+
+  try {
+    // Collect frequently-modified files, preferring the user's own commits.
+    const userEmail = await getGitEmail()
+
+    const logArgs = [
+      'log',
+      '-n',
+      '1000',
+      '--pretty=format:',
+      '--name-only',
+      '--diff-filter=M',
+    ]
+
+    const counts = new Map<string, number>()
+    const tallyInto = (stdout: string) => {
+      for (const line of stdout.split('\n')) {
+        const f = line.trim()
+        if (f) counts.set(f, (counts.get(f) ?? 0) + 1)
+      }
+    }
+
+    if (userEmail) {
+      const { stdout } = await execFileNoThrowWithCwd(
+        'git',
+        [...logArgs, `--author=${userEmail}`],
+        { cwd: getCwd() },
+      )
+      tallyInto(stdout)
+    }
+
+    // Fall back to all authors if the user's own history is thin.
+    if (counts.size < 10) {
+      const { stdout } = await execFileNoThrowWithCwd(gitExe(), logArgs, {
+        cwd: getCwd(),
+      })
+      tallyInto(stdout)
+    }
+
+    const sorted = Array.from(counts.entries())
+      .sort((a, b) => b[1] - a[1])
+      .map(([p]) => p)
+
+    return pickDiverseCoreFiles(sorted, 5)
+  } catch (err) {
+    logError(err as Error)
+    return []
+  }
+}
+
+const ONE_WEEK_IN_MS = 7 * 24 * 60 * 60 * 1000
+
+export const getExampleCommandFromCache = memoize(() => {
+  const projectConfig = getCurrentProjectConfig()
+  const frequentFile = projectConfig.exampleFiles?.length
+    ? sample(projectConfig.exampleFiles)
+    : '<filepath>'
+
+  const commands = [
+    'fix lint errors',
+    'fix typecheck errors',
+    `how does ${frequentFile} work?`,
+    `refactor ${frequentFile}`,
+    'how do I log an error?',
+    `edit ${frequentFile} to...`,
+    `write a test for ${frequentFile}`,
+    'create a util logging.py that...',
+  ]
+
+  return `Try "${sample(commands)}"`
+})
+
+export const refreshExampleCommands = memoize(async (): Promise<void> => {
+  const projectConfig = getCurrentProjectConfig()
+  const now = Date.now()
+  const lastGenerated = projectConfig.exampleFilesGeneratedAt ?? 0
+
+  // Regenerate examples if they're over a week old
+  if (now - lastGenerated > ONE_WEEK_IN_MS) {
+    projectConfig.exampleFiles = []
+  }
+
+  // If no example files cached, kickstart fetch in background
+  if (!projectConfig.exampleFiles?.length) {
+    void getFrequentlyModifiedFiles().then(files => {
+      if (files.length) {
+        saveCurrentProjectConfig(current => ({
+          ...current,
+          exampleFiles: files,
+          exampleFilesGeneratedAt: Date.now(),
+        }))
+      }
+    })
+  }
+})

package/utils/execFileNoThrow.ts

@@ -0,0 +1,150 @@
+// This file represents useful wrappers over node:child_process
+// These wrappers ease error handling and cross-platform compatbility
+// By using execa, Windows automatically gets shell escaping + BAT / CMD handling
+
+import { type ExecaError, execa } from 'execa'
+import { getCwd } from '../utils/cwd.js'
+import { logError } from './log.js'
+
+export { execSyncWithDefaults_DEPRECATED } from './execFileNoThrowPortable.js'
+
+const MS_IN_SECOND = 1000
+const SECONDS_IN_MINUTE = 60
+
+type ExecFileOptions = {
+  abortSignal?: AbortSignal
+  timeout?: number
+  preserveOutputOnError?: boolean
+  // Setting useCwd=false avoids circular dependencies during initialization
+  // getCwd() -> PersistentShell -> logEvent() -> execFileNoThrow
+  useCwd?: boolean
+  env?: NodeJS.ProcessEnv
+  stdin?: 'ignore' | 'inherit' | 'pipe'
+  input?: string
+}
+
+export function execFileNoThrow(
+  file: string,
+  args: string[],
+  options: ExecFileOptions = {
+    timeout: 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+    preserveOutputOnError: true,
+    useCwd: true,
+  },
+): Promise<{ stdout: string; stderr: string; code: number; error?: string }> {
+  return execFileNoThrowWithCwd(file, args, {
+    abortSignal: options.abortSignal,
+    timeout: options.timeout,
+    preserveOutputOnError: options.preserveOutputOnError,
+    cwd: options.useCwd ? getCwd() : undefined,
+    env: options.env,
+    stdin: options.stdin,
+    input: options.input,
+  })
+}
+
+type ExecFileWithCwdOptions = {
+  abortSignal?: AbortSignal
+  timeout?: number
+  preserveOutputOnError?: boolean
+  maxBuffer?: number
+  cwd?: string
+  env?: NodeJS.ProcessEnv
+  shell?: boolean | string | undefined
+  stdin?: 'ignore' | 'inherit' | 'pipe'
+  input?: string
+}
+
+type ExecaResultWithError = {
+  shortMessage?: string
+  signal?: string
+}
+
+/**
+ * Extracts a human-readable error message from an execa result.
+ *
+ * Priority order:
+ * 1. shortMessage - execa's human-readable error (e.g., "Command failed with exit code 1: ...")
+ *    This is preferred because it already includes signal info when a process is killed,
+ *    making it more informative than just the signal name.
+ * 2. signal - the signal that killed the process (e.g., "SIGTERM")
+ * 3. errorCode - fallback to just the numeric exit code
+ */
+function getErrorMessage(
+  result: ExecaResultWithError,
+  errorCode: number,
+): string {
+  if (result.shortMessage) {
+    return result.shortMessage
+  }
+  if (typeof result.signal === 'string') {
+    return result.signal
+  }
+  return String(errorCode)
+}
+
+/**
+ * execFile, but always resolves (never throws)
+ */
+export function execFileNoThrowWithCwd(
+  file: string,
+  args: string[],
+  {
+    abortSignal,
+    timeout: finalTimeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+    preserveOutputOnError: finalPreserveOutput = true,
+    cwd: finalCwd,
+    env: finalEnv,
+    maxBuffer,
+    shell,
+    stdin: finalStdin,
+    input: finalInput,
+  }: ExecFileWithCwdOptions = {
+    timeout: 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+    preserveOutputOnError: true,
+    maxBuffer: 1_000_000,
+  },
+): Promise<{ stdout: string; stderr: string; code: number; error?: string }> {
+  return new Promise(resolve => {
+    // Use execa for cross-platform .bat/.cmd compatibility on Windows
+    execa(file, args, {
+      maxBuffer,
+      signal: abortSignal,
+      timeout: finalTimeout,
+      cwd: finalCwd,
+      env: finalEnv,
+      shell,
+      stdin: finalStdin,
+      input: finalInput,
+      reject: false, // Don't throw on non-zero exit codes
+    })
+      .then(result => {
+        if (result.failed) {
+          if (finalPreserveOutput) {
+            const errorCode = result.exitCode ?? 1
+            void resolve({
+              stdout: result.stdout || '',
+              stderr: result.stderr || '',
+              code: errorCode,
+              error: getErrorMessage(
+                result as unknown as ExecaResultWithError,
+                errorCode,
+              ),
+            })
+          } else {
+            void resolve({ stdout: '', stderr: '', code: result.exitCode ?? 1 })
+          }
+        } else {
+          void resolve({
+            stdout: result.stdout,
+            stderr: result.stderr,
+            code: 0,
+          })
+        }
+      })
+      .catch((error: ExecaError) => {
+        logError(error)
+        void resolve({ stdout: '', stderr: '', code: 1 })
+      })
+  })
+}

package/utils/execFileNoThrowPortable.ts

@@ -0,0 +1,89 @@
+import { type Options as ExecaOptions, execaSync } from 'execa'
+import { getCwd } from '../utils/cwd.js'
+import { slowLogging } from './slowOperations.js'
+
+const MS_IN_SECOND = 1000
+const SECONDS_IN_MINUTE = 60
+
+type ExecSyncOptions = {
+  abortSignal?: AbortSignal
+  timeout?: number
+  input?: string
+  stdio?: ExecaOptions['stdio']
+}
+
+/**
+ * @deprecated Use `execa` directly with `{ shell: true, reject: false }` for non-blocking execution.
+ * Sync exec calls block the event loop and cause performance issues.
+ */
+export function execSyncWithDefaults_DEPRECATED(command: string): string | null
+/**
+ * @deprecated Use `execa` directly with `{ shell: true, reject: false }` for non-blocking execution.
+ * Sync exec calls block the event loop and cause performance issues.
+ */
+export function execSyncWithDefaults_DEPRECATED(
+  command: string,
+  options: ExecSyncOptions,
+): string | null
+/**
+ * @deprecated Use `execa` directly with `{ shell: true, reject: false }` for non-blocking execution.
+ * Sync exec calls block the event loop and cause performance issues.
+ */
+export function execSyncWithDefaults_DEPRECATED(
+  command: string,
+  abortSignal: AbortSignal,
+  timeout?: number,
+): string | null
+/**
+ * @deprecated Use `execa` directly with `{ shell: true, reject: false }` for non-blocking execution.
+ * Sync exec calls block the event loop and cause performance issues.
+ */
+export function execSyncWithDefaults_DEPRECATED(
+  command: string,
+  optionsOrAbortSignal?: ExecSyncOptions | AbortSignal,
+  timeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+): string | null {
+  let options: ExecSyncOptions
+
+  if (optionsOrAbortSignal === undefined) {
+    // No second argument - use defaults
+    options = {}
+  } else if (optionsOrAbortSignal instanceof AbortSignal) {
+    // Old signature - second argument is AbortSignal
+    options = {
+      abortSignal: optionsOrAbortSignal,
+      timeout,
+    }
+  } else {
+    // New signature - second argument is options object
+    options = optionsOrAbortSignal
+  }
+
+  const {
+    abortSignal,
+    timeout: finalTimeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+    input,
+    stdio = ['ignore', 'pipe', 'pipe'],
+  } = options
+
+  abortSignal?.throwIfAborted()
+  using _ = slowLogging`exec: ${command.slice(0, 200)}`
+  try {
+    const result = execaSync(command, {
+      env: process.env,
+      maxBuffer: 1_000_000,
+      timeout: finalTimeout,
+      cwd: getCwd(),
+      stdio,
+      shell: true, // execSync typically runs shell commands
+      reject: false, // Don't throw on non-zero exit codes
+      input,
+    })
+    if (!result.stdout) {
+      return null
+    }
+    return result.stdout.trim() || null
+  } catch {
+    return null
+  }
+}

package/utils/execSyncWrapper.ts

@@ -0,0 +1,38 @@
+import {
+  type ExecSyncOptions,
+  type ExecSyncOptionsWithBufferEncoding,
+  type ExecSyncOptionsWithStringEncoding,
+  execSync as nodeExecSync,
+} from 'child_process'
+import { slowLogging } from './slowOperations.js'
+
+/**
+ * @deprecated Use async alternatives when possible. Sync exec calls block the event loop.
+ *
+ * Wrapped execSync with slow operation logging.
+ * Use this instead of child_process execSync directly to detect performance issues.
+ *
+ * @example
+ * import { execSync_DEPRECATED } from './execSyncWrapper.js'
+ * const result = execSync_DEPRECATED('git status', { encoding: 'utf8' })
+ */
+export function execSync_DEPRECATED(command: string): Buffer
+export function execSync_DEPRECATED(
+  command: string,
+  options: ExecSyncOptionsWithStringEncoding,
+): string
+export function execSync_DEPRECATED(
+  command: string,
+  options: ExecSyncOptionsWithBufferEncoding,
+): Buffer
+export function execSync_DEPRECATED(
+  command: string,
+  options?: ExecSyncOptions,
+): Buffer | string
+export function execSync_DEPRECATED(
+  command: string,
+  options?: ExecSyncOptions,
+): Buffer | string {
+  using _ = slowLogging`execSync: ${command.slice(0, 100)}`
+  return nodeExecSync(command, options)
+}