@raidiant/notifai 10.1.1 → 10.1.2

package/src/commands-config.ts

@@ -1,336 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs'
-import path from 'node:path'
-import { parse as parseToml, stringify as stringifyToml } from 'smol-toml'
-import { ensurePrivateDirectory } from './atomic-file.js'
-import { acceptedValues, configInfo } from './config-schema.js'
-import {
-  BOOLEAN_CONFIG_KEYS,
-  CONFIG_KEYS,
-  NUMERIC_CONFIG_KEYS,
-  ORIGIN_LIST_CONFIG_KEYS,
-  USER_OWNED_CONFIG_KEYS,
-  configBounds,
-  configDefaultValue,
-  findProjectConfigPath,
-  globalConfigPath,
-  personalProjectConfigPath,
-  sessionConfigPath,
-  type ConfigKey,
-} from './config.js'
-import { normalizeOrigin } from './url-policy.js'
-import { renderConfigExplain, renderConfigList, renderConfigPlain } from './ui/config-view.js'
-import { EXIT, loadLoggedConfig, type CommandDeps } from './commands-core.js'
-import { isCliSoundRef } from './sound-ref.js'
-
-// ---------------------------------------------------------------------------
-// config show / set / unset
-// ---------------------------------------------------------------------------
-
-export function configShowCommand(
-  deps: CommandDeps,
-  flags: { json?: boolean; explain?: boolean; plain?: boolean },
-): number {
-  const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env })
-  if (flags.json) {
-    const output = Object.fromEntries(
-      CONFIG_KEYS.map((key) => [
-        key,
-        {
-          value: config[key].value,
-          source: config[key].source,
-          summary: configInfo(key).summary,
-        },
-      ]),
-    )
-    deps.io.out(JSON.stringify(output, null, 2))
-    return EXIT.ok
-  }
-  // Anything that is not a person at a terminal keeps the flat `key = value`
-  // form it has always had. Scripts parse this, and a prettier layout for an
-  // audience that cannot see it would only be a breaking change.
-  if (deps.io.interactive !== true || flags.plain === true) {
-    for (const line of renderConfigPlain(config, flags.explain === true)) deps.io.out(line)
-    return EXIT.ok
-  }
-  for (const line of renderConfigList(config, { showAdvanced: flags.explain === true })) {
-    deps.io.out(line)
-  }
-  return EXIT.ok
-}
-
-/**
- * One setting, explained in full.
- *
- * The gap this closes: `config show` prints a value and provenance but that is
- * not enough to explain the setting's consequences. Every key already had a
- * careful explanation — in a TypeScript comment, read by everyone except the
- * person who needed it.
- */
-export function configExplainCommand(
-  deps: CommandDeps,
-  key: string,
-  flags: { json?: boolean } = {},
-): number {
-  if (!(CONFIG_KEYS as readonly string[]).includes(key)) {
-    deps.io.err(`Unknown setting "${key}".`)
-    deps.io.err(`Valid settings: ${CONFIG_KEYS.join(', ')}`)
-    return EXIT.usage
-  }
-  const configKey = key as ConfigKey
-  const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env })
-  const info = configInfo(configKey)
-  const entry = config[configKey]
-
-  if (flags.json) {
-    deps.io.out(
-      JSON.stringify(
-        {
-          key: configKey,
-          label: info.label,
-          group: info.group,
-          kind: info.kind,
-          summary: info.summary,
-          detail: info.detail,
-          accepts: acceptedValues(configKey),
-          ...(info.choices !== undefined ? { choices: info.choices } : {}),
-          value: entry.value,
-          source: entry.source,
-        },
-        null,
-        2,
-      ),
-    )
-    return EXIT.ok
-  }
-
-  if (deps.io.interactive !== true) {
-    deps.io.out(`${configKey} = ${JSON.stringify(entry.value)}  [${entry.source}]`)
-    deps.io.out(info.detail.replace(/\n\n/g, '\n'))
-    deps.io.out(`accepts: ${acceptedValues(configKey)}`)
-    return EXIT.ok
-  }
-  for (const line of renderConfigExplain(configKey, config)) deps.io.out(line)
-  return EXIT.ok
-}
-
-/**
- * Closest config key by edit distance, or null when nothing is close.
- *
- * The threshold matters more than the algorithm: suggesting a key that shares
- * three letters with the typo sends the reader to the wrong setting with
- * confidence, which is worse than listing all fourteen and letting them look.
- */
-function nearestKey(input: string): string | null {
-  let best: string | null = null
-  let bestDistance = Number.POSITIVE_INFINITY
-  for (const candidate of CONFIG_KEYS) {
-    const distance = editDistance(input.toLowerCase(), candidate)
-    if (distance < bestDistance) {
-      bestDistance = distance
-      best = candidate
-    }
-  }
-  return best !== null && bestDistance <= Math.max(2, Math.floor(best.length / 3)) ? best : null
-}
-
-function editDistance(a: string, b: string): number {
-  const previous = Array.from({ length: b.length + 1 }, (_, i) => i)
-  for (let i = 1; i <= a.length; i += 1) {
-    let diagonal = previous[0]!
-    previous[0] = i
-    for (let j = 1; j <= b.length; j += 1) {
-      const above = previous[j]!
-      previous[j] = Math.min(
-        previous[j]! + 1,
-        previous[j - 1]! + 1,
-        diagonal + (a[i - 1] === b[j - 1] ? 0 : 1),
-      )
-      diagonal = above
-    }
-  }
-  return previous[b.length]!
-}
-
-export async function configSetCommand(
-  deps: CommandDeps,
-  key: string,
-  rawValue: string,
-  flags: { project?: boolean; local?: boolean; session?: string; yes?: boolean },
-): Promise<number> {
-  const configKey = configMutationKey(deps, key)
-  if (configKey === null) return EXIT.usage
-  const info = configInfo(configKey)
-  let value: unknown = rawValue
-  if (NUMERIC_CONFIG_KEYS.includes(configKey)) {
-    const numeric = Number(rawValue)
-    if (!Number.isInteger(numeric)) {
-      deps.io.err(`${key} takes ${acceptedValues(configKey)}, not "${rawValue}".`)
-      return EXIT.usage
-    }
-    const bounds = configBounds(configKey)
-    if (bounds !== undefined && (numeric < bounds.min || numeric > bounds.max)) {
-      deps.io.err(`${key} must be between ${bounds.min} and ${bounds.max}.`)
-      return EXIT.usage
-    }
-    value = numeric
-  }
-  if (BOOLEAN_CONFIG_KEYS.includes(configKey)) {
-    if (rawValue !== 'true' && rawValue !== 'false') {
-      deps.io.err(`${key} is a toggle — pass "true" or "false", not "${rawValue}".`)
-      return EXIT.usage
-    }
-    value = rawValue === 'true'
-  }
-  // Sound is listed as an enum of shipped names so the interactive picker has
-  // choices, but it also accepts an Account custom name or id. Other enum keys
-  // stay closed: an unrecognised value used to be written and only fail at send.
-  if (configKey === 'sound') {
-    if (!isCliSoundRef(rawValue)) {
-      deps.io.err(`${key} takes ${acceptedValues(configKey)} — not "${rawValue}".`)
-      return EXIT.usage
-    }
-  } else if (info.kind === 'enum' && info.choices !== undefined && !info.choices.includes(rawValue)) {
-    deps.io.err(`${key} takes one of: ${info.choices.join(', ')} — not "${rawValue}".`)
-    return EXIT.usage
-  }
-  if (info.kind === 'list') value = rawValue.split(',').map((s) => s.trim()).filter(Boolean)
-  if (ORIGIN_LIST_CONFIG_KEYS.includes(configKey)) {
-    const origins = (value as string[]).map((entry) => normalizeOrigin(entry))
-    const rejected = (value as string[]).filter((_, index) => origins[index] === null)
-    if (rejected.length > 0) {
-      deps.io.err(
-        `${key} entries must be bare http(s) origins like "https://host" or "http://host:8080" — not ${rejected.map((entry) => `"${entry}"`).join(', ')}.`,
-      )
-      return EXIT.usage
-    }
-    value = origins
-  }
-
-  const target = await configMutationTarget(deps, flags)
-  if (target === null) return EXIT.usage
-  if (target.layer === 'project' && USER_OWNED_CONFIG_KEYS.includes(configKey)) {
-    deps.io.err(
-      `${key} widens which origins this machine trusts, so it is never read from the repository's shared config — a cloned repository must not be able to set it.`,
-    )
-    deps.io.err('Store it on this machine (no flag) or for this project personally (--local).')
-    return EXIT.usage
-  }
-  if (target.layer === 'global' && Object.is(value, configDefaultValue(configKey))) {
-    deps.io.err(`${key} is already the shipped default (${JSON.stringify(value)}).`)
-    deps.io.err(
-      `Run \`notifai config unset ${key} --yes\` to remove a redundant override instead of creating one.`,
-    )
-    return EXIT.usage
-  }
-
-  if (!flags.yes) {
-    const confirmed = await deps.io.confirm(`Set ${key} = ${JSON.stringify(value)} in ${target.path}?`)
-    if (!confirmed) {
-      deps.io.err('Not confirmed. Pass --yes to skip the confirmation gate.')
-      return EXIT.usage
-    }
-  }
-
-  const existing = existsSync(target.path)
-    ? (parseToml(readFileSync(target.path, 'utf8')) as Record<string, unknown>)
-    : {}
-  existing[key] = value
-  if (target.layer === 'project') mkdirSync(path.dirname(target.path), { recursive: true })
-  else ensurePrivateDirectory(path.dirname(target.path))
-  writeFileSync(target.path, `${stringifyToml(existing)}\n`)
-  deps.io.out(`Wrote ${key} to ${target.path}`)
-  return EXIT.ok
-}
-
-function configMutationKey(deps: CommandDeps, key: string): ConfigKey | null {
-  if (!(CONFIG_KEYS as readonly string[]).includes(key)) {
-    deps.io.err(`Unknown setting "${key}".`)
-    const near = nearestKey(key)
-    if (near !== null) deps.io.err(`Did you mean "${near}"?`)
-    deps.io.err(`Valid settings: ${CONFIG_KEYS.join(', ')}`)
-    deps.io.err('Run `notifai config explain <key>` to see what one of them does.')
-    return null
-  }
-  return key as ConfigKey
-}
-
-type ConfigMutationFlags = { project?: boolean; local?: boolean; session?: string; yes?: boolean }
-type ConfigMutationLayer = 'global' | 'project' | 'local' | 'session'
-
-async function configMutationTarget(
-  deps: CommandDeps,
-  flags: ConfigMutationFlags,
-): Promise<{ path: string; layer: ConfigMutationLayer } | null> {
-  let layer = flags.local ? 'local' : flags.project ? 'project' : 'global'
-  if (
-    flags.session === undefined &&
-    flags.local !== true &&
-    flags.project !== true &&
-    flags.yes !== true &&
-    deps.io.interactive === true &&
-    deps.io.select
-  ) {
-    const selected = await deps.io.select('Where should this setting live?', [
-      { value: 'global', label: 'This machine', hint: 'applies across projects' },
-      { value: 'project', label: 'This project (shared)', hint: '.notifai/config.toml' },
-      { value: 'local', label: 'This project (personal)', hint: 'stored on this machine, not in the repo' },
-    ])
-    if (selected === null) {
-      deps.io.err('No configuration layer selected.')
-      return null
-    }
-    layer = selected
-  }
-
-  const targetPath = flags.session
-    ? sessionConfigPath(flags.session, deps.env)
-    : layer === 'local'
-      ? personalProjectConfigPath(deps.cwd, deps.env)
-      : layer === 'project'
-        ? (findProjectConfigPath(deps.cwd) ?? path.join(deps.cwd, '.notifai', 'config.toml'))
-        : globalConfigPath(deps.env)
-  return {
-    path: targetPath,
-    layer: flags.session ? 'session' : (layer as Exclude<ConfigMutationLayer, 'session'>),
-  }
-}
-
-export async function configUnsetCommand(
-  deps: CommandDeps,
-  key: string,
-  flags: ConfigMutationFlags,
-): Promise<number> {
-  const configKey = configMutationKey(deps, key)
-  if (configKey === null) return EXIT.usage
-  const target = await configMutationTarget(deps, flags)
-  if (target === null) return EXIT.usage
-  const existing = existsSync(target.path)
-    ? (parseToml(readFileSync(target.path, 'utf8')) as Record<string, unknown>)
-    : {}
-  if (!Object.prototype.hasOwnProperty.call(existing, configKey)) {
-    deps.io.out(`${configKey} is not set in ${target.path}`)
-    return EXIT.ok
-  }
-  if (!flags.yes) {
-    const confirmed = await deps.io.confirm(`Remove ${configKey} from ${target.path}?`)
-    if (!confirmed) {
-      deps.io.err('Not confirmed. Pass --yes to skip the confirmation gate.')
-      return EXIT.usage
-    }
-  }
-
-  delete existing[configKey]
-  if (Object.keys(existing).length === 0) {
-    rmSync(target.path, { force: true })
-  } else {
-    writeFileSync(target.path, `${stringifyToml(existing)}\n`)
-  }
-  deps.io.out(`Removed ${configKey} from ${target.path}; the inherited value now applies.`)
-  return EXIT.ok
-}

