@goliapkg/sentori-cli 0.2.1 → 0.4.0

package/src/__tests__/issue.test.ts

@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
+import { formatIssueLine, issueList, issuePatch } from '../issue.js'
+
+const cfg = {
+  apiUrl: 'https://api.example.com/',
+  projectId: 'proj-1',
+  token: 'sk_test',
+}
+
+const sample = {
+  errorType: 'TypeError',
+  eventCount: 17,
+  id: 'issue-1',
+  lastSeen: '2026-05-13T00:00:00Z',
+  messageSample: 'undefined is not an object',
+  status: 'active' as const,
+}
+
+const origFetch = globalThis.fetch
+let calls: { body: string | undefined; headers: Headers; method: string; url: string }[]
+beforeEach(() => {
+  calls = []
+})
+afterEach(() => {
+  globalThis.fetch = origFetch
+})
+
+function mockFetch(respBody: string, init: ResponseInit = { status: 200 }): void {
+  globalThis.fetch = (async (url: Request | string | URL, opts?: RequestInit) => {
+    calls.push({
+      body: typeof opts?.body === 'string' ? opts.body : undefined,
+      headers: new Headers(opts?.headers),
+      method: opts?.method ?? 'GET',
+      url: String(url),
+    })
+    return new Response(respBody, {
+      headers: { 'content-type': 'application/json' },
+      ...init,
+    })
+  }) as typeof fetch
+}
+
+describe('issueList', () => {
+  test('GETs /admin/api/projects/<id>/issues with query params + Bearer', async () => {
+    mockFetch(JSON.stringify([sample]))
+    const rows = await issueList({ config: cfg, limit: 20, status: 'active' })
+    expect(calls).toHaveLength(1)
+    expect(calls[0]?.method).toBe('GET')
+    expect(calls[0]?.url).toBe(
+      'https://api.example.com/admin/api/projects/proj-1/issues?status=active&limit=20',
+    )
+    expect(calls[0]?.headers.get('authorization')).toBe('Bearer sk_test')
+    expect(rows).toHaveLength(1)
+    expect(rows[0]?.id).toBe('issue-1')
+  })
+
+  test('omits empty query params', async () => {
+    mockFetch(JSON.stringify([]))
+    await issueList({ config: cfg })
+    expect(calls[0]?.url).toBe('https://api.example.com/admin/api/projects/proj-1/issues')
+  })
+
+  test('throws with server detail on non-2xx', async () => {
+    mockFetch('forbidden', { status: 403, statusText: 'Forbidden' })
+    await expect(issueList({ config: cfg })).rejects.toThrow('403 Forbidden — forbidden')
+  })
+})
+
+describe('issuePatch', () => {
+  test('PATCHes /issues/<id> with the body', async () => {
+    mockFetch(JSON.stringify({ ...sample, status: 'resolved' }))
+    const updated = await issuePatch(cfg, 'issue-1', {
+      resolvedInRelease: 'app@1.2.4+457',
+      status: 'resolved',
+    })
+    expect(calls[0]?.method).toBe('PATCH')
+    expect(calls[0]?.url).toBe('https://api.example.com/admin/api/projects/proj-1/issues/issue-1')
+    expect(JSON.parse(calls[0]?.body ?? '{}')).toEqual({
+      resolvedInRelease: 'app@1.2.4+457',
+      status: 'resolved',
+    })
+    expect(updated.status).toBe('resolved')
+  })
+})
+
+describe('formatIssueLine', () => {
+  test('renders id + status + title + event count on one line', () => {
+    const line = formatIssueLine(sample)
+    expect(line).toContain('issue-1')
+    expect(line).toContain('active')
+    expect(line).toContain('TypeError: undefined is not an object')
+    expect(line).toContain('17×')
+  })
+})

package/src/__tests__/react-native.test.ts

@@ -0,0 +1,37 @@
+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 { composeSourceMaps, resolveComposeScript } from '../react-native.js'
+
+let dir = ''
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'sentori-cli-rn-'))
+})
+afterEach(async () => {
+  await rm(dir, { force: true, recursive: true })
+})
+
+describe('react-native helpers', () => {
+  test('resolveComposeScript returns null when react-native is not installed', () => {
+    // This package doesn't depend on react-native, so from sdk/cli's
+    // own node_modules there's nothing to find.
+    expect(resolveComposeScript()).toBeNull()
+  })
+
+  test('composeSourceMaps throws "no such file" for a missing input', () => {
+    expect(() => composeSourceMaps(join(dir, 'nope.map'), join(dir, 'nope2.map'))).toThrow(
+      'no such file',
+    )
+  })
+
+  test('composeSourceMaps throws a helpful message when react-native is absent', async () => {
+    await writeFile(join(dir, 'a.packager.map'), '{"version":3}')
+    await writeFile(join(dir, 'a.hbc.map'), '{"version":3}')
+    expect(() =>
+      composeSourceMaps(join(dir, 'a.packager.map'), join(dir, 'a.hbc.map')),
+    ).toThrow(/compose-source-maps\.js/)
+  })
+})

