@goliapkg/sentori-cli 0.6.0 → 1.1.0

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/source-bundle.ts

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