@xelauvas/xela-cli 0.1.0

package/src/utils/powershell/staticPrefix.ts

@@ -0,0 +1,316 @@
+/**
+ * PowerShell static command prefix extraction.
+ *
+ * Mirrors bash's getCommandPrefixStatic / getCompoundCommandPrefixesStatic
+ * (src/utils/bash/prefix.ts) but uses the PowerShell AST parser instead of
+ * tree-sitter. The AST gives us cmd.name and cmd.args already split; for
+ * external commands we feed those into the same fig-spec walker bash uses
+ * (src/utils/shell/specPrefix.ts) — git/npm/kubectl CLIs are shell-agnostic.
+ *
+ * Feeds the "Yes, and don't ask again for: ___" editable input in the
+ * permission dialog — static extractor provides a best-guess prefix, user
+ * edits it down if needed.
+ */
+
+import { getCommandSpec } from '../bash/registry.js'
+import { buildPrefix, DEPTH_RULES } from '../shell/specPrefix.js'
+import { countCharInString } from '../stringUtils.js'
+import { NEVER_SUGGEST } from './dangerousCmdlets.js'
+import {
+  getAllCommands,
+  type ParsedCommandElement,
+  parsePowerShellCommand,
+} from './parser.js'
+
+/**
+ * Extract a static prefix from a single parsed command element.
+ * Returns null for commands we won't suggest (shells, eval cmdlets, path-like
+ * invocations) or can't extract a meaningful prefix from.
+ */
+async function extractPrefixFromElement(
+  cmd: ParsedCommandElement,
+): Promise<string | null> {
+  // nameType === 'application' means the raw name had path chars (./x, x\y,
+  // x.exe) — PowerShell will run a file, not a named cmdlet. Don't suggest.
+  // Same reasoning as the permission engine's nameType gate (PR #20096).
+  if (cmd.nameType === 'application') {
+    return null
+  }
+
+  const name = cmd.name
+  if (!name) {
+    return null
+  }
+
+  if (NEVER_SUGGEST.has(name.toLowerCase())) {
+    return null
+  }
+
+  // Cmdlets (Verb-Noun): the name alone is the right prefix granularity.
+  // Get-Process -Name pwsh → Get-Process. There's no subcommand concept.
+  if (cmd.nameType === 'cmdlet') {
+    return name
+  }
+
+  // External command. Guard the argv before feeding it to buildPrefix.
+  //
+  // elementTypes[0] (command name) must be a literal. `& $cmd status` has
+  // elementTypes[0]='Variable', name='$cmd' — classifies as 'unknown' (no path
+  // chars), passes NEVER_SUGGEST, getCommandSpec('$cmd')=null → returns bare
+  // '$cmd' → dead rule. Cheap to gate here.
+  //
+  // elementTypes[1..] (args) must all be StringConstant or Parameter. Anything
+  // dynamic (Variable/SubExpression/ScriptBlock/ExpandableString) would embed
+  // `$foo`/`$(...)` in the prefix → dead rule.
+  if (cmd.elementTypes?.[0] !== 'StringConstant') {
+    return null
+  }
+  for (let i = 0; i < cmd.args.length; i++) {
+    const t = cmd.elementTypes[i + 1]
+    if (t !== 'StringConstant' && t !== 'Parameter') {
+      return null
+    }
+  }
+
+  // Consult the fig spec — same oracle bash uses. If git's spec says -C takes
+  // a value, buildPrefix skips -C /repo and finds `status` as a subcommand.
+  // Lowercase for lookup: fig specs are filesystem paths (git.js), case-
+  // sensitive on Linux. PowerShell is case-insensitive (Git === git) so `Git`
+  // must resolve to the git spec. macOS hides this bug (case-insensitive fs).
+  // Call buildPrefix unconditionally — calculateDepth consults DEPTH_RULES
+  // before its own `if (!spec) return 2` fallback, so gcloud/aws/kubectl/az
+  // get depth-aware prefixes even without a loaded spec. The old
+  // `if (!spec) return name` short-circuit produced bare `gcloud:*` which
+  // auto-allows every gcloud subcommand.
+  const nameLower = name.toLowerCase()
+  const spec = await getCommandSpec(nameLower)
+  const prefix = await buildPrefix(name, cmd.args, spec)
+
+  // Post-buildPrefix word integrity: buildPrefix space-joins consumed args
+  // into the prefix string. parser.ts:685 stores .value (quote-stripped) for
+  // single-quoted literals: git 'push origin' → args=['push origin']. If
+  // that arg is consumed, buildPrefix emits 'git push origin' — silently
+  // promoting 1 argv element to 3 prefix words. Rule PowerShell(git push
+  // origin:*) then matches `git push origin --force` (3-element argv) — not
+  // what the user approved.
+  //
+  // The old set-membership check (`!cmd.args.includes(word)`) was defeated
+  // by decoy args: `git 'push origin' push origin` → args=['push origin',
+  // 'push', 'origin'], prefix='git push origin'. Each word ∈ args (decoys at
+  // indices 1,2 satisfy .includes()) → passed. Now POSITIONAL: walk args in
+  // order; each prefix word must exactly match the next non-flag arg. A
+  // positional that doesn't match means buildPrefix split it. Flags and
+  // their values are skipped (buildPrefix skips them too) so
+  // `git -C '/my repo' status` and `git commit -m 'fix typo'` still pass.
+  // Backslash (C:\repo) rejected: dead over-specific rule.
+  let argIdx = 0
+  for (const word of prefix.split(' ').slice(1)) {
+    if (word.includes('\\')) return null
+    while (argIdx < cmd.args.length) {
+      const a = cmd.args[argIdx]!
+      if (a === word) break
+      if (a.startsWith('-')) {
+        argIdx++
+        // Only skip the flag's value if the spec says this flag takes a
+        // value argument. Without spec info, treat as a switch (no value)
+        // — fail-safe avoids over-skipping positional args. (bug #16)
+        if (
+          spec?.options &&
+          argIdx < cmd.args.length &&
+          cmd.args[argIdx] !== word &&
+          !cmd.args[argIdx]!.startsWith('-')
+        ) {
+          const flagLower = a.toLowerCase()
+          const opt = spec.options.find(o =>
+            Array.isArray(o.name)
+              ? o.name.includes(flagLower)
+              : o.name === flagLower,
+          )
+          if (opt?.args) {
+            argIdx++
+          }
+        }
+        continue
+      }
+      // Positional arg that isn't the expected word → arg was split.
+      return null
+    }
+    if (argIdx >= cmd.args.length) return null
+    argIdx++
+  }
+
+  // Bare-root guard: buildPrefix returns 'git' for `git` with no subcommand
+  // found (empty args, or only global flags). That's too broad — would
+  // auto-allow `git push --force` forever. Bash's extractor doesn't gate this
+  // (bash/prefix.ts:363, separate fix). Reject single-word results for
+  // commands whose spec declares subcommands OR that have DEPTH_RULES entries
+  // (gcloud, aws, kubectl, etc.) which implies subcommand structure even
+  // without a loaded spec. (bug #17)
+  if (
+    !prefix.includes(' ') &&
+    (spec?.subcommands?.length || DEPTH_RULES[nameLower])
+  ) {
+    return null
+  }
+  return prefix
+}
+
+/**
+ * Extract a prefix suggestion for a PowerShell command.
+ *
+ * Parses the command, takes the first CommandAst, returns a prefix suitable
+ * for the permission dialog's "don't ask again for: ___" editable input.
+ * Returns null when no safe prefix can be extracted (parse failure, shell
+ * invocation, path-like name, bare subcommand-aware command).
+ */
+export async function getCommandPrefixStatic(
+  command: string,
+): Promise<{ commandPrefix: string | null } | null> {
+  const parsed = await parsePowerShellCommand(command)
+  if (!parsed.valid) {
+    return null
+  }
+
+  // Find the first actual command (CommandAst). getAllCommands iterates
+  // both statement.commands and statement.nestedCommands (for &&/||/if/for).
+  // Skip synthetic CommandExpressionAst entries (expression pipeline sources,
+  // non-PipelineAst statement placeholders).
+  const firstCommand = getAllCommands(parsed).find(
+    cmd => cmd.elementType === 'CommandAst',
+  )
+  if (!firstCommand) {
+    return { commandPrefix: null }
+  }
+
+  return { commandPrefix: await extractPrefixFromElement(firstCommand) }
+}
+
+/**
+ * Extract prefixes for all subcommands in a compound PowerShell command.
+ *
+ * For `Get-Process; git status && npm test`, returns per-subcommand prefixes.
+ * Subcommands for which `excludeSubcommand` returns true (e.g. already
+ * read-only/auto-allowed) are skipped — no point suggesting a rule for them.
+ * Prefixes sharing a root are collapsed via word-aligned LCP:
+ * `npm run test && npm run lint` → `npm run`.
+ *
+ * The filter receives the ParsedCommandElement (not cmd.text) because
+ * PowerShell's read-only check (isAllowlistedCommand) needs the element's
+ * structured fields (nameType, args). Passing text would require reparsing,
+ * which spawns pwsh.exe per subcommand — expensive and wasteful since we
+ * already have the parsed elements here. Bash's equivalent passes text
+ * because BashTool.isReadOnly works from regex/patterns, not parsed AST.
+ */
+export async function getCompoundCommandPrefixesStatic(
+  command: string,
+  excludeSubcommand?: (element: ParsedCommandElement) => boolean,
+): Promise<string[]> {
+  const parsed = await parsePowerShellCommand(command)
+  if (!parsed.valid) {
+    return []
+  }
+
+  const commands = getAllCommands(parsed).filter(
+    cmd => cmd.elementType === 'CommandAst',
+  )
+
+  // Single command — no compound collapse needed.
+  if (commands.length <= 1) {
+    const prefix = commands[0]
+      ? await extractPrefixFromElement(commands[0])
+      : null
+    return prefix ? [prefix] : []
+  }
+
+  const prefixes: string[] = []
+  for (const cmd of commands) {
+    if (excludeSubcommand?.(cmd)) {
+      continue
+    }
+    const prefix = await extractPrefixFromElement(cmd)
+    if (prefix) {
+      prefixes.push(prefix)
+    }
+  }
+
+  if (prefixes.length === 0) {
+    return []
+  }
+
+  // Group by root command (first word) and collapse each group via
+  // word-aligned longest common prefix. `npm run test` + `npm run lint`
+  // → `npm run`. But NEVER collapse down to a bare subcommand-aware root:
+  // `git add` + `git commit` would LCP to `git`, which extractPrefixFromElement
+  // explicitly refuses as too broad (line ~119). Collapsing through that gate
+  // would suggest PowerShell(git:*) → auto-allows git push --force forever.
+  // When LCP yields a bare subcommand-aware root, drop the group entirely
+  // rather than suggest either the too-broad root or N un-collapsed rules.
+  //
+  // Bash's getCompoundCommandPrefixesStatic has this same collapse without
+  // the guard (src/utils/bash/prefix.ts:360-365) — that's a separate fix.
+  //
+  // Grouping and word-comparison are case-insensitive (PowerShell is
+  // case-insensitive: Git === git, Get-Process === get-process). The Map key
+  // is lowercased; the emitted prefix keeps the first-seen casing.
+  const groups = new Map<string, string[]>()
+  for (const prefix of prefixes) {
+    const root = prefix.split(' ')[0]!
+    const key = root.toLowerCase()
+    const group = groups.get(key)
+    if (group) {
+      group.push(prefix)
+    } else {
+      groups.set(key, [prefix])
+    }
+  }
+
+  const collapsed: string[] = []
+  for (const [rootLower, group] of groups) {
+    const lcp = wordAlignedLCP(group)
+    const lcpWordCount = lcp === '' ? 0 : countCharInString(lcp, ' ') + 1
+    if (lcpWordCount <= 1) {
+      // LCP collapsed to a single word. If that root's fig spec declares
+      // subcommands, this is the same too-broad case extractPrefixFromElement
+      // rejects (bare `git` → allows `git push --force`). Drop the group.
+      // getCommandSpec is LRU-memoized; one lookup per distinct root.
+      const rootSpec = await getCommandSpec(rootLower)
+      if (rootSpec?.subcommands?.length || DEPTH_RULES[rootLower]) {
+        continue
+      }
+    }
+    collapsed.push(lcp)
+  }
+  return collapsed
+}
+
+/**
+ * Word-aligned longest common prefix. Doesn't chop mid-word.
+ * Case-insensitive comparison (PowerShell: Git === git), emits first
+ * string's casing.
+ * ["npm run test", "npm run lint"] → "npm run"
+ * ["Git status", "git log"] → "Git" (first-seen casing)
+ * ["Get-Process"] → "Get-Process"
+ */
+function wordAlignedLCP(strings: string[]): string {
+  if (strings.length === 0) return ''
+  if (strings.length === 1) return strings[0]!
+
+  const firstWords = strings[0]!.split(' ')
+  let commonWordCount = firstWords.length
+
+  for (let i = 1; i < strings.length; i++) {
+    const words = strings[i]!.split(' ')
+    let matchCount = 0
+    while (
+      matchCount < commonWordCount &&
+      matchCount < words.length &&
+      words[matchCount]!.toLowerCase() === firstWords[matchCount]!.toLowerCase()
+    ) {
+      matchCount++
+    }
+    commonWordCount = matchCount
+    if (commonWordCount === 0) break
+  }
+
+  return firstWords.slice(0, commonWordCount).join(' ')
+}

