@goliapkg/sentori-cli 0.5.1 → 0.5.3

package/src/__tests__/upload.test.ts

@@ -1,121 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-
-import { collectFiles, uploadSourcemaps } from '../upload.js'
-
-let dir = ''
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'sentori-cli-test-'))
-  await writeFile(join(dir, 'main.jsbundle'), '/*bundle*/')
-  await writeFile(join(dir, 'main.jsbundle.map'), '{"version":3}')
-  await writeFile(join(dir, 'app.js'), 'console.log(1)')
-  await writeFile(join(dir, 'app.js.map'), '{"version":3}')
-  await writeFile(join(dir, 'README.txt'), 'not a build artifact')
-})
-afterEach(async () => {
-  await rm(dir, { force: true, recursive: true })
-})
-
-describe('collectFiles', () => {
-  test('a directory yields its .map / .js / .bundle files, not others', async () => {
-    const files = await collectFiles([dir])
-    const names = files.map((f) => f.replace(`${dir}/`, '')).sort()
-    expect(names).toEqual(['app.js', 'app.js.map', 'main.jsbundle', 'main.jsbundle.map'])
-  })
-
-  test('an explicit file is taken as-is regardless of extension', async () => {
-    const files = await collectFiles([join(dir, 'README.txt')])
-    expect(files).toEqual([join(dir, 'README.txt')])
-  })
-
-  test('dedupes when a file is named both directly and via its dir', async () => {
-    const files = await collectFiles([dir, join(dir, 'app.js.map')])
-    expect(files.filter((f) => f.endsWith('app.js.map'))).toHaveLength(1)
-  })
-
-  test('throws on a nonexistent path', async () => {
-    await expect(collectFiles([join(dir, 'nope')])).rejects.toThrow('no such file or directory')
-  })
-
-  test('throws when a directory has no uploadable files', async () => {
-    const empty = await mkdtemp(join(tmpdir(), 'sentori-cli-empty-'))
-    try {
-      await expect(collectFiles([empty])).rejects.toThrow('no .map')
-    } finally {
-      await rm(empty, { force: true, recursive: true })
-    }
-  })
-})
-
-describe('uploadSourcemaps', () => {
-  test('dryRun returns the file list, makes no request', async () => {
-    let called = false
-    const orig = globalThis.fetch
-    globalThis.fetch = (async () => {
-      called = true
-      return new Response()
-    }) as typeof fetch
-    try {
-      const r = await uploadSourcemaps({
-        apiUrl: 'https://api.example.com',
-        dryRun: true,
-        paths: [dir],
-        release: 'app@1.0.0+1',
-        token: 'st_pk_x',
-      })
-      expect(r.files).toHaveLength(4)
-      expect(called).toBe(false)
-    } finally {
-      globalThis.fetch = orig
-    }
-  })
-
-  test('POSTs multipart to /admin/api/releases/<release>/sourcemaps with the token', async () => {
-    const calls: { headers: Headers; url: string }[] = []
-    const orig = globalThis.fetch
-    globalThis.fetch = (async (url: Request | string | URL, init?: RequestInit) => {
-      calls.push({ headers: new Headers(init?.headers), url: String(url) })
-      return new Response(JSON.stringify({ artifacts: [], uploaded: 4 }), {
-        headers: { 'content-type': 'application/json' },
-        status: 200,
-      })
-    }) as typeof fetch
-    try {
-      const r = await uploadSourcemaps({
-        apiUrl: 'https://api.example.com/',
-        paths: [dir],
-        release: 'my app@1.0.0+1',
-        token: 'st_pk_secret',
-      })
-      expect(calls).toHaveLength(1)
-      expect(calls[0]?.url).toBe(
-        'https://api.example.com/admin/api/releases/my%20app%401.0.0%2B1/sourcemaps',
-      )
-      expect(calls[0]?.headers.get('authorization')).toBe('Bearer st_pk_secret')
-      expect(r.uploaded).toBe(4)
-    } finally {
-      globalThis.fetch = orig
-    }
-  })
-
-  test('throws with the server detail on a non-2xx response', async () => {
-    const orig = globalThis.fetch
-    globalThis.fetch = (async () =>
-      new Response('release frozen', { status: 403, statusText: 'Forbidden' })) as typeof fetch
-    try {
-      await expect(
-        uploadSourcemaps({
-          apiUrl: 'https://api.example.com',
-          paths: [dir],
-          release: 'app@1.0.0+1',
-          token: 'st_pk_x',
-        }),
-      ).rejects.toThrow('403 Forbidden — release frozen')
-    } finally {
-      globalThis.fetch = orig
-    }
-  })
-})

