@goliapkg/sentori-cli 0.5.3 → 0.6.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,87 @@
+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 { uploadSourcemaps } from './upload.js'
+
+/** 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] : [])]
+    const r = await uploadSourcemaps({
+      apiUrl: opts.apiUrl,
+      dryRun: opts.dryRun,
+      paths,
+      release: opts.release,
+      token: opts.token,
+    })
+    return { files: r.files, uploaded: r.uploaded }
+  } finally {
+    try {
+      rmSync(composed, { force: true })
+      rmSync(join(composed, '..'), { force: true, recursive: true })
+    } catch {
+      // best-effort cleanup
+    }
+  }
+}

package/src/source-bundle.ts

@@ -0,0 +1,234 @@
+// v1.2 W3.a — `sentori-cli upload source-bundle`.
+//
+// Uploads a pre-built `*.tar.gz` archive of the project's source tree
+// for one platform. Server stores it under
+// `release_artifacts` with `kind = source_bundle_<platform>`; on
+// click-frame, the dashboard's FrameSourceDrawer pulls the matching
+// source file out of the archive and shows ±N lines.
+//
+// We intentionally keep the CLI side small: the operator (or CI)
+// already knows how to build a tarball. v1.3 may add an
+// auto-bundle-from-directory mode; for now you do:
+//
+//   tar -czf ios-source.tar.gz Sources/
+//   sentori-cli upload source-bundle --project <uuid> \
+//     --release myapp@1.0.0 --platform ios --path ios-source.tar.gz
+
+import { spawnSync } from 'node:child_process'
+import { mkdtemp, readFile, readdir, stat, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, relative, sep as pathSep } from 'node:path'
+
+import type { AdminUpload } from './native-artifacts.js'
+
+const PLATFORMS = new Set(['ios', 'android'])
+
+/** v1.2 W3.d — per-platform file extensions the CLI bundles when
+ *  `--from-dir` mode picks files from a project tree. Kept narrow on
+ *  purpose: source-bundle is only useful for native source viewing,
+ *  and including non-source files would balloon the archive without
+ *  helping the lookup path. */
+const EXTENSIONS: Record<'android' | 'ios', string[]> = {
+  android: ['.kt', '.java'],
+  ios: ['.swift', '.m', '.mm', '.h', '.hpp'],
+}
+
+const SKIP_DIRS = new Set([
+  '.git',
+  'node_modules',
+  'Pods',
+  'build',
+  'DerivedData',
+  '.gradle',
+  '.build',
+  'target',
+])
+
+export type SourceBundleUploadOptions = AdminUpload & {
+  /** v1.4 W26 — optional module label so polyrepo apps (main +
+   *  watch ext + share ext etc.) can upload multiple bundles per
+   *  (release, platform). Empty/undefined → unlabelled single
+   *  bundle (v1.3 W15 behaviour). */
+  module?: string
+  /** Pre-built tar.gz archive of the project's source tree. */
+  path: string
+  platform: 'android' | 'ios'
+}
+
+export type SourceBundleUploadResult = {
+  contentHash: string
+  kind: string
+  sizeBytes: number
+}
+
+export async function uploadSourceBundle(
+  opts: SourceBundleUploadOptions,
+): Promise<SourceBundleUploadResult> {
+  if (!PLATFORMS.has(opts.platform)) {
+    throw new Error(`--platform must be 'ios' or 'android' (got '${opts.platform}')`)
+  }
+  if (!opts.release) {
+    throw new Error('--release is required for source-bundle uploads')
+  }
+
+  // v1.2 W3.d: when `opts.path` is a directory, bundle it on the fly
+  // instead of requiring the operator to pre-build the archive.
+  let archivePath = opts.path
+  let cleanup: undefined | (() => Promise<void>)
+  try {
+    const st = await stat(opts.path)
+    if (st.isDirectory()) {
+      const built = await buildSourceBundleFromDir(opts.path, opts.platform)
+      archivePath = built.path
+      cleanup = built.cleanup
+    }
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code !== 'ENOENT') throw e
+    throw new Error(`source path not found: ${opts.path}`)
+  }
+
+  try {
+    return await uploadPrebuiltTarGz({ ...opts, path: archivePath })
+  } finally {
+    if (cleanup) await cleanup()
+  }
+}
+
+async function uploadPrebuiltTarGz(
+  opts: SourceBundleUploadOptions,
+): Promise<SourceBundleUploadResult> {
+  const body = await readFile(opts.path)
+  if (body.length === 0) throw new Error(`empty archive: ${opts.path}`)
+  // Same gzip magic check the server enforces. Failing early here
+  // saves a network round-trip when an operator accidentally points
+  // at a raw .tar.
+  if (body.length < 2 || body[0] !== 0x1f || body[1] !== 0x8b) {
+    throw new Error(
+      `${opts.path} does not look like a gzip stream (expected 1f 8b magic) — ` +
+        `did you mean to gzip it first? \`tar -czf <out>.tar.gz <dir>/\``,
+    )
+  }
+  if (!opts.release) throw new Error('--release is required for source-bundle uploads')
+  const base = opts.apiUrl.replace(/\/+$/, '')
+  const q = new URLSearchParams()
+  q.set('release', opts.release)
+  q.set('platform', opts.platform)
+  if (opts.module) q.set('module', opts.module)
+  const url = `${base}/admin/api/projects/${encodeURIComponent(opts.projectId)}/source-bundles?${q.toString()}`
+
+  const resp = await fetch(url, {
+    body,
+    headers: {
+      Authorization: `Bearer ${opts.token}`,
+      'Content-Type': 'application/gzip',
+    },
+    method: 'POST',
+  })
+  if (!resp.ok) {
+    let detail = ''
+    try {
+      detail = await resp.text()
+    } catch {
+      // ignore
+    }
+    throw new Error(
+      `${resp.status} ${resp.statusText}${detail ? ` — ${detail.slice(0, 300)}` : ''}`,
+    )
+  }
+  const parsed: unknown = await resp.json()
+  if (
+    !parsed ||
+    typeof parsed !== 'object' ||
+    typeof (parsed as { contentHash?: unknown }).contentHash !== 'string'
+  ) {
+    throw new Error(`unexpected response shape: ${JSON.stringify(parsed)}`)
+  }
+  const r = parsed as { contentHash: string; kind: string; sizeBytes: number }
+  return { contentHash: r.contentHash, kind: r.kind, sizeBytes: r.sizeBytes }
+}
+
+/** Walk `dir`, pick platform-relevant source files, and tar.gz them
+ *  into a temp file. Caller is responsible for invoking `cleanup()`.
+ *  Uses the system `tar` binary; that's portable enough on macOS +
+ *  Linux + WSL, which covers every realistic CI environment Sentori
+ *  ships to. Native Windows CI without WSL would need to gzip the
+ *  archive themselves (the pre-built-path mode still works). */
+export async function buildSourceBundleFromDir(
+  dir: string,
+  platform: 'android' | 'ios',
+): Promise<{ cleanup: () => Promise<void>; path: string }> {
+  const exts = EXTENSIONS[platform]
+  const files: string[] = []
+  await walk(dir, dir, exts, files)
+  if (files.length === 0) {
+    throw new Error(
+      `no ${platform} source files (${exts.join(', ')}) found under ${dir} — ` +
+        `pass --platform with the right value or check your source layout`,
+    )
+  }
+  files.sort()
+
+  // Write the file list to a temp file, then have tar consume it via
+  // -T —. Avoids the per-arg shell length cap on huge projects.
+  const tmp = await mkdtemp(join(tmpdir(), 'sentori-srcbun-'))
+  const listPath = join(tmp, 'files.txt')
+  const archivePath = join(tmp, `${platform}-source.tar.gz`)
+  await writeFile(listPath, files.join('\n'))
+  const r = spawnSync('tar', ['-czf', archivePath, '-C', dir, '-T', listPath])
+  if (r.status !== 0) {
+    throw new Error(
+      `tar failed (status ${r.status}): ${(r.stderr ?? '').toString().slice(0, 300)}`,
+    )
+  }
+  return {
+    cleanup: async () => {
+      try {
+        await readdir(tmp).then(async (entries) => {
+          for (const e of entries) {
+            await unlinkIfExists(join(tmp, e))
+          }
+        })
+        await unlinkIfExists(tmp, true)
+      } catch {
+        // best-effort cleanup
+      }
+    },
+    path: archivePath,
+  }
+}
+
+async function walk(
+  root: string,
+  dir: string,
+  exts: string[],
+  out: string[],
+): Promise<void> {
+  const entries = await readdir(dir, { withFileTypes: true })
+  for (const e of entries) {
+    if (e.name.startsWith('.') && e.isDirectory() && e.name !== '.') {
+      // Hidden directory: skip (.git, .gradle, .build…). The known
+      // ones are listed in SKIP_DIRS for clarity, but any leading-dot
+      // dir is also skipped as a safety net.
+      continue
+    }
+    if (SKIP_DIRS.has(e.name)) continue
+    const full = join(dir, e.name)
+    if (e.isDirectory()) {
+      await walk(root, full, exts, out)
+    } else if (e.isFile()) {
+      const lower = e.name.toLowerCase()
+      if (exts.some((ext) => lower.endsWith(ext))) {
+        out.push(relative(root, full).split(pathSep).join('/'))
+      }
+    }
+  }
+}
+
+async function unlinkIfExists(path: string, isDir = false): Promise<void> {
+  const { rm } = await import('node:fs/promises')
+  try {
+    await rm(path, { force: true, recursive: isDir })
+  } catch {
+    // ignore
+  }
+}

