omnara 0.5.1 → 0.5.3

package/scripts/upload-release.ts

@@ -0,0 +1,388 @@
+#!/usr/bin/env bun
+/**
+ * Upload Omnara CLI releases to R2/S3 storage.
+ *
+ * This unified script handles both prerelease and stable release uploads.
+ * It generates the release.json manifest and uploads all binaries.
+ *
+ * Required environment variables:
+ *   AWS_ACCESS_KEY_ID     - R2/S3 access key
+ *   AWS_SECRET_ACCESS_KEY - R2/S3 secret key
+ *   AWS_ENDPOINT_URL      - R2 endpoint (e.g., https://<account_id>.r2.cloudflarestorage.com)
+ *   BUCKET_NAME           - Bucket name (e.g., omnara-releases)
+ *
+ * Optional:
+ *   RELEASE_BASE_URL      - Base URL for downloads (default: https://releases.omnara.com)
+ *
+ * Usage:
+ *   # Upload a stable release (to /{version}/ and /latest/)
+ *   bun run scripts/upload-release.ts --version 0.5.0
+ *
+ *   # Upload a prerelease (to /prerelease/{version}/ and /prerelease/latest/)
+ *   bun run scripts/upload-release.ts --version 0.5.0-pre.abc1234 --prerelease
+ *
+ *   # Dry run (generate release.json only, no upload)
+ *   bun run scripts/upload-release.ts --version 0.5.0 --dry-run
+ *
+ *   # Skip version existence check
+ *   bun run scripts/upload-release.ts --version 0.5.0 --force
+ *
+ * This script expects executables to already be built in dist/exe/
+ * Run `mise run build-exe-all` or `bun run scripts/build-executable.ts --all` first.
+ */
+
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { $ } from 'bun';
+
+const projectRoot = resolve(dirname(import.meta.path), '..');
+const exeDir = join(projectRoot, 'dist', 'exe');
+const pkgJsonPath = join(projectRoot, 'package.json');
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+function log(msg: string): void {
+  console.log(`${colors.blue}==>${colors.reset} ${msg}`);
+}
+
+function success(msg: string): void {
+  console.log(`${colors.green}==>${colors.reset} ${msg}`);
+}
+
+function warn(msg: string): void {
+  console.log(`${colors.yellow}warning:${colors.reset} ${msg}`);
+}
+
+function error(msg: string): never {
+  console.error(`${colors.red}error:${colors.reset} ${msg}`);
+  process.exit(1);
+}
+
+interface Config {
+  version: string;
+  prerelease: boolean;
+  dryRun: boolean;
+  force: boolean;
+  baseUrl: string;
+  endpoint: string;
+  bucket: string;
+  accessKey: string;
+  secretKey: string;
+}
+
+interface PlatformInfo {
+  url: string;
+  sha256: string;
+}
+
+interface ReleaseInfo {
+  version: string;
+  released_at: string;
+  platforms: Record<string, PlatformInfo>;
+}
+
+function parseArgs(): Partial<Config> {
+  const args = process.argv.slice(2);
+  const config: Partial<Config> = {
+    prerelease: false,
+    dryRun: false,
+    force: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--version' && args[i + 1]) {
+      config.version = args[++i];
+    } else if (arg === '--base-url' && args[i + 1]) {
+      config.baseUrl = args[++i];
+    } else if (arg === '--prerelease') {
+      config.prerelease = true;
+    } else if (arg === '--dry-run') {
+      config.dryRun = true;
+    } else if (arg === '--force') {
+      config.force = true;
+    } else if (arg === '--help' || arg === '-h') {
+      printHelp();
+      process.exit(0);
+    }
+  }
+
+  return config;
+}
+
+function printHelp(): void {
+  console.log(`
+Upload Omnara CLI releases to R2/S3 storage.
+
+Usage:
+  bun run scripts/upload-release.ts [options]
+
+Options:
+  --version <version>   Version to upload (defaults to package.json version)
+  --base-url <url>      Base URL for downloads (default: https://releases.omnara.com)
+  --prerelease          Upload as prerelease (to /prerelease/ prefix)
+  --dry-run             Generate release.json only, skip upload
+  --force               Skip version existence check
+  --help, -h            Show this help message
+
+Environment Variables:
+  AWS_ACCESS_KEY_ID     R2/S3 access key (required for upload)
+  AWS_SECRET_ACCESS_KEY R2/S3 secret key (required for upload)
+  AWS_ENDPOINT_URL      R2 endpoint URL (required for upload)
+  BUCKET_NAME           Bucket name (required for upload)
+  RELEASE_BASE_URL      Base URL for downloads
+
+Examples:
+  # Upload stable release
+  bun run scripts/upload-release.ts --version 0.5.0
+
+  # Upload prerelease
+  bun run scripts/upload-release.ts --version 0.5.0-pre.abc1234 --prerelease
+
+  # Dry run (no upload)
+  bun run scripts/upload-release.ts --version 0.5.0 --dry-run
+`);
+}
+
+function getPackageVersion(): string {
+  const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf8')) as { version?: string };
+  return pkgJson.version ?? '0.0.0';
+}
+
+function checkEnvVars(): { endpoint: string; bucket: string; accessKey: string; secretKey: string } {
+  const accessKey = process.env.AWS_ACCESS_KEY_ID;
+  const secretKey = process.env.AWS_SECRET_ACCESS_KEY;
+  const endpoint = process.env.AWS_ENDPOINT_URL ?? process.env.R2_ENDPOINT_URL;
+  const bucket = process.env.BUCKET_NAME ?? process.env.R2_BUCKET;
+
+  const missing: string[] = [];
+  if (!accessKey) missing.push('AWS_ACCESS_KEY_ID');
+  if (!secretKey) missing.push('AWS_SECRET_ACCESS_KEY');
+  if (!endpoint) missing.push('AWS_ENDPOINT_URL');
+  if (!bucket) missing.push('BUCKET_NAME');
+
+  if (missing.length > 0) {
+    error(`Missing required environment variables: ${missing.join(', ')}`);
+  }
+
+  return { endpoint: endpoint!, bucket: bucket!, accessKey: accessKey!, secretKey: secretKey! };
+}
+
+function calculateSha256(filePath: string): string {
+  const content = readFileSync(filePath);
+  return createHash('sha256').update(content).digest('hex');
+}
+
+function extractPlatform(filename: string): string {
+  return filename.replace(/^omnara-/, '').replace(/\.exe$/, '');
+}
+
+function getExecutableFiles(): string[] {
+  if (!existsSync(exeDir)) {
+    error(`Executable directory not found: ${exeDir}\nRun 'bun run scripts/build-executable.ts --all' first.`);
+  }
+
+  const files = readdirSync(exeDir).filter((f) => {
+    return f.startsWith('omnara-') && !f.endsWith('.sha256') && !f.endsWith('.json');
+  });
+
+  if (files.length === 0) {
+    error(`No executable files found in ${exeDir}\nRun 'bun run scripts/build-executable.ts --all' first.`);
+  }
+
+  return files;
+}
+
+function generateReleaseJson(version: string, baseUrl: string, prefix: string): ReleaseInfo {
+  const files = getExecutableFiles();
+  const platforms: Record<string, PlatformInfo> = {};
+
+  log('Generating release.json...');
+  console.log('');
+
+  for (const file of files) {
+    const filePath = join(exeDir, file);
+    const platform = extractPlatform(file);
+    const sha256 = calculateSha256(filePath);
+
+    // URL path: {baseUrl}/{prefix}/{version}/{file}
+    // For prerelease: https://releases.omnara.com/prerelease/0.5.0-pre.abc1234/omnara-darwin-arm64
+    // For release: https://releases.omnara.com/0.5.0/omnara-darwin-arm64
+    const urlPath = prefix ? `${prefix}/${version}` : version;
+    platforms[platform] = {
+      url: `${baseUrl}/${urlPath}/${file}`,
+      sha256,
+    };
+
+    // Write individual .sha256 file
+    writeFileSync(`${filePath}.sha256`, sha256);
+
+    console.log(`  ${colors.cyan}${platform}${colors.reset}`);
+    console.log(`    SHA256: ${sha256}`);
+  }
+
+  const release: ReleaseInfo = {
+    version,
+    released_at: new Date().toISOString(),
+    platforms,
+  };
+
+  const releasePath = join(exeDir, 'release.json');
+  writeFileSync(releasePath, JSON.stringify(release, null, 2) + '\n');
+
+  console.log('');
+  success(`Generated ${releasePath}`);
+
+  return release;
+}
+
+async function checkVersionExists(baseUrl: string, prefix: string, version: string): Promise<boolean> {
+  const urlPath = prefix ? `${prefix}/${version}` : version;
+  const releaseUrl = `${baseUrl}/${urlPath}/release.json`;
+
+  try {
+    const response = await fetch(releaseUrl, { method: 'HEAD' });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function uploadFile(
+  filePath: string,
+  destPath: string,
+  contentType: string,
+  config: Config
+): Promise<void> {
+  const { endpoint, bucket } = config;
+
+  await $`aws s3 cp ${filePath} s3://${bucket}/${destPath} --endpoint-url ${endpoint} --content-type ${contentType}`.quiet();
+}
+
+async function uploadRelease(config: Config, prefix: string): Promise<void> {
+  const files = getExecutableFiles();
+  const { version } = config;
+
+  // Determine paths
+  const versionPath = prefix ? `${prefix}/${version}` : version;
+  const latestPath = prefix ? `${prefix}/latest` : 'latest';
+
+  // Upload binaries to version directory
+  log(`Uploading executables to ${versionPath}/...`);
+  for (const file of files) {
+    const filePath = join(exeDir, file);
+    console.log(`  ${file}`);
+    await uploadFile(filePath, `${versionPath}/${file}`, 'application/octet-stream', config);
+  }
+
+  // Upload release.json to version directory
+  log(`Uploading release.json to ${versionPath}/...`);
+  await uploadFile(join(exeDir, 'release.json'), `${versionPath}/release.json`, 'application/json', config);
+
+  // Upload binaries to latest directory
+  log(`Uploading executables to ${latestPath}/...`);
+  for (const file of files) {
+    const filePath = join(exeDir, file);
+    console.log(`  ${file}`);
+    await uploadFile(filePath, `${latestPath}/${file}`, 'application/octet-stream', config);
+  }
+
+  // Upload release.json to latest directory
+  log(`Uploading release.json to ${latestPath}/...`);
+  await uploadFile(join(exeDir, 'release.json'), `${latestPath}/release.json`, 'application/json', config);
+}
+
+async function main(): Promise<void> {
+  console.log('');
+  console.log('  Omnara CLI Release Uploader');
+  console.log('');
+
+  const parsedArgs = parseArgs();
+  const version = parsedArgs.version ?? getPackageVersion();
+  const prerelease = parsedArgs.prerelease ?? false;
+  const dryRun = parsedArgs.dryRun ?? false;
+  const force = parsedArgs.force ?? false;
+  const baseUrl = parsedArgs.baseUrl ?? process.env.RELEASE_BASE_URL ?? 'https://releases.omnara.com';
+
+  // Prefix for prerelease uploads
+  const prefix = prerelease ? 'prerelease' : '';
+
+  log(`Version: ${version}`);
+  log(`Type: ${prerelease ? 'prerelease' : 'stable release'}`);
+  log(`Base URL: ${baseUrl}`);
+  if (dryRun) {
+    warn('Dry run mode - will not upload');
+  }
+  console.log('');
+
+  // Check if version already exists (unless force or dry-run)
+  if (!dryRun && !force) {
+    log('Checking if version already exists...');
+    const exists = await checkVersionExists(baseUrl, prefix, version);
+    if (exists) {
+      warn(`Version ${version} already exists at ${baseUrl}/${prefix ? prefix + '/' : ''}${version}/`);
+      warn('Use --force to overwrite');
+      process.exit(0);
+    }
+    success('Version does not exist, proceeding with upload');
+    console.log('');
+  }
+
+  // Generate release.json
+  generateReleaseJson(version, baseUrl, prefix);
+  console.log('');
+
+  // Upload if not dry run
+  if (!dryRun) {
+    // Check environment variables
+    const envVars = checkEnvVars();
+
+    const config: Config = {
+      version,
+      prerelease,
+      dryRun,
+      force,
+      baseUrl,
+      ...envVars,
+    };
+
+    await uploadRelease(config, prefix);
+
+    console.log('');
+    success(`${prerelease ? 'Prerelease' : 'Release'} ${version} uploaded successfully!`);
+    console.log('');
+    console.log('  Binaries available at:');
+    const versionPath = prefix ? `${prefix}/${version}` : version;
+    const latestPath = prefix ? `${prefix}/latest` : 'latest';
+    console.log(`    ${baseUrl}/${versionPath}/`);
+    console.log(`    ${baseUrl}/${latestPath}/`);
+    console.log('');
+
+    if (prerelease) {
+      console.log('  To install prerelease:');
+      console.log('    PRERELEASE=1 curl -fsSL https://omnara.com/install/install.sh | bash');
+    } else {
+      console.log('  To install:');
+      console.log('    curl -fsSL https://omnara.com/install/install.sh | bash');
+    }
+    console.log('');
+  } else {
+    console.log('');
+    success('Dry run complete - release.json generated but not uploaded');
+    console.log('');
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});