package/src/index.ts

@@ -1,478 +0,0 @@
-#!/usr/bin/env node
-import { parseArgs } from 'node:util'
-
-import { formatIssueLine, issueList, issuePatch } from './issue.js'
-import { uploadDsym, uploadMapping } from './native-artifacts.js'
-import { reactNativeUpload } from './react-native.js'
-import { uploadSourcemaps } from './upload.js'
-
-const HELP = `sentori-cli — Sentori command-line interface
-
-Source-map upload:
-  sentori-cli upload sourcemap [options] <path...>
-      Upload one or more files or directories. A directory is scanned
-      (one level) for *.map / *.js / *.jsbundle / *.bundle / *.hbc;
-      a file given explicitly is uploaded as-is. Use this for web
-      bundlers (point at the build dir) or for already-composed RN maps.
-
-  sentori-cli react-native upload [options]
-      Compose a Metro packager map + a Hermes map into one source map
-      and upload it (plus the bundle). Use this for a Hermes release
-      build. Requires --metro-map and --hermes-map.
-
-Native artifacts (project-scoped, need --project + admin token):
-  sentori-cli upload dsym --project <uuid> [--release <r>] [--object-name <n>] [--debug-id <uuid> --arch <a>] <path>
-      Upload iOS dSYM debug info. By default walks a Foo.dSYM bundle
-      and uses "dwarfdump --uuid" to enumerate slices, uploading each.
-      Pass --debug-id and --arch to upload a single slice without
-      dwarfdump (useful in Linux CI where the toolchain isn't there).
-
-  sentori-cli upload mapping --project <uuid> [--release <r>] [--debug-id <uuid>] <mapping.txt>
-      Upload an R8 / ProGuard mapping (raw bytes). If the file starts
-      with a "# pg_map_id:" line the server sniffs the debug-id from
-      it; otherwise you can pass it explicitly.
-
-CI triage:
-  sentori-cli issue list --project <uuid> [--status active|silenced|resolved|closed] [--limit N] [--error-type <t>]
-  sentori-cli issue resolve <issue-uuid> --project <uuid> [--in-release <r>]
-  sentori-cli issue silence <issue-uuid> --project <uuid>
-
-Options (upload commands):
-  --release <r>     release identifier — MUST equal the value the SDK
-                    reports via init({ release }). Required.
-  --token <t>       Sentori token (or set $SENTORI_TOKEN).
-  --api-url <url>   Sentori API base (default https://api.sentori.golia.jp,
-                    or $SENTORI_API_URL). For a self-hosted instance, your
-                    host. (Accepts --ingest-url as an alias.)
-  --dry-run         describe what would be uploaded; don't upload.
-  -h, --help        show this help.
-
-Options (react-native upload):
-  --metro-map <p>   the *.packager.map Metro emits (--sourcemap-output).
-  --hermes-map <p>  the *.hbc.map the Hermes compiler emits.
-  --bundle <p>      optional: also upload the bundle (.jsbundle / .bundle).
-
-Options (issue commands):
-  --project <uuid>  project id (or set $SENTORI_PROJECT_ID).
-  --token <t>       admin token, sk_… prefix (or $SENTORI_ADMIN_TOKEN /
-                    $SENTORI_TOKEN). The ingest st_pk_ token may also work
-                    on a self-hosted instance.
-  --api-url <url>   Sentori API base (same as above).
-  --in-release <r>  (resolve only) mark this release as where the fix
-                    landed; the regression detector flips the issue back
-                    to "regressed" if a matching event lands later.
-
-Hermes release build, by hand:
-  npx react-native bundle --platform ios --dev false --entry-file index.js \\
-    --bundle-output main.jsbundle --sourcemap-output main.jsbundle.packager.map
-  # (the iOS/Android build compiles to Hermes and writes main.jsbundle.hbc.map)
-  npx @goliapkg/sentori-cli react-native upload \\
-    --release "<app>@<version>+<build>" --token "$SENTORI_TOKEN" \\
-    --metro-map main.jsbundle.packager.map --hermes-map main.jsbundle.hbc.map \\
-    --bundle main.jsbundle
-`
-
-type Common = { apiUrl: string; dryRun: boolean; release: string; token: string }
-
-/** Parse the shared options, or print an error + return null. */
-function parseCommon(values: Record<string, unknown>): Common | null {
-  const release = typeof values.release === 'string' ? values.release : undefined
-  if (!release) {
-    console.error('error: --release is required (must match the SDK’s init({ release }))')
-    return null
-  }
-  const dryRun = values['dry-run'] === true
-  const token =
-    (typeof values.token === 'string' ? values.token : undefined) ?? process.env.SENTORI_TOKEN
-  if (!token && !dryRun) {
-    console.error('error: --token (or $SENTORI_TOKEN) is required')
-    return null
-  }
-  const apiUrl =
-    (typeof values['api-url'] === 'string' ? values['api-url'] : undefined) ??
-    (typeof values['ingest-url'] === 'string' ? values['ingest-url'] : undefined) ??
-    process.env.SENTORI_API_URL ??
-    'https://api.sentori.golia.jp'
-  return { apiUrl, dryRun, release, token: token ?? '' }
-}
-
-async function cmdUploadSourcemap(argv: string[]): Promise<number> {
-  let parsed
-  try {
-    parsed = parseArgs({
-      allowPositionals: true,
-      args: argv,
-      options: {
-        'api-url': { type: 'string' },
-        'dry-run': { type: 'boolean' },
-        help: { short: 'h', type: 'boolean' },
-        'ingest-url': { type: 'string' },
-        release: { type: 'string' },
-        token: { type: 'string' },
-      },
-    })
-  } catch (e) {
-    console.error(`error: ${(e as Error).message}\n`)
-    console.error(HELP)
-    return 2
-  }
-  if (parsed.values.help) {
-    console.log(HELP)
-    return 0
-  }
-  const c = parseCommon(parsed.values)
-  if (!c) return 2
-  if (parsed.positionals.length === 0) {
-    console.error('error: at least one path (file or directory) is required')
-    return 2
-  }
-  try {
-    const result = await uploadSourcemaps({
-      apiUrl: c.apiUrl,
-      dryRun: c.dryRun,
-      paths: parsed.positionals,
-      release: c.release,
-      token: c.token,
-    })
-    reportUpload(result, c)
-    return 0
-  } catch (e) {
-    console.error(`upload failed: ${(e as Error).message}`)
-    return 1
-  }
-}
-
-async function cmdReactNativeUpload(argv: string[]): Promise<number> {
-  let parsed
-  try {
-    parsed = parseArgs({
-      args: argv,
-      options: {
-        'api-url': { type: 'string' },
-        bundle: { type: 'string' },
-        'dry-run': { type: 'boolean' },
-        help: { short: 'h', type: 'boolean' },
-        'hermes-map': { type: 'string' },
-        'ingest-url': { type: 'string' },
-        'metro-map': { type: 'string' },
-        release: { type: 'string' },
-        token: { type: 'string' },
-      },
-    })
-  } catch (e) {
-    console.error(`error: ${(e as Error).message}\n`)
-    console.error(HELP)
-    return 2
-  }
-  if (parsed.values.help) {
-    console.log(HELP)
-    return 0
-  }
-  const c = parseCommon(parsed.values)
-  if (!c) return 2
-  const metroMap = parsed.values['metro-map']
-  const hermesMap = parsed.values['hermes-map']
-  if (typeof metroMap !== 'string' || typeof hermesMap !== 'string') {
-    console.error('error: --metro-map and --hermes-map are both required')
-    return 2
-  }
-  try {
-    const result = await reactNativeUpload({
-      apiUrl: c.apiUrl,
-      bundle: typeof parsed.values.bundle === 'string' ? parsed.values.bundle : undefined,
-      dryRun: c.dryRun,
-      hermesMap,
-      metroMap,
-      release: c.release,
-      token: c.token,
-    })
-    reportUpload(result, c)
-    return 0
-  } catch (e) {
-    console.error(`react-native upload failed: ${(e as Error).message}`)
-    return 1
-  }
-}
-
-function reportUpload(
-  result: { files: string[]; uploaded?: number },
-  c: Common,
-): void {
-  if (c.dryRun) {
-    console.log(
-      `would upload ${result.files.length} file(s) to ${c.apiUrl.replace(/\/+$/, '')}/admin/api/releases/${encodeURIComponent(c.release)}/sourcemaps:`,
-    )
-    for (const f of result.files) console.log(`  ${f}`)
-  } else {
-    console.log(
-      `uploaded ${result.uploaded ?? result.files.length} file(s) for release "${c.release}" — minified stacks on this release will now resolve to source.`,
-    )
-  }
-}
-
-// ── issue commands ────────────────────────────────────────────────
-
-type AdminCfg = { apiUrl: string; projectId: string; token: string }
-
-function parseAdminCfg(values: Record<string, unknown>): AdminCfg | null {
-  const projectId =
-    (typeof values.project === 'string' ? values.project : undefined) ??
-    process.env.SENTORI_PROJECT_ID
-  if (!projectId) {
-    console.error('error: --project <uuid> (or $SENTORI_PROJECT_ID) is required')
-    return null
-  }
-  const token =
-    (typeof values.token === 'string' ? values.token : undefined) ??
-    process.env.SENTORI_ADMIN_TOKEN ??
-    process.env.SENTORI_TOKEN
-  if (!token) {
-    console.error(
-      'error: --token (or $SENTORI_ADMIN_TOKEN / $SENTORI_TOKEN) is required for issue commands',
-    )
-    return null
-  }
-  const apiUrl =
-    (typeof values['api-url'] === 'string' ? values['api-url'] : undefined) ??
-    (typeof values['ingest-url'] === 'string' ? values['ingest-url'] : undefined) ??
-    process.env.SENTORI_API_URL ??
-    'https://api.sentori.golia.jp'
-  return { apiUrl, projectId, token }
-}
-
-async function cmdIssueList(argv: string[]): Promise<number> {
-  let parsed
-  try {
-    parsed = parseArgs({
-      args: argv,
-      options: {
-        'api-url': { type: 'string' },
-        'error-type': { type: 'string' },
-        help: { short: 'h', type: 'boolean' },
-        'ingest-url': { type: 'string' },
-        limit: { type: 'string' },
-        project: { type: 'string' },
-        status: { type: 'string' },
-        token: { type: 'string' },
-      },
-    })
-  } catch (e) {
-    console.error(`error: ${(e as Error).message}\n${HELP}`)
-    return 2
-  }
-  if (parsed.values.help) {
-    console.log(HELP)
-    return 0
-  }
-  const cfg = parseAdminCfg(parsed.values)
-  if (!cfg) return 2
-  const status = parsed.values.status
-  if (status && !['active', 'closed', 'resolved', 'silenced'].includes(status)) {
-    console.error(`error: --status must be one of: active, silenced, resolved, closed`)
-    return 2
-  }
-  const limitStr = parsed.values.limit
-  const limit = limitStr ? Number.parseInt(limitStr, 10) : undefined
-  try {
-    const rows = await issueList({
-      config: cfg,
-      errorType: parsed.values['error-type'],
-      limit,
-      status: status as 'active' | 'closed' | 'resolved' | 'silenced' | undefined,
-    })
-    if (rows.length === 0) {
-      console.log('(no matching issues)')
-      return 0
-    }
-    for (const r of rows) console.log(formatIssueLine(r))
-    return 0
-  } catch (e) {
-    console.error(`issue list failed: ${(e as Error).message}`)
-    return 1
-  }
-}
-
-async function cmdIssuePatch(
-  argv: string[],
-  body: { resolvedInRelease?: string; status: 'active' | 'closed' | 'resolved' | 'silenced' },
-  verb: 'closed' | 'resolved' | 'silenced',
-): Promise<number> {
-  let parsed
-  try {
-    parsed = parseArgs({
-      allowPositionals: true,
-      args: argv,
-      options: {
-        'api-url': { type: 'string' },
-        help: { short: 'h', type: 'boolean' },
-        'in-release': { type: 'string' },
-        'ingest-url': { type: 'string' },
-        project: { type: 'string' },
-        token: { type: 'string' },
-      },
-    })
-  } catch (e) {
-    console.error(`error: ${(e as Error).message}\n${HELP}`)
-    return 2
-  }
-  if (parsed.values.help) {
-    console.log(HELP)
-    return 0
-  }
-  const cfg = parseAdminCfg(parsed.values)
-  if (!cfg) return 2
-  const issueId = parsed.positionals[0]
-  if (!issueId) {
-    console.error('error: <issue-uuid> is required')
-    return 2
-  }
-  if (verb === 'resolved' && typeof parsed.values['in-release'] === 'string') {
-    body.resolvedInRelease = parsed.values['in-release']
-  }
-  try {
-    const updated = await issuePatch(cfg, issueId, body)
-    console.log(
-      `${issueId} → ${verb}${body.resolvedInRelease ? ` (in ${body.resolvedInRelease})` : ''}: ${updated.errorType}`,
-    )
-    return 0
-  } catch (e) {
-    console.error(`issue ${verb} failed: ${(e as Error).message}`)
-    return 1
-  }
-}
-
-// ── native artifact upload ────────────────────────────────────────
-
-async function cmdUploadDsym(argv: string[]): Promise<number> {
-  let parsed
-  try {
-    parsed = parseArgs({
-      allowPositionals: true,
-      args: argv,
-      options: {
-        'api-url': { type: 'string' },
-        arch: { type: 'string' },
-        'debug-id': { type: 'string' },
-        help: { short: 'h', type: 'boolean' },
-        'ingest-url': { type: 'string' },
-        'object-name': { type: 'string' },
-        project: { type: 'string' },
-        release: { type: 'string' },
-        token: { type: 'string' },
-      },
-    })
-  } catch (e) {
-    console.error(`error: ${(e as Error).message}\n${HELP}`)
-    return 2
-  }
-  if (parsed.values.help) {
-    console.log(HELP)
-    return 0
-  }
-  const cfg = parseAdminCfg(parsed.values)
-  if (!cfg) return 2
-  const path = parsed.positionals[0]
-  if (!path) {
-    console.error('error: a path to a .dSYM bundle or DWARF binary is required')
-    return 2
-  }
-  const debugId = parsed.values['debug-id']
-  const arch = parsed.values.arch
-  if ((debugId && !arch) || (arch && !debugId)) {
-    console.error('error: --debug-id and --arch must be passed together (or both omitted)')
-    return 2
-  }
-  try {
-    const r = await uploadDsym({
-      apiUrl: cfg.apiUrl,
-      arch: typeof arch === 'string' ? arch : undefined,
-      debugId: typeof debugId === 'string' ? debugId : undefined,
-      objectName: typeof parsed.values['object-name'] === 'string' ? parsed.values['object-name'] : undefined,
-      path,
-      projectId: cfg.projectId,
-      release: typeof parsed.values.release === 'string' ? parsed.values.release : undefined,
-      token: cfg.token,
-    })
-    console.log(`uploaded ${r.slices.length} dSYM slice(s):`)
-    for (const s of r.slices) console.log(`  ${s.debugId}  (${s.arch})`)
-    return 0
-  } catch (e) {
-    console.error(`dsym upload failed: ${(e as Error).message}`)
-    return 1
-  }
-}
-
-async function cmdUploadMapping(argv: string[]): Promise<number> {
-  let parsed
-  try {
-    parsed = parseArgs({
-      allowPositionals: true,
-      args: argv,
-      options: {
-        'api-url': { type: 'string' },
-        'debug-id': { type: 'string' },
-        help: { short: 'h', type: 'boolean' },
-        'ingest-url': { type: 'string' },
-        project: { type: 'string' },
-        release: { type: 'string' },
-        token: { type: 'string' },
-      },
-    })
-  } catch (e) {
-    console.error(`error: ${(e as Error).message}\n${HELP}`)
-    return 2
-  }
-  if (parsed.values.help) {
-    console.log(HELP)
-    return 0
-  }
-  const cfg = parseAdminCfg(parsed.values)
-  if (!cfg) return 2
-  const path = parsed.positionals[0]
-  if (!path) {
-    console.error('error: a path to mapping.txt is required')
-    return 2
-  }
-  try {
-    await uploadMapping({
-      apiUrl: cfg.apiUrl,
-      debugId: typeof parsed.values['debug-id'] === 'string' ? parsed.values['debug-id'] : undefined,
-      path,
-      projectId: cfg.projectId,
-      release: typeof parsed.values.release === 'string' ? parsed.values.release : undefined,
-      token: cfg.token,
-    })
-    console.log(`uploaded mapping for project ${cfg.projectId}${parsed.values.release ? ` / ${parsed.values.release}` : ''}`)
-    return 0
-  } catch (e) {
-    console.error(`mapping upload failed: ${(e as Error).message}`)
-    return 1
-  }
-}
-
-async function main(argv: string[]): Promise<number> {
-  if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
-    console.log(HELP)
-    return 0
-  }
-  const [a, b, ...rest] = argv
-  if (a === 'upload' && b === 'sourcemap') return cmdUploadSourcemap(rest)
-  if (a === 'upload' && b === 'dsym') return cmdUploadDsym(rest)
-  if (a === 'upload' && b === 'mapping') return cmdUploadMapping(rest)
-  if (a === 'react-native' && b === 'upload') return cmdReactNativeUpload(rest)
-  if (a === 'issue' && b === 'list') return cmdIssueList(rest)
-  if (a === 'issue' && b === 'resolve') return cmdIssuePatch(rest, { status: 'resolved' }, 'resolved')
-  if (a === 'issue' && b === 'silence') return cmdIssuePatch(rest, { status: 'silenced' }, 'silenced')
-  if (a === 'issue' && b === 'close') return cmdIssuePatch(rest, { status: 'closed' }, 'closed')
-  console.error(`unknown command: ${[a, b].filter(Boolean).join(' ') || '(none)'}\n`)
-  console.error(HELP)
-  return 2
-}
-
-main(process.argv.slice(2)).then(
-  (code) => process.exit(code),
-  (e: unknown) => {
-    console.error(`fatal: ${(e as Error).message}`)
-    process.exit(1)
-  },
-)