package/src/commands-core.ts

@@ -1,312 +0,0 @@
-import { SHIPPED_CLI_CAPABILITIES, type RecoveryAction } from '@raidiant/notifai-protocol'
-import { type ClaudeWakeAdapters } from './claude-wake.js'
-import {
-  ApiCallError,
-  NetworkError,
-  createClient,
-  type ApiClient,
-  type ClientOptions,
-} from './client.js'
-import { type CodexWakeAdapters } from './codex-wake.js'
-import { loadConfig, type CliConfig } from './config.js'
-import type { CredentialStore, MachineCredential } from './credentials.js'
-import { type HookAdapterTarget } from './hook-adapter.js'
-import { logConfigResolved, logSettingsFrom, nullLogger, type Logger } from './logging.js'
-import type { NativeSkills } from './native-skills.js'
-import type { OrcaSessionTitleLookup } from './orca-session-title.js'
-import type { QuestionSettlementLaunch } from './question-settlement-process.js'
-import { packageVersion } from './release.js'
-import type { Tone } from './ui/theme.js'
-import { cliUpdateRecoveryCommand } from './cli-update-contract.js'
-
-export interface CommandIo {
-  out(line: string): void
-  err(line: string): void
-  /** Interactive confirmation; resolves `fallback` (default false) when not interactive. */
-  confirm(question: string, fallback?: boolean): Promise<boolean>
-  openUrl(url: string): void
-  /**
-   * True only when a human is demonstrably driving a terminal. Everything below
-   * is optional sugar that MUST only be called behind this flag: an agent that
-   * reaches an interactive prompt does not error, it hangs — the prompt
-   * libraries wait on stdin for ever — so the gate is bypass, not handling.
-   * Test fakes leave all of this undefined and exercise the plain paths.
-   */
-  interactive?: boolean
-  select?(message: string, options: { value: string; label: string; hint?: string }[]): Promise<string | null>
-  /** Interactive multi-select. `initial` are pre-selected values. */
-  multiselect?(
-    message: string,
-    options: { value: string; label: string; hint?: string }[],
-    initial?: string[],
-  ): Promise<string[] | null>
-  intro?(title: string): Promise<void>
-  outro?(message: string): Promise<void>
-  note?(message: string, title?: string): Promise<void>
-  spinner?(message: string): Promise<CommandSpinner | null>
-  /**
-   * A report line. `tone` distinguishes the two states that are neither pass
-   * nor fail — something optional the user declined, and something that was
-   * never evaluated — which a boolean has to round to one or the other.
-   * Optional so existing implementations keep type-checking.
-   */
-  check?(ok: boolean, message: string, tone?: Tone): Promise<void>
-}
-
-export interface CommandSpinner {
-  message(message: string): void
-  stop(message: string): void
-  error(message: string): void
-}
-
-export interface CommandDeps {
-  io: CommandIo
-  store: CredentialStore
-  env: NodeJS.ProcessEnv
-  cwd: string
-  /** Test seam; production fixes the hook adapter under os.homedir(). */
-  hookAdapterHome?: string
-  /** Test seam; production uses this process's Node and CLI paths. */
-  hookInstallTarget?: HookAdapterTarget
-  /** Test seam; production uses process.platform for adapter format and quoting. */
-  hookPlatform?: NodeJS.Platform
-  /** Test seam; production uses fetch against base_url. */
-  clientFactory?: (baseUrl: string, bearer: string | null, options?: ClientOptions) => ApiClient
-  /** Test seam for bounded polling without wall-clock sleeps. */
-  now?: () => number
-  /** Test seam for retry/backoff timing. */
-  sleep?: (milliseconds: number) => Promise<void>
-  /** Test seams for Claude liveness, socket delivery, and cold resume. */
-  claudeWake?: ClaudeWakeAdapters
-  claudeSourcePid?: number
-  /** Test seams for the Codex thread-writer probe and cold resume. */
-  codexWake?: CodexWakeAdapters
-  codexSourcePid?: number
-  /** Test seam for the detached owner recovered from a pre-Stop User prompt. */
-  spawnQuestionSettlement?: (launch: QuestionSettlementLaunch) => void
-  /** Test seam and production adapter for the external native skills installer. */
-  nativeSkills?: NativeSkills
-  /** Test seam for Orca's exact-worktree task/session title lookup. */
-  orcaSessionTitle?: OrcaSessionTitleLookup
-  /** Test seam for registry reads; production uses fetch. */
-  fetchImpl?: typeof fetch
-  /**
-   * The local record of what this invocation did. Optional so a test fake need
-   * not carry one; `log(deps)` supplies a logger that records nothing.
-   */
-  logger?: Logger
-}
-
-/** The invocation's logger, or one that discards everything. */
-export function log(deps: CommandDeps): Logger {
-  return deps.logger ?? nullLogger()
-}
-
-export function loadLoggedConfig(
-  deps: CommandDeps,
-  options: Parameters<typeof loadConfig>[0],
-): CliConfig {
-  const config = loadConfig(options)
-  const logger = log(deps)
-  logger.adopt(logSettingsFrom(config))
-  logger.bind({ project: config.project.value })
-  logConfigResolved(logger, config)
-  return config
-}
-
-export const EXIT = {
-  ok: 0,
-  failed: 1,
-  usage: 2,
-  noReply: 3,
-  auth: 4,
-  network: 5,
-} as const
-
-export function makeClient(
-  deps: CommandDeps,
-  baseUrl: string,
-  bearer: string | null,
-  options?: ClientOptions,
-): ApiClient {
-  return (deps.clientFactory ?? createClient)(baseUrl, bearer, {
-    ...options,
-    logger: log(deps),
-    cliVersion: packageVersion(),
-    capabilities: SHIPPED_CLI_CAPABILITIES,
-  })
-}
-
-export function resolvedBaseUrl(config: CliConfig, credential: MachineCredential | null): string {
-  return credential ? credential.baseUrl : config.base_url.value
-}
-
-/**
- * Whether a flag or env origin would send signed-in traffic somewhere other
- * than the origin stored with this machine's credential.
- *
- * Login still honours those overrides: pairing has no credential to pin to.
- * Returning the source (not the override URL, and never the bearer) is what
- * lets callers diagnose the ignore without leaking either.
- */
-export function ignoredOriginOverride(
-  config: CliConfig,
-  credential: MachineCredential,
-): CliConfig['base_url']['source'] | null {
-  if (config.base_url.source === 'default') return null
-  if (config.base_url.value === credential.baseUrl) return null
-  return config.base_url.source
-}
-
-export function diagnoseIgnoredOriginOverride(
-  io: Pick<CommandIo, 'err'>,
-  config: CliConfig,
-  credential: MachineCredential,
-): void {
-  const source = ignoredOriginOverride(config, credential)
-  if (source === null) return
-  io.err(
-    `Ignoring base_url from ${source}; authenticated traffic uses the origin stored with this machine's credential. Run \`notifai login\` to pair with a different origin.`,
-  )
-}
-
-export function authedClient(deps: CommandDeps, config: CliConfig): { client: ApiClient; baseUrl: string } | null {
-  const credential = deps.store.load()
-  if (!credential) {
-    // The commonest reason a command does nothing, and one that leaves no other
-    // trace: it returns before any request is made, so without this the log
-    // shows an exit code and no cause.
-    log(deps).error('cli.error', { kind: 'auth', message: 'not signed in', store: deps.store.describe() })
-    deps.io.err('Not signed in. Run `notifai init`; it will coordinate machine login and device setup.')
-    return null
-  }
-  diagnoseIgnoredOriginOverride(deps.io, config, credential)
-  const baseUrl = resolvedBaseUrl(config, credential)
-  return {
-    client: makeClient(deps, baseUrl, `Bearer nfm_${credential.machineId}.${credential.secret}`),
-    baseUrl,
-  }
-}
-
-/**
- * Resolve a current CLI independently of PATH. A bare `notifai update` would
- * be captured by the stale winner this action is meant to repair.
- */
-export function updateCliCommand(_deps: Pick<CommandDeps, 'hookInstallTarget' | 'hookPlatform'>): string {
-  return cliUpdateRecoveryCommand()
-}
-
-/** The one first-run command an unsigned machine is told to run. */
-export const SETUP_COMMAND = 'notifai init'
-
-function affectedDeviceNames(details: unknown): string[] {
-  if (typeof details !== 'object' || details === null || !('device_names' in details)) return []
-  const names = (details as { device_names?: unknown }).device_names
-  if (!Array.isArray(names)) return []
-  return [...new Set(names.filter((name): name is string => typeof name === 'string' && name.trim() !== ''))]
-}
-
-function naturalList(values: readonly string[]): string {
-  if (values.length <= 1) return values[0] ?? ''
-  if (values.length === 2) return `${values[0]} and ${values[1]}`
-  return `${values.slice(0, -1).join(', ')}, and ${values.at(-1)}`
-}
-
-function localRecovery(
-  deps: Pick<CommandDeps, 'hookInstallTarget' | 'hookPlatform'>,
-  action: RecoveryAction | null,
-  details: unknown,
-): string | null {
-  switch (action) {
-    case 'update_cli':
-      return `next: ${updateCliCommand(deps)}`
-    case 'update_companion': {
-      const names = affectedDeviceNames(details)
-      return names.length > 0
-        ? `next: Update Notifai on ${naturalList(names)}.`
-        : 'next: Update Notifai on the affected devices.'
-    }
-    case 'wait_for_service':
-      return 'next: The service is being updated; try again later.'
-    default:
-      return null
-  }
-}
-
-export function reportError(
-  deps: CommandDeps,
-  err: unknown,
-  context: Record<string, unknown> = {},
-): number {
-  // Recorded before it is printed: stderr from an agent's shell call is often
-  // the one thing that does not survive into the next turn, and this is exactly
-  // the line someone comes back looking for.
-  log(deps).error('cli.error', {
-    ...context,
-    ...(err instanceof ApiCallError
-      ? {
-          kind: 'api',
-          status: err.status,
-          code: err.code,
-          message: err.message,
-          next_action: err.nextAction,
-          recovery_action: err.recoveryAction,
-          details: err.details,
-        }
-      : err instanceof NetworkError
-        ? { kind: 'network', message: err.message }
-        : { kind: 'unknown', message: String(err) }),
-  })
-  if (err instanceof ApiCallError) {
-    deps.io.err(
-      deps.io.interactive === true && err.recoveryAction !== null
-        ? err.message
-        : `${err.code}: ${err.message}`,
-    )
-    // The server's field-level details were already being logged above, but
-    // stderr is the one surface an agent's next turn actually reads — so the
-    // diagnosis has to be on it, the same way the hook path prints it.
-    const paths = rejectedPaths(err.details)
-    if (paths.length > 0) deps.io.err(`the server rejected: ${paths.join(', ')}`)
-    // A 422 on a request this CLI built is not a user error: the two sides
-    // disagree about the contract, in whichever direction. `doctor` says which.
-    // Codes that name a policy the account chose are the exception — the
-    // contract held, the body simply did not satisfy that account.
-    if (
-      err.status === 422 &&
-      err.code !== 'acknowledgement_text_required' &&
-      err.code !== 'feature_unavailable'
-    ) {
-      deps.io.err(
-        'this build sent a field the server did not accept — the CLI and server ' +
-          'disagree about the contract; check with `notifai doctor`',
-      )
-    }
-    const recovery =
-      err.code === 'no_active_devices'
-        ? 'next: Run `notifai init` to connect an active Companion App; it will complete machine setup and identify any human-only device step.'
-        : localRecovery(deps, err.recoveryAction, err.details)
-    if (recovery !== null) deps.io.err(recovery)
-    else if (err.recoveryAction === null && err.nextAction) deps.io.err(`next: ${err.nextAction}`)
-    if (err.code === 'auth_required' || err.code === 'machine_revoked') return EXIT.auth
-    return err.status >= 500 ? EXIT.network : EXIT.failed
-  }
-  if (err instanceof NetworkError) {
-    deps.io.err(err.message)
-    return EXIT.network
-  }
-  deps.io.err(String(err))
-  return EXIT.failed
-}
-
-export function rejectedPaths(details: unknown): string[] {
-  if (!Array.isArray(details)) return []
-  return details
-    .map((issue) =>
-      typeof issue === 'object' && issue !== null && typeof (issue as { path?: unknown }).path === 'string'
-        ? (issue as { path: string }).path
-        : null,
-    )
-    .filter((path): path is string => path !== null && path !== '')
-    .slice(0, 5)
-}