package/src/upload.ts

@@ -0,0 +1,85 @@
+import { readFile, readdir, stat } from 'node:fs/promises'
+import { basename, join } from 'node:path'
+
+// Files worth uploading: source maps, and the bundle they map (so the
+// dashboard can show the minified line too if a frame falls outside
+// the map). `.jsbundle` (iOS) and `.bundle` (Android) are RN's bundle
+// names; `.hbc` is the Hermes bytecode bundle.
+const UPLOADABLE = /\.(map|js|jsbundle|bundle|hbc)$/i
+
+export type UploadOptions = {
+  release: string
+  token: string
+  /** Sentori API base, e.g. https://sentori.golia.jp or your host. */
+  apiUrl: string
+  /** Files or directories. Directories are scanned one level deep. */
+  paths: string[]
+  dryRun?: boolean
+}
+
+export type UploadResult = {
+  files: string[]
+  uploaded?: number
+  artifacts?: { kind: string; name: string }[]
+}
+
+/** Resolve `paths` (files or dirs) to a deduped list of files to upload.
+ *  A directory contributes its top-level `.map` / `.js` / `.bundle` /
+ *  `.hbc` files; a file given explicitly is taken as-is (even if its
+ *  extension isn't in the list — the caller asked for it). */
+export async function collectFiles(paths: string[]): Promise<string[]> {
+  const out: string[] = []
+  for (const p of paths) {
+    const s = await stat(p).catch(() => null)
+    if (!s) throw new Error(`no such file or directory: ${p}`)
+    if (s.isDirectory()) {
+      for (const entry of await readdir(p)) {
+        const full = join(p, entry)
+        const es = await stat(full).catch(() => null)
+        if (es?.isFile() && UPLOADABLE.test(entry)) out.push(full)
+      }
+    } else {
+      out.push(p)
+    }
+  }
+  const deduped = [...new Set(out)]
+  if (deduped.length === 0) {
+    throw new Error('no .map / .js / .bundle files found in the given path(s)')
+  }
+  return deduped
+}
+
+export async function uploadSourcemaps(opts: UploadOptions): Promise<UploadResult> {
+  const files = await collectFiles(opts.paths)
+  if (opts.dryRun) return { files }
+
+  const form = new FormData()
+  for (const f of files) {
+    const buf = await readFile(f)
+    form.append('file', new Blob([buf]), basename(f))
+  }
+
+  const base = opts.apiUrl.replace(/\/+$/, '')
+  const url = `${base}/admin/api/releases/${encodeURIComponent(opts.release)}/sourcemaps`
+  const resp = await fetch(url, {
+    body: form,
+    headers: { Authorization: `Bearer ${opts.token}` },
+    method: 'POST',
+  })
+  if (!resp.ok) {
+    let detail = ''
+    try {
+      detail = await resp.text()
+    } catch {
+      // ignore
+    }
+    throw new Error(
+      `${resp.status} ${resp.statusText}${detail ? ` — ${detail.slice(0, 300)}` : ''}`,
+    )
+  }
+  const body = (await resp.json().catch(() => ({}))) as {
+    artifacts?: { kind: string; name: string }[]
+    uploaded?: number
+  }
+  return { artifacts: body.artifacts, files, uploaded: body.uploaded ?? files.length }
+}

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)
-})