package/src/issue.ts

@@ -1,81 +0,0 @@
-// `sentori-cli issue list / resolve / silence` — CI triage helpers.
-
-type Issue = {
-  errorType: string
-  eventCount: number
-  id: string
-  lastSeen: string
-  messageSample: string
-  status: 'active' | 'closed' | 'resolved' | 'silenced'
-}
-
-type AdminConfig = {
-  apiUrl: string
-  projectId: string
-  token: string
-}
-
-function url(c: AdminConfig, path: string): string {
-  return `${c.apiUrl.replace(/\/+$/, '')}/admin/api/projects/${c.projectId}${path}`
-}
-
-async function adminFetch<T>(c: AdminConfig, path: string, init?: RequestInit): Promise<T> {
-  const resp = await fetch(url(c, path), {
-    ...init,
-    headers: {
-      Authorization: `Bearer ${c.token}`,
-      'Content-Type': 'application/json',
-      ...(init?.headers ?? {}),
-    },
-  })
-  if (!resp.ok) {
-    let detail = ''
-    try {
-      detail = await resp.text()
-    } catch {
-      // ignore
-    }
-    throw new Error(
-      `${resp.status} ${resp.statusText}${detail ? ` — ${detail.slice(0, 300)}` : ''}`,
-    )
-  }
-  // PATCH /issues/<id> returns the row; some endpoints might return no
-  // content — handle both.
-  const txt = await resp.text()
-  return (txt ? JSON.parse(txt) : null) as T
-}
-
-export type IssueListOptions = {
-  config: AdminConfig
-  errorType?: string
-  limit?: number
-  status?: 'active' | 'closed' | 'resolved' | 'silenced'
-}
-
-export async function issueList(opts: IssueListOptions): Promise<Issue[]> {
-  const q = new URLSearchParams()
-  if (opts.status) q.set('status', opts.status)
-  if (opts.limit) q.set('limit', String(opts.limit))
-  if (opts.errorType) q.set('errorType', opts.errorType)
-  const qs = q.toString()
-  return adminFetch<Issue[]>(opts.config, `/issues${qs ? '?' + qs : ''}`)
-}
-
-export async function issuePatch(
-  config: AdminConfig,
-  issueId: string,
-  body: { resolvedInRelease?: string; status: 'active' | 'closed' | 'resolved' | 'silenced' },
-): Promise<Issue> {
-  return adminFetch<Issue>(config, `/issues/${encodeURIComponent(issueId)}`, {
-    body: JSON.stringify(body),
-    method: 'PATCH',
-  })
-}
-
-/** Format one issue for terminal output — short, one line, scannable. */
-export function formatIssueLine(i: Issue): string {
-  const status = i.status.padEnd(9)
-  const title = `${i.errorType}${i.messageSample ? `: ${i.messageSample}` : ''}`
-  const events = `${i.eventCount}×`
-  return `${i.id}  ${status}  ${title.slice(0, 80).padEnd(80)}  ${events}`
-}