package/src/index.ts

@@ -1,60 +1,147 @@
 #!/usr/bin/env node
 import { parseArgs } from 'node:util'
 
+import { formatIssueLine, issueList, issuePatch } from './issue.js'
+import { reactNativeUpload } from './react-native.js'
 import { uploadSourcemaps } from './upload.js'
 
-const HELP = `sentori-cli — upload release artifacts to Sentori
+const HELP = `sentori-cli — Sentori command-line interface
 
-Usage:
+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.
 
-  <path>   one or more files or directories. A directory is scanned
-           (one level) for *.map and *.js / *.bundle / *.hbc files.
-           A file given explicitly is uploaded as-is.
+  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.
 
-Options:
+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. A mismatch
-                    means the dashboard silently can't symbolicate.
+                    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         list what would be uploaded; don't upload.
+  --dry-run         describe what would be uploaded; don't upload.
   -h, --help        show this help.
 
-React Native / Hermes: in a release build the *minified* map (Metro)
-and the *bytecode* map (Hermes) must be composed first —
-  npx react-native bundle --platform ios --dev false \\
-    --entry-file index.js --bundle-output main.jsbundle \\
-    --sourcemap-output main.jsbundle.packager.map
-  node node_modules/react-native/scripts/compose-source-maps.js \\
-    main.jsbundle.packager.map main.jsbundle.hbc.map -o main.jsbundle.map
-then \`sentori-cli upload sourcemap --release "<app>@<version>+<build>" main.jsbundle.map main.jsbundle\`.
-(Web bundlers emit a usable .map directly — just point at the build dir.)
+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
 `
 
-async function main(argv: string[]): Promise<number> {
-  if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+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
   }
-  if (argv[0] !== 'upload' || argv[1] !== 'sourcemap') {
-    console.error(`unknown command: ${argv.slice(0, 2).join(' ') || '(none)'}\n`)
-    console.error(HELP)
+  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({
-      allowPositionals: true,
-      args: argv.slice(2),
+      args: argv,
       options: {
         'api-url': { type: 'string' },
+        bundle: { type: 'string' },
         'dry-run': { type: 'boolean' },
         help: { short: 'h', type: 'boolean' },
-        'ingest-url': { type: 'string' }, // alias, kept for older docs
+        'hermes-map': { type: 'string' },
+        'ingest-url': { type: 'string' },
+        'metro-map': { type: 'string' },
         release: { type: 'string' },
         token: { type: 'string' },
       },
@@ -64,58 +151,200 @@ async function main(argv: string[]): Promise<number> {
     console.error(HELP)
     return 2
   }
-  const { positionals, values } = parsed
-
-  if (values.help) {
+  if (parsed.values.help) {
     console.log(HELP)
     return 0
   }
-  const release = values.release
-  if (!release) {
-    console.error('error: --release is required (must match the SDK’s init({ release }))')
+  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
   }
-  const dryRun = !!values['dry-run']
-  const token = values.token ?? process.env.SENTORI_TOKEN
-  if (!token && !dryRun) {
-    console.error('error: --token (or $SENTORI_TOKEN) is 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 =
-    values['api-url'] ??
-    values['ingest-url'] ??
+    (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'
-  if (positionals.length === 0) {
-    console.error('error: at least one path (file or directory) is required')
+  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 result = await uploadSourcemaps({
-      apiUrl,
-      dryRun,
-      paths: positionals,
-      release,
-      token: token ?? '',
+    const rows = await issueList({
+      config: cfg,
+      errorType: parsed.values['error-type'],
+      limit,
+      status: status as 'active' | 'closed' | 'resolved' | 'silenced' | undefined,
     })
-    if (dryRun) {
-      console.log(
-        `would upload ${result.files.length} file(s) to ${apiUrl.replace(/\/+$/, '')}/admin/api/releases/${encodeURIComponent(release)}/sourcemaps:`,
-      )
-      for (const f of result.files) console.log(`  ${f}`)
-    } else {
-      console.log(`uploaded ${result.uploaded} file(s) for release "${release}"`)
-      for (const a of result.artifacts ?? []) console.log(`  ${a.name}  [${a.kind}]`)
-      console.log('done — minified stack traces on this release will now resolve to source.')
+    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(`upload failed: ${(e as Error).message}`)
+    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
   }
 }
 
+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 === '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) => {

package/src/issue.ts

@@ -0,0 +1,81 @@
+// `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}`
+}