@goliapkg/sentori-cli 0.5.3 → 1.0.0

package/src/push.ts

@@ -0,0 +1,174 @@
+// v2.12 — `sentori-cli push *` commands.
+//
+// Wraps the v2.7 admin REST + v2.7 ingest endpoints so operators can
+// drive credential CRUD, ad-hoc sends, and receipt lookups from the
+// terminal without touching curl.
+//
+// `push send`     POST /v1/push/send         (ingest Bearer)
+// `push receipt`  GET  /v1/push/receipts/:id (ingest Bearer)
+// `push creds list`    GET    /admin/api/projects/:id/push/credentials   (admin Bearer)
+// `push creds set`     PUT    /admin/api/projects/:id/push/credentials   (admin Bearer)
+// `push creds delete`  DELETE /admin/api/projects/:id/push/credentials/:provider
+
+import { readFileSync } from 'node:fs'
+
+export type PushClientConfig = {
+  apiUrl: string
+  projectId: string
+  token: string
+}
+
+type AdminCredentialRow = {
+  provider: string
+  config: Record<string, unknown>
+  updatedAt: string
+}
+
+type Ticket = {
+  id: string
+  status: 'queued' | 'sent' | 'failed'
+  providerOutcome?: string | null
+  error?: string | null
+  retryCount: number
+  createdAt: string
+  sentAt?: string | null
+}
+
+const VALID_PROVIDERS = new Set(['apns', 'fcm', 'webpush', 'hcm', 'mipush'])
+
+function joinUrl(base: string, path: string): string {
+  return `${base.replace(/\/+$/, '')}${path}`
+}
+
+async function bearerFetch<T>(
+  url: string,
+  token: string,
+  init?: RequestInit,
+): Promise<T> {
+  const resp = await fetch(url, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      ...(init?.headers ?? {}),
+    },
+  })
+  if (!resp.ok) {
+    const detail = await resp.text().catch(() => '')
+    throw new Error(
+      `${resp.status} ${resp.statusText}${detail ? ` — ${detail.slice(0, 300)}` : ''}`,
+    )
+  }
+  const txt = await resp.text()
+  return (txt ? JSON.parse(txt) : null) as T
+}
+
+/** Parse a CLI flag value that may be `@file.json` (read from disk
+ *  and parse) or a literal JSON string. */
+export function parseJsonArg(raw: string, kind: string): unknown {
+  if (raw.startsWith('@')) {
+    const path = raw.slice(1)
+    const body = readFileSync(path, 'utf-8')
+    try {
+      return JSON.parse(body)
+    } catch (e) {
+      throw new Error(`${kind} file ${path} is not valid JSON: ${(e as Error).message}`)
+    }
+  }
+  try {
+    return JSON.parse(raw)
+  } catch (e) {
+    throw new Error(`${kind} arg is not valid JSON: ${(e as Error).message}`)
+  }
+}
+
+// ── credential CRUD ───────────────────────────────────────────────
+
+export async function pushCredsList(cfg: PushClientConfig): Promise<AdminCredentialRow[]> {
+  return bearerFetch<AdminCredentialRow[]>(
+    joinUrl(cfg.apiUrl, `/admin/api/projects/${cfg.projectId}/push/credentials`),
+    cfg.token,
+  )
+}
+
+export async function pushCredsSet(
+  cfg: PushClientConfig,
+  provider: string,
+  config: unknown,
+  secret: unknown,
+): Promise<{ ok: boolean }> {
+  if (!VALID_PROVIDERS.has(provider)) {
+    throw new Error(
+      `invalid provider '${provider}'; expected one of ${[...VALID_PROVIDERS].join('/')}`,
+    )
+  }
+  return bearerFetch<{ ok: boolean }>(
+    joinUrl(cfg.apiUrl, `/admin/api/projects/${cfg.projectId}/push/credentials`),
+    cfg.token,
+    {
+      body: JSON.stringify({ provider, config, secret }),
+      method: 'PUT',
+    },
+  )
+}
+
+export async function pushCredsDelete(
+  cfg: PushClientConfig,
+  provider: string,
+): Promise<void> {
+  await bearerFetch<null>(
+    joinUrl(
+      cfg.apiUrl,
+      `/admin/api/projects/${cfg.projectId}/push/credentials/${provider}`,
+    ),
+    cfg.token,
+    { method: 'DELETE' },
+  )
+}
+
+// ── send / receipt ────────────────────────────────────────────────
+
+export type SendOpts = {
+  to: string
+  title?: string
+  body?: string
+  data?: unknown
+  priority?: 'high' | 'normal'
+  ttl?: number
+  idempotencyKey?: string
+}
+
+export async function pushSend(cfg: PushClientConfig, opts: SendOpts): Promise<Ticket> {
+  const payload: Record<string, unknown> = {
+    to: opts.to,
+    title: opts.title,
+    body: opts.body,
+    data: opts.data,
+    idempotencyKey: opts.idempotencyKey,
+  }
+  if (opts.priority || opts.ttl != null) {
+    payload.options = { priority: opts.priority, ttl: opts.ttl }
+  }
+  const resp = await bearerFetch<{ tickets: Ticket[] }>(
+    joinUrl(cfg.apiUrl, '/v1/push/send'),
+    cfg.token,
+    {
+      body: JSON.stringify(payload),
+      method: 'POST',
+    },
+  )
+  if (!resp.tickets?.length) {
+    throw new Error('server returned no tickets')
+  }
+  return resp.tickets[0]!
+}
+
+export async function pushReceipt(
+  cfg: PushClientConfig,
+  sendId: string,
+): Promise<{ ticket: Ticket }> {
+  return bearerFetch<{ ticket: Ticket }>(
+    joinUrl(cfg.apiUrl, `/v1/push/receipts/${encodeURIComponent(sendId)}`),
+    cfg.token,
+  )
+}