package/src/utils/preflightChecks.tsx

@@ -0,0 +1,151 @@
+import { c as _c } from "react/compiler-runtime";
+import axios from 'axios';
+import React, { useEffect, useState } from 'react';
+import { logEvent } from 'src/services/analytics/index.js';
+import { Spinner } from '../components/Spinner.js';
+import { getOauthConfig } from '../constants/oauth.js';
+import { useTimeout } from '../hooks/useTimeout.js';
+import { Box, Text } from '../ink.js';
+import { getSSLErrorHint } from '../services/api/errorUtils.js';
+import { getUserAgent } from './http.js';
+import { logError } from './log.js';
+export interface PreflightCheckResult {
+  success: boolean;
+  error?: string;
+  sslHint?: string;
+}
+async function checkEndpoints(): Promise<PreflightCheckResult> {
+  try {
+    const oauthConfig = getOauthConfig();
+    const tokenUrl = new URL(oauthConfig.TOKEN_URL);
+    const endpoints = [`${oauthConfig.BASE_API_URL}/api/hello`, `${tokenUrl.origin}/v1/oauth/hello`];
+    const checkEndpoint = async (url: string): Promise<PreflightCheckResult> => {
+      try {
+        const response = await axios.get(url, {
+          headers: {
+            'User-Agent': getUserAgent()
+          }
+        });
+        if (response.status !== 200) {
+          const hostname = new URL(url).hostname;
+          return {
+            success: false,
+            error: `Failed to connect to ${hostname}: Status ${response.status}`
+          };
+        }
+        return {
+          success: true
+        };
+      } catch (error) {
+        const hostname = new URL(url).hostname;
+        const sslHint = getSSLErrorHint(error);
+        return {
+          success: false,
+          error: `Failed to connect to ${hostname}: ${error instanceof Error ? (error as ErrnoException).code || error.message : String(error)}`,
+          sslHint: sslHint ?? undefined
+        };
+      }
+    };
+    const results = await Promise.all(endpoints.map(checkEndpoint));
+    const failedResult = results.find(result => !result.success);
+    if (failedResult) {
+      // Log failure to Statsig
+      logEvent('tengu_preflight_check_failed', {
+        isConnectivityError: false,
+        hasErrorMessage: !!failedResult.error,
+        isSSLError: !!failedResult.sslHint
+      });
+    }
+    return failedResult || {
+      success: true
+    };
+  } catch (error) {
+    logError(error as Error);
+
+    // Log to Statsig
+    logEvent('tengu_preflight_check_failed', {
+      isConnectivityError: true
+    });
+    return {
+      success: false,
+      error: `Connectivity check error: ${error instanceof Error ? (error as ErrnoException).code || error.message : String(error)}`
+    };
+  }
+}
+interface PreflightStepProps {
+  onSuccess: () => void;
+}
+export function PreflightStep(t0) {
+  const $ = _c(12);
+  const {
+    onSuccess
+  } = t0;
+  const [result, setResult] = useState(null);
+  const [isChecking, setIsChecking] = useState(true);
+  const showSpinner = useTimeout(1000) && isChecking;
+  let t1;
+  let t2;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => {
+      const run = async function run() {
+        const checkResult = await checkEndpoints();
+        setResult(checkResult);
+        setIsChecking(false);
+      };
+      run();
+    };
+    t2 = [];
+    $[0] = t1;
+    $[1] = t2;
+  } else {
+    t1 = $[0];
+    t2 = $[1];
+  }
+  useEffect(t1, t2);
+  let t3;
+  let t4;
+  if ($[2] !== onSuccess || $[3] !== result) {
+    t3 = () => {
+      if (result?.success) {
+        onSuccess();
+      } else {
+        if (result && !result.success) {
+          const timer = setTimeout(_temp, 100);
+          return () => clearTimeout(timer);
+        }
+      }
+    };
+    t4 = [result, onSuccess];
+    $[2] = onSuccess;
+    $[3] = result;
+    $[4] = t3;
+    $[5] = t4;
+  } else {
+    t3 = $[4];
+    t4 = $[5];
+  }
+  useEffect(t3, t4);
+  let t5;
+  if ($[6] !== isChecking || $[7] !== result || $[8] !== showSpinner) {
+    t5 = isChecking && showSpinner ? <Box paddingLeft={1}><Spinner /><Text>Checking connectivity...</Text></Box> : !result?.success && !isChecking && <Box flexDirection="column" gap={1}><Text color="error">Unable to connect to Anthropic services</Text><Text color="error">{result?.error}</Text>{result?.sslHint ? <Box flexDirection="column" gap={1}><Text>{result.sslHint}</Text><Text color="suggestion">See https://code.claude.com/docs/en/network-config</Text></Box> : <Box flexDirection="column" gap={1}><Text>Please check your internet connection and network settings.</Text><Text>Note: Claude Code might not be available in your country. Check supported countries at{" "}<Text color="suggestion">https://anthropic.com/supported-countries</Text></Text></Box>}</Box>;
+    $[6] = isChecking;
+    $[7] = result;
+    $[8] = showSpinner;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  let t6;
+  if ($[10] !== t5) {
+    t6 = <Box flexDirection="column" gap={1} paddingLeft={1}>{t5}</Box>;
+    $[10] = t5;
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  return t6;
+}
+function _temp() {
+  return process.exit(1);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["axios","React","useEffect","useState","logEvent","Spinner","getOauthConfig","useTimeout","Box","Text","getSSLErrorHint","getUserAgent","logError","PreflightCheckResult","success","error","sslHint","checkEndpoints","Promise","oauthConfig","tokenUrl","URL","TOKEN_URL","endpoints","BASE_API_URL","origin","checkEndpoint","url","response","get","headers","status","hostname","Error","ErrnoException","code","message","String","undefined","results","all","map","failedResult","find","result","isConnectivityError","hasErrorMessage","isSSLError","PreflightStepProps","onSuccess","PreflightStep","t0","$","_c","setResult","isChecking","setIsChecking","showSpinner","t1","t2","Symbol","for","run","checkResult","t3","t4","timer","setTimeout","_temp","clearTimeout","t5","t6","process","exit"],"sources":["preflightChecks.tsx"],"sourcesContent":["import axios from 'axios'\nimport React, { useEffect, useState } from 'react'\nimport { logEvent } from 'src/services/analytics/index.js'\nimport { Spinner } from '../components/Spinner.js'\nimport { getOauthConfig } from '../constants/oauth.js'\nimport { useTimeout } from '../hooks/useTimeout.js'\nimport { Box, Text } from '../ink.js'\nimport { getSSLErrorHint } from '../services/api/errorUtils.js'\nimport { getUserAgent } from './http.js'\nimport { logError } from './log.js'\n\nexport interface PreflightCheckResult {\n  success: boolean\n  error?: string\n  sslHint?: string\n}\n\nasync function checkEndpoints(): Promise<PreflightCheckResult> {\n  try {\n    const oauthConfig = getOauthConfig()\n    const tokenUrl = new URL(oauthConfig.TOKEN_URL)\n    const endpoints = [\n      `${oauthConfig.BASE_API_URL}/api/hello`,\n      `${tokenUrl.origin}/v1/oauth/hello`,\n    ]\n\n    const checkEndpoint = async (\n      url: string,\n    ): Promise<PreflightCheckResult> => {\n      try {\n        const response = await axios.get(url, {\n          headers: { 'User-Agent': getUserAgent() },\n        })\n        if (response.status !== 200) {\n          const hostname = new URL(url).hostname\n          return {\n            success: false,\n            error: `Failed to connect to ${hostname}: Status ${response.status}`,\n          }\n        }\n        return { success: true }\n      } catch (error) {\n        const hostname = new URL(url).hostname\n        const sslHint = getSSLErrorHint(error)\n        return {\n          success: false,\n          error: `Failed to connect to ${hostname}: ${error instanceof Error ? (error as ErrnoException).code || error.message : String(error)}`,\n          sslHint: sslHint ?? undefined,\n        }\n      }\n    }\n\n    const results = await Promise.all(endpoints.map(checkEndpoint))\n    const failedResult = results.find(result => !result.success)\n\n    if (failedResult) {\n      // Log failure to Statsig\n      logEvent('tengu_preflight_check_failed', {\n        isConnectivityError: false,\n        hasErrorMessage: !!failedResult.error,\n        isSSLError: !!failedResult.sslHint,\n      })\n    }\n\n    return failedResult || { success: true }\n  } catch (error) {\n    logError(error as Error)\n\n    // Log to Statsig\n    logEvent('tengu_preflight_check_failed', {\n      isConnectivityError: true,\n    })\n\n    return {\n      success: false,\n      error: `Connectivity check error: ${error instanceof Error ? (error as ErrnoException).code || error.message : String(error)}`,\n    }\n  }\n}\n\ninterface PreflightStepProps {\n  onSuccess: () => void\n}\n\nexport function PreflightStep({\n  onSuccess,\n}: PreflightStepProps): React.ReactNode {\n  const [result, setResult] = useState<PreflightCheckResult | null>(null)\n  const [isChecking, setIsChecking] = useState(true)\n\n  // delay showing the check since it's so fast that we normally\n  // want to just immediately show the next step without a flash\n  const showSpinner = useTimeout(1000) && isChecking\n\n  useEffect(() => {\n    async function run() {\n      const checkResult = await checkEndpoints()\n      setResult(checkResult)\n      setIsChecking(false)\n    }\n    void run()\n  }, [])\n\n  useEffect(() => {\n    if (result?.success) {\n      onSuccess()\n    } else if (result && !result.success) {\n      const timer = setTimeout(() => process.exit(1), 100)\n      return () => clearTimeout(timer)\n    }\n  }, [result, onSuccess])\n\n  return (\n    <Box flexDirection=\"column\" gap={1} paddingLeft={1}>\n      {isChecking && showSpinner ? (\n        <Box paddingLeft={1}>\n          <Spinner />\n          <Text>Checking connectivity...</Text>\n        </Box>\n      ) : (\n        !result?.success &&\n        !isChecking && (\n          <Box flexDirection=\"column\" gap={1}>\n            <Text color=\"error\">Unable to connect to Anthropic services</Text>\n            <Text color=\"error\">{result?.error}</Text>\n            {result?.sslHint ? (\n              <Box flexDirection=\"column\" gap={1}>\n                <Text>{result.sslHint}</Text>\n                <Text color=\"suggestion\">\n                  See https://code.claude.com/docs/en/network-config\n                </Text>\n              </Box>\n            ) : (\n              <Box flexDirection=\"column\" gap={1}>\n                <Text>\n                  Please check your internet connection and network settings.\n                </Text>\n                <Text>\n                  Note: Claude Code might not be available in your country.\n                  Check supported countries at{' '}\n                  <Text color=\"suggestion\">\n                    https://anthropic.com/supported-countries\n                  </Text>\n                </Text>\n              </Box>\n            )}\n          </Box>\n        )\n      )}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/utils/privacyLevel.ts

@@ -0,0 +1,55 @@
+/**
+ * Privacy level controls how much nonessential network traffic and telemetry
+ * Claude Code generates.
+ *
+ * Levels are ordered by restrictiveness:
+ *   default < no-telemetry < essential-traffic
+ *
+ * - default:            Everything enabled.
+ * - no-telemetry:       Analytics/telemetry disabled (Datadog, 1P events, feedback survey).
+ * - essential-traffic:  ALL nonessential network traffic disabled
+ *                       (telemetry + auto-updates, grove, release notes, model capabilities, etc.).
+ *
+ * The resolved level is the most restrictive signal from:
+ *   CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC  →  essential-traffic
+ *   DISABLE_TELEMETRY                         →  no-telemetry
+ */
+
+type PrivacyLevel = 'default' | 'no-telemetry' | 'essential-traffic'
+
+export function getPrivacyLevel(): PrivacyLevel {
+  if (process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC) {
+    return 'essential-traffic'
+  }
+  if (process.env.DISABLE_TELEMETRY) {
+    return 'no-telemetry'
+  }
+  return 'default'
+}
+
+/**
+ * True when all nonessential network traffic should be suppressed.
+ * Equivalent to the old `process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` check.
+ */
+export function isEssentialTrafficOnly(): boolean {
+  return getPrivacyLevel() === 'essential-traffic'
+}
+
+/**
+ * True when telemetry/analytics should be suppressed.
+ * True at both `no-telemetry` and `essential-traffic` levels.
+ */
+export function isTelemetryDisabled(): boolean {
+  return getPrivacyLevel() !== 'default'
+}
+
+/**
+ * Returns the env var name responsible for the current essential-traffic restriction,
+ * or null if unrestricted. Used for user-facing "unset X to re-enable" messages.
+ */
+export function getEssentialTrafficOnlyReason(): string | null {
+  if (process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC) {
+    return 'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC'
+  }
+  return null
+}

package/src/utils/process.ts

@@ -0,0 +1,68 @@
+function handleEPIPE(
+  stream: NodeJS.WriteStream,
+): (err: NodeJS.ErrnoException) => void {
+  return (err: NodeJS.ErrnoException) => {
+    if (err.code === 'EPIPE') {
+      stream.destroy()
+    }
+  }
+}
+
+// Prevents memory leak when pipe is broken (e.g., `claude -p | head -1`)
+export function registerProcessOutputErrorHandlers(): void {
+  process.stdout.on('error', handleEPIPE(process.stdout))
+  process.stderr.on('error', handleEPIPE(process.stderr))
+}
+
+function writeOut(stream: NodeJS.WriteStream, data: string): void {
+  if (stream.destroyed) {
+    return
+  }
+
+  // Note: we don't handle backpressure (write() returning false).
+  //
+  // We should consider handling the callback to ensure we wait for data to flush.
+  stream.write(data /* callback to handle here */)
+}
+
+export function writeToStdout(data: string): void {
+  writeOut(process.stdout, data)
+}
+
+export function writeToStderr(data: string): void {
+  writeOut(process.stderr, data)
+}
+
+// Write error to stderr and exit with code 1. Consolidates the
+// console.error + process.exit(1) pattern used in entrypoint fast-paths.
+export function exitWithError(message: string): never {
+  // biome-ignore lint/suspicious/noConsole:: intentional console output
+  console.error(message)
+  // eslint-disable-next-line custom-rules/no-process-exit
+  process.exit(1)
+}
+
+// Wait for a stdin-like stream to close, but give up after ms if no data ever
+// arrives. First data chunk cancels the timeout — after that, wait for end
+// unconditionally (caller's accumulator needs all chunks, not just the first).
+// Returns true on timeout, false on end. Used by -p mode to distinguish a
+// real pipe producer from an inherited-but-idle parent stdin.
+export function peekForStdinData(
+  stream: NodeJS.EventEmitter,
+  ms: number,
+): Promise<boolean> {
+  return new Promise<boolean>(resolve => {
+    const done = (timedOut: boolean) => {
+      clearTimeout(peek)
+      stream.off('end', onEnd)
+      stream.off('data', onFirstData)
+      void resolve(timedOut)
+    }
+    const onEnd = () => done(false)
+    const onFirstData = () => clearTimeout(peek)
+    // eslint-disable-next-line no-restricted-syntax -- not a sleep: races timeout against stream end/data events
+    const peek = setTimeout(done, ms, true)
+    stream.once('end', onEnd)
+    stream.once('data', onFirstData)
+  })
+}