eoas 1.0.1

package/src/commands/publish.ts

@@ -0,0 +1,277 @@
+import { Platform } from '@expo/eas-build-job';
+import spawnAsync from '@expo/spawn-async';
+import { Command, Flags } from '@oclif/core';
+import { Config } from '@oclif/core/lib/config';
+import FormData from 'form-data';
+import fs from 'fs-extra';
+import mime from 'mime';
+import fetch from 'node-fetch';
+import path from 'path';
+
+import { computeFilesRequests, requestUploadUrls } from '../lib/assets';
+import { getAuthExpoHeaders, retrieveExpoCredentials } from '../lib/auth';
+import {
+  RequestedPlatform,
+  getExpoConfigUpdateUrl,
+  getPrivateExpoConfigAsync,
+  getPublicExpoConfigAsync,
+} from '../lib/expoConfig';
+import Log from '../lib/log';
+import { ora } from '../lib/ora';
+import { isExpoInstalled } from '../lib/package';
+import { confirmAsync } from '../lib/prompts';
+import { ensureRepoIsCleanAsync } from '../lib/repo';
+import { resolveRuntimeVersionAsync } from '../lib/runtimeVersion';
+import { resolveVcsClient } from '../lib/vcs';
+import { Client } from '../lib/vcs/vcs';
+import { resolveWorkflowAsync } from '../lib/workflow';
+
+export default class Publish extends Command {
+  vcsClient: Client;
+  constructor(argv: string[], config: Config) {
+    super(argv, config);
+    this.vcsClient = resolveVcsClient(false);
+  }
+  static override args = {};
+  static override description = 'Publish a new update to the self-hosted update server';
+  static override examples = ['<%= config.bin %> <%= command.id %>'];
+  static override flags = {
+    platform: Flags.string({
+      type: 'option',
+      options: Object.values(RequestedPlatform),
+      default: RequestedPlatform.All,
+      required: false,
+    }),
+    channel: Flags.string({
+      description: 'Name of the channel to publish the update to',
+      required: true,
+    }),
+    branch: Flags.string({
+      description: 'Name of the branch to point to',
+      required: true,
+    }),
+    nonInteractive: Flags.boolean({
+      description: 'Run command in non-interactive mode',
+      default: false,
+    }),
+  };
+  private sanitizeFlags(flags: any): {
+    platform: RequestedPlatform;
+    branch: string;
+    nonInteractive: boolean;
+    channel: string;
+  } {
+    return {
+      platform: flags.platform,
+      branch: flags.branch,
+      nonInteractive: flags.nonInteractive,
+      channel: flags.channel,
+    };
+  }
+  public async run(): Promise<void> {
+    const credentials = retrieveExpoCredentials();
+
+    if (!credentials.token && !credentials.sessionSecret) {
+      Log.error('You are not logged to eas, please run `eas login`');
+      return;
+    }
+    const { flags } = await this.parse(Publish);
+    const { platform, nonInteractive, branch, channel } = this.sanitizeFlags(flags);
+    if (!branch) {
+      Log.error('Branch name is required');
+      return;
+    }
+    if (!channel) {
+      Log.error('Channel name is required');
+      return;
+    }
+    await this.vcsClient.ensureRepoExistsAsync();
+    await ensureRepoIsCleanAsync(this.vcsClient, nonInteractive);
+    const projectDir = process.cwd();
+    const hasExpo = isExpoInstalled(projectDir);
+    if (!hasExpo) {
+      Log.error('Expo is not installed in this project. Please install Expo first.');
+      return;
+    }
+
+    const privateConfig = await getPrivateExpoConfigAsync(projectDir, {
+      env: {
+        RELEASE_CHANNEL: channel,
+      },
+    });
+    const updateUrl = getExpoConfigUpdateUrl(privateConfig);
+    if (!updateUrl) {
+      Log.error(
+        "Update url is not setup in your config. Please run 'eoas init' to setup the update url"
+      );
+      return;
+    }
+    let baseUrl: string;
+    try {
+      const parsedUrl = new URL(updateUrl);
+      baseUrl = parsedUrl.origin;
+    } catch (e) {
+      Log.error('Invalid URL', e);
+      return;
+    }
+    if (!nonInteractive) {
+      const confirmed = await confirmAsync({
+        message: `Is this the correct URL of your self-hosted update server? ${baseUrl}`,
+        name: 'export',
+        type: 'confirm',
+      });
+      if (!confirmed) {
+        Log.error('Please run `eoas init` to setup the correct update url');
+      }
+    }
+    const runtimeSpinner = ora('Resolving runtime version').start();
+    const runtimeVersions = [
+      ...(!platform || platform === RequestedPlatform.All || platform === RequestedPlatform.Ios
+        ? [
+            (
+              await resolveRuntimeVersionAsync({
+                exp: privateConfig,
+                platform: 'ios',
+                workflow: await resolveWorkflowAsync(projectDir, Platform.IOS, this.vcsClient),
+                projectDir,
+                env: {
+                  RELEASE_CHANNEL: channel,
+                },
+              })
+            )?.runtimeVersion,
+          ]
+        : []),
+      ...(!platform || platform === RequestedPlatform.All || platform === RequestedPlatform.Android
+        ? [
+            (
+              await resolveRuntimeVersionAsync({
+                exp: privateConfig,
+                platform: 'android',
+                workflow: await resolveWorkflowAsync(projectDir, Platform.ANDROID, this.vcsClient),
+                projectDir,
+                env: {
+                  RELEASE_CHANNEL: channel,
+                },
+              })
+            )?.runtimeVersion,
+          ]
+        : []),
+    ].filter(Boolean);
+    if (!runtimeVersions.length) {
+      runtimeSpinner.fail('Could not resolve runtime versions for the requested platforms');
+      Log.error('Could not resolve runtime versions for the requested platforms');
+      return;
+    }
+    runtimeSpinner.succeed('Runtime versions resolved');
+
+    const exportSpinner = ora("Exporting project's static files").start();
+    try {
+      await spawnAsync('rm', ['-rf', 'dist'], { cwd: projectDir });
+      const { stdout } = await spawnAsync('npx', ['expo', 'export', '--output-dir', 'dist'], {
+        cwd: projectDir,
+        env: {
+          ...process.env,
+          EXPO_NO_DOTENV: '1',
+        },
+      });
+      exportSpinner.succeed('Project exported successfully');
+      Log.withInfo(stdout);
+    } catch {
+      exportSpinner.fail('Failed to export the project');
+    }
+    const publicConfig = await getPublicExpoConfigAsync(projectDir, {
+      skipSDKVersionRequirement: true,
+    });
+    if (!publicConfig) {
+      Log.error(
+        'Could not find Expo config in this project. Please make sure you have an Expo config.'
+      );
+      return;
+    }
+    // eslint-disable-next-line
+    fs.writeJsonSync(path.join(projectDir, 'dist', 'expoConfig.json'), publicConfig, {
+      spaces: 2,
+    });
+    Log.withInfo('expoConfig.json file created in dist directory');
+    const uploadFilesSpinner = ora('Uploading files to the server').start();
+    const files = computeFilesRequests(projectDir, platform || RequestedPlatform.All);
+    if (!files.length) {
+      uploadFilesSpinner.fail('No files to upload');
+    }
+    try {
+      const uploadUrls = await Promise.all(
+        runtimeVersions.map(runtimeVersion => {
+          if (!runtimeVersion) {
+            throw new Error('Runtime version is not resolved');
+          }
+          return requestUploadUrls(
+            {
+              fileNames: files.map(file => file.path),
+            },
+            `${baseUrl}/requestUploadUrl/${branch}`,
+            credentials,
+            runtimeVersion
+          );
+        })
+      );
+      const allItems = uploadUrls.flat();
+      await Promise.all(
+        allItems.map(async itm => {
+          const isLocalBucketFileUpload = itm.requestUploadUrl.startsWith(
+            `${baseUrl}/uploadLocalFile`
+          );
+          const formData = new FormData();
+          let file: fs.ReadStream;
+          try {
+            file = fs.createReadStream(path.join(projectDir, 'dist', itm.filePath));
+          } catch {
+            throw new Error(`Failed to read file ${itm.filePath}`);
+          }
+          formData.append(itm.fileName, file);
+          if (isLocalBucketFileUpload) {
+            const response = await fetch(itm.requestUploadUrl, {
+              method: 'PUT',
+              headers: {
+                ...formData.getHeaders(),
+                ...getAuthExpoHeaders(credentials),
+              },
+              body: formData,
+            });
+            if (!response.ok) {
+              Log.error('Failed to upload file', await response.text());
+              throw new Error('Failed to upload file');
+            }
+            file.close();
+            return;
+          }
+          const findFile = files.find(f => f.path === itm.filePath || f.name === itm.fileName);
+          if (!findFile) {
+            Log.error(`File ${itm.filePath} not found`);
+            throw new Error(`File ${itm.filePath} not found`);
+          }
+          let contentType = mime.getType(findFile.ext);
+          if (!contentType) {
+            contentType = 'application/octet-stream';
+          }
+          const buffer = await fs.readFile(path.join(projectDir, 'dist', itm.filePath));
+          const response = await fetch(itm.requestUploadUrl, {
+            method: 'PUT',
+            headers: {
+              'Content-Type': contentType,
+              'Cache-Control': 'max-age=31556926',
+            },
+            body: buffer,
+          });
+          if (!response.ok) {
+            Log.error('Failed to upload file', await response.text());
+            throw new Error('Failed to upload file');
+          }
+          file.close();
+        })
+      );
+      uploadFilesSpinner.succeed('Files uploaded successfully');
+    } catch {
+      uploadFilesSpinner.fail('Failed to upload static files');
+    }
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,7 @@
+declare module 'better-opn' {
+  function open(
+    target: string,
+    options?: any
+  ): Promise<import('child_process').ChildProcess | false>;
+  export = open;
+}

package/src/lib/assets.ts

@@ -0,0 +1,118 @@
+// This file is partially copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+import { Platform } from '@expo/config';
+import fs from 'fs-extra';
+import Joi from 'joi';
+import fetch from 'node-fetch';
+import path from 'path';
+
+import { ExpoCredentials, getAuthExpoHeaders } from './auth';
+import { RequestedPlatform } from './expoConfig';
+import Log from './log';
+
+const fileMetadataJoi = Joi.object({
+  assets: Joi.array()
+    .required()
+    .items(Joi.object({ path: Joi.string().required(), ext: Joi.string().required() })),
+  bundle: Joi.string().required(),
+}).optional();
+export const MetadataJoi = Joi.object({
+  version: Joi.number().required(),
+  bundler: Joi.string().required(),
+  fileMetadata: Joi.object({
+    android: fileMetadataJoi,
+    ios: fileMetadataJoi,
+    web: fileMetadataJoi,
+  }).required(),
+}).required();
+
+type Metadata = {
+  version: number;
+  bundler: 'metro';
+  fileMetadata: {
+    [key in Platform]: { assets: { path: string; ext: string }[]; bundle: string };
+  };
+};
+
+interface AssetToUpload {
+  path: string;
+  name: string;
+  ext: string;
+}
+
+function loadMetadata(distRoot: string): Metadata {
+  // eslint-disable-next-line
+  const fileContent = fs.readFileSync(path.join(distRoot, 'metadata.json'), 'utf8');
+  let metadata: Metadata;
+  try {
+    metadata = JSON.parse(fileContent);
+  } catch (e: any) {
+    Log.error(`Failed to read metadata.json: ${e.message}`);
+    throw e;
+  }
+  const { error } = MetadataJoi.validate(metadata);
+  if (error) {
+    throw error;
+  }
+  // Check version and bundler by hand (instead of with Joi) so
+  // more informative error messages can be returned.
+  if (metadata.version !== 0) {
+    throw new Error('Only bundles with metadata version 0 are supported');
+  }
+  if (metadata.bundler !== 'metro') {
+    throw new Error('Only bundles created with Metro are currently supported');
+  }
+  const platforms = Object.keys(metadata.fileMetadata);
+  if (platforms.length === 0) {
+    Log.warn('No updates were exported for any platform');
+  }
+  Log.debug(`Loaded ${platforms.length} platform(s): ${platforms.join(', ')}`);
+  return metadata;
+}
+
+export function computeFilesRequests(
+  projectDir: string,
+  requestedPlatform: RequestedPlatform
+): AssetToUpload[] {
+  const metadata = loadMetadata(path.join(projectDir, 'dist'));
+  const assets: AssetToUpload[] = [
+    { path: 'metadata.json', name: 'metadata.json', ext: 'json' },
+    { path: 'expoConfig.json', name: 'expoConfig.json', ext: 'json' },
+  ];
+  for (const platform of Object.keys(metadata.fileMetadata) as Platform[]) {
+    if (requestedPlatform !== RequestedPlatform.All && requestedPlatform !== platform) {
+      continue;
+    }
+    const bundle = metadata.fileMetadata[platform].bundle;
+    assets.push({ path: bundle, name: path.basename(bundle), ext: 'hbc' });
+    for (const asset of metadata.fileMetadata[platform].assets) {
+      assets.push({ path: asset.path, name: path.basename(asset.path), ext: asset.ext });
+    }
+  }
+  return assets;
+}
+
+export interface RequestUploadUrlItem {
+  requestUploadUrl: string;
+  fileName: string;
+  filePath: string;
+}
+
+export async function requestUploadUrls(
+  body: { fileNames: string[] },
+  requestUploadUrl: string,
+  auth: ExpoCredentials,
+  runtimeVersion: string
+): Promise<RequestUploadUrlItem[]> {
+  const response = await fetch(`${requestUploadUrl}?runtimeVersion=${runtimeVersion}`, {
+    method: 'POST',
+    headers: {
+      ...getAuthExpoHeaders(auth),
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to request upload URL`);
+  }
+  return await response.json();
+}

package/src/lib/auth.ts

@@ -0,0 +1,67 @@
+import { homedir } from 'os';
+import path from 'path';
+
+export interface ExpoCredentials {
+  token?: string;
+  sessionSecret?: string;
+}
+type SessionData = {
+  sessionSecret: string;
+  userId: string;
+  username: string;
+  currentConnection: 'Username-Password-Authentication' | 'Browser-Flow-Authentication';
+};
+
+function dotExpoHomeDirectory(): string {
+  const home = homedir();
+  if (!home) {
+    throw new Error(
+      "Can't determine your home directory; make sure your $HOME environment variable is set."
+    );
+  }
+
+  let dirPath;
+  if (process.env.EXPO_STAGING) {
+    dirPath = path.join(home, '.expo-staging');
+  } else if (process.env.EXPO_LOCAL) {
+    dirPath = path.join(home, '.expo-local');
+  } else {
+    dirPath = path.join(home, '.expo');
+  }
+  return dirPath;
+}
+
+function getStateJsonPath(): string {
+  return path.join(dotExpoHomeDirectory(), 'state.json');
+}
+
+function getExpoSessionData(): SessionData | null {
+  try {
+    const stateJsonPath = getStateJsonPath();
+    const stateJson = require(stateJsonPath);
+    return stateJson['auth'] || null;
+  } catch {
+    return null;
+  }
+}
+
+export function retrieveExpoCredentials(): ExpoCredentials {
+  const token = process.env.EXPO_TOKEN;
+  const sessionData = getExpoSessionData();
+  const sessionSecret = sessionData?.sessionSecret;
+  return { token, sessionSecret };
+}
+
+export function getAuthExpoHeaders(credentials: ExpoCredentials): Record<string, string> {
+  if (credentials.token) {
+    return {
+      Authorization: `Bearer ${credentials.token}`,
+    };
+  }
+  if (credentials.sessionSecret) {
+    return {
+      'expo-session': credentials.sessionSecret,
+    };
+  }
+  return {};
+}