package/src/react-native.ts

@@ -0,0 +1,94 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync, mkdtempSync, rmSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { uploadArtifact } from './upload.js'
+import { basename } from 'node:path'
+
+/** Resolve `react-native/scripts/compose-source-maps.js` from the
+ *  current project's node_modules. Returns null if react-native isn't
+ *  installed or the version doesn't ship that script. */
+export function resolveComposeScript(fromDir = process.cwd()): null | string {
+  const req = createRequire(join(fromDir, 'noop.js'))
+  for (const id of [
+    'react-native/scripts/compose-source-maps.js',
+    '@react-native/community-cli-plugin/dist/utils/composeSourceMaps.js',
+  ]) {
+    try {
+      const p = req.resolve(id)
+      if (existsSync(p)) return p
+    } catch {
+      // try next
+    }
+  }
+  return null
+}
+
+/** Compose a Metro packager source map + a Hermes source map into a
+ *  single map (a temp file the caller is responsible for deleting).
+ *  Throws if react-native's compose script can't be found or fails. */
+export function composeSourceMaps(metroMap: string, hermesMap: string): string {
+  for (const p of [metroMap, hermesMap]) {
+    if (!existsSync(p)) throw new Error(`no such file: ${p}`)
+  }
+  const script = resolveComposeScript()
+  if (!script) {
+    throw new Error(
+      "couldn't find react-native's compose-source-maps.js — install react-native, or " +
+        'compose the maps yourself and use `sentori-cli upload sourcemap <composed.map>`',
+    )
+  }
+  const out = join(mkdtempSync(join(tmpdir(), 'sentori-rn-')), 'composed.map')
+  const r = spawnSync('node', [script, metroMap, hermesMap, '-o', out], { stdio: 'inherit' })
+  if (r.status !== 0) {
+    throw new Error(`compose-source-maps.js exited with ${r.status ?? 'signal'}`)
+  }
+  if (!existsSync(out)) throw new Error('compose-source-maps.js produced no output')
+  return out
+}
+
+export type RnUploadOptions = {
+  apiUrl: string
+  /** Optional bundle file (.jsbundle / .bundle) to upload alongside the map. */
+  bundle?: string
+  dryRun?: boolean
+  hermesMap: string
+  metroMap: string
+  release: string
+  token: string
+}
+
+/** Compose the Metro + Hermes maps, then upload the result (and the
+ *  bundle, if given). Cleans up the temp composed map. */
+export async function reactNativeUpload(opts: RnUploadOptions): Promise<{
+  files: string[]
+  uploaded?: number
+}> {
+  const composed = composeSourceMaps(opts.metroMap, opts.hermesMap)
+  try {
+    const paths = [composed, ...(opts.bundle ? [opts.bundle] : [])]
+    if (opts.dryRun) return { files: paths }
+    let uploaded = 0
+    for (const p of paths) {
+      await uploadArtifact({
+        apiUrl: opts.apiUrl,
+        token: opts.token,
+        release: opts.release,
+        kind: 'sourcemap',
+        path: p,
+        name: basename(p),
+      })
+      uploaded += 1
+    }
+    return { files: paths, uploaded }
+  } finally {
+    try {
+      rmSync(composed, { force: true })
+      rmSync(join(composed, '..'), { force: true, recursive: true })
+    } catch {
+      // best-effort cleanup
+    }
+  }
+}

package/src/upload.ts

@@ -0,0 +1,44 @@
+// Unified symbolication-artifact upload: sourcemap / dsym / proguard
+// all land on `POST /v1/releases/{release}/artifacts` (multipart
+// `kind` + `file`), authenticated with an api-scope token. A late
+// upload triggers retro-symbolication server-side, which is what
+// makes the lenient exit-0 contract honest — nothing is lost
+// forever.
+
+import { readFileSync } from 'node:fs'
+import { basename } from 'node:path'
+
+export type UploadOpts = {
+  apiUrl: string
+  token: string
+  release: string
+  kind: 'dsym' | 'proguard' | 'sourcemap'
+  path: string
+  /** Override the stored artifact name (defaults to the filename). */
+  name?: string
+}
+
+export async function uploadArtifact(opts: UploadOpts): Promise<{ id: string }> {
+  const bytes = readFileSync(opts.path)
+  if (bytes.length === 0) throw new Error(`empty file: ${opts.path}`)
+
+  const form = new FormData()
+  form.append('kind', opts.kind)
+  form.append(
+    'file',
+    new Blob([new Uint8Array(bytes)]),
+    opts.name ?? basename(opts.path),
+  )
+
+  const url = `${opts.apiUrl.replace(/\/+$/, '')}/v1/releases/${encodeURIComponent(opts.release)}/artifacts`
+  const resp = await fetch(url, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${opts.token}` },
+    body: form,
+  })
+  if (!resp.ok) {
+    const detail = await resp.text().catch(() => '')
+    throw new Error(`${resp.status} ${resp.statusText}${detail ? ` — ${detail.slice(0, 200)}` : ''}`)
+  }
+  return (await resp.json()) as { id: string }
+}

package/bin/sentori-cli.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-// Phase 17 sub-B: Node entry point for `npx @goliapkg/sentori-cli ...`.
-// Forwards argv + stdio to the prebuilt Rust binary that postinstall
-// dropped at ../vendor/sentori-cli.
-
-'use strict'
-
-const path = require('node:path')
-const fs = require('node:fs')
-const { spawn } = require('node:child_process')
-
-const bin = path.join(__dirname, '..', 'vendor', 'sentori-cli')
-if (!fs.existsSync(bin)) {
-  console.error(
-    'sentori-cli binary missing — postinstall did not complete. ' +
-      'Try: `npm rebuild @goliapkg/sentori-cli` or set SENTORI_SKIP_DOWNLOAD=0 then reinstall.'
-  )
-  process.exit(127)
-}
-
-const child = spawn(bin, process.argv.slice(2), { stdio: 'inherit' })
-child.on('exit', (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal)
-  } else {
-    process.exit(code ?? 1)
-  }
-})
-child.on('error', (e) => {
-  console.error('failed to run sentori-cli:', e.message)
-  process.exit(1)
-})

package/scripts/postinstall.js

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-// Phase 17 sub-B: download the prebuilt sentori-cli binary that
-// matches the current platform / arch and place it at ../vendor/.
-//
-// Skips if SENTORI_SKIP_DOWNLOAD=1 (CI, monorepo bootstrap, etc.).
-
-'use strict'
-
-const fs = require('node:fs')
-const https = require('node:https')
-const path = require('node:path')
-const { spawnSync } = require('node:child_process')
-
-const pkg = require(path.join(__dirname, '..', 'package.json'))
-const TAG = `cli-v${pkg.version}`
-
-const SUPPORTED = {
-  'linux-x64': 'linux-x64',
-  'linux-arm64': 'linux-arm64',
-  'darwin-x64': 'darwin-x64',
-  'darwin-arm64': 'darwin-arm64',
-}
-
-function detect() {
-  return `${process.platform}-${process.arch}`
-}
-
-function fetch(url, destStream) {
-  return new Promise((resolve, reject) => {
-    const handle = (u) => {
-      https
-        .get(u, { headers: { 'user-agent': `sentori-cli-installer/${pkg.version}` } }, (res) => {
-          const code = res.statusCode || 0
-          if (code >= 300 && code < 400 && res.headers.location) {
-            return handle(res.headers.location)
-          }
-          if (code !== 200) {
-            return reject(new Error(`HTTP ${code} from ${u}`))
-          }
-          res.pipe(destStream)
-          destStream.on('finish', resolve)
-          destStream.on('error', reject)
-        })
-        .on('error', reject)
-    }
-    handle(url)
-  })
-}
-
-async function main() {
-  if (process.env.SENTORI_SKIP_DOWNLOAD === '1') {
-    console.log('SENTORI_SKIP_DOWNLOAD=1; skipping sentori-cli binary download')
-    return
-  }
-
-  const key = detect()
-  const slug = SUPPORTED[key]
-  if (!slug) {
-    console.error(
-      `sentori-cli has no prebuilt binary for ${key}. ` +
-        `Cargo install instead: cargo install --git https://github.com/goliajp/sentori --bin sentori-cli`
-    )
-    process.exit(0) // soft fail — user can still cargo install
-  }
-
-  const filename = `sentori-cli-${TAG}-${slug}.tar.gz`
-  const url = `https://github.com/goliajp/sentori/releases/download/${TAG}/${filename}`
-  const vendorDir = path.join(__dirname, '..', 'vendor')
-  fs.mkdirSync(vendorDir, { recursive: true })
-  const tarball = path.join(vendorDir, 'sentori-cli.tar.gz')
-
-  console.log(`sentori-cli ${pkg.version}: downloading ${slug} from GitHub Release`)
-  await fetch(url, fs.createWriteStream(tarball))
-
-  const tar = spawnSync('tar', ['-xzf', tarball, '-C', vendorDir], { stdio: 'inherit' })
-  if (tar.status !== 0) {
-    console.error('tar -xzf failed; is `tar` on PATH?')
-    process.exit(1)
-  }
-  fs.unlinkSync(tarball)
-
-  const bin = path.join(vendorDir, 'sentori-cli')
-  fs.chmodSync(bin, 0o755)
-  console.log(`✓ sentori-cli ${pkg.version} ready (${slug})`)
-}
-
-main().catch((e) => {
-  console.error('sentori-cli install failed:', e.message)
-  process.exit(1)
-})