@chronsyn/eas-on-infra 0.0.1

package/dist/ingress.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureRoute = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const multer_1 = __importDefault(require("multer"));
+const zod_1 = __importDefault(require("zod"));
+const unzipper_1 = __importDefault(require("unzipper"));
+const ZBodySchema = zod_1.default.object({
+    eas_access_token: zod_1.default.string(),
+    eas_profile: zod_1.default.string(),
+    eas_platform: zod_1.default.enum(['ios', 'android']),
+    installer: zod_1.default.enum([
+        'npm', // npm i
+        'yarn', // yarn
+        'bun', // bun install
+        'pnpm', // pnpm install
+    ]).optional()
+}).strict();
+const configureRoute = (app) => {
+    const multerDestination = !!process.env.UPLOAD_DIRECTORY
+        ? node_path_1.default.resolve(process.env.UPLOAD_DIRECTORY)
+        : node_path_1.default.resolve(process.cwd(), 'uploads');
+    app.post('/ingress', (0, multer_1.default)({
+        limits: {
+            fileSize: 300000000, // 300MB
+            fieldNameSize: 8 * 50,
+            files: 1,
+            fields: 20,
+        },
+        preservePath: false,
+        storage: multer_1.default.diskStorage({
+            destination: multerDestination,
+            filename: (req, file, cb) => {
+                cb(null, [new Date().getTime(), node_crypto_1.default.randomBytes(16).toString('hex'), '.zip'].join('_'));
+            }
+        }),
+        fileFilter: (req, file, cb) => {
+            if (file.mimetype.toLowerCase() !== 'application/zip') {
+                return cb(new Error('File rejected'));
+            }
+            return cb(null, true);
+        },
+    }).single('bundle'), async (req, res, next) => {
+        var _a, _b, _c, _d;
+        console.log(`Received ingress request...`);
+        const actualInputFilePath = (_a = req.file) === null || _a === void 0 ? void 0 : _a.path;
+        const projectFileExtractName = [
+            new Date().getTime(),
+            node_crypto_1.default.randomBytes(4).toString("hex")
+        ].join('_');
+        const extractedPath = node_path_1.default.resolve(process.env.BINARY_OUTPUT_DIRECTORY
+            ? (process.env.BINARY_OUTPUT_DIRECTORY,
+                projectFileExtractName)
+            : (process.cwd(),
+                'extracted',
+                projectFileExtractName));
+        const directory = await unzipper_1.default.Open.file(actualInputFilePath);
+        await directory.extract({ path: extractedPath });
+        const parse = await ZBodySchema.safeParseAsync(req.body);
+        if (parse.error) {
+            res.status(500).json({ status: "error", error: parse.error });
+            return;
+        }
+        const { eas_access_token, 
+        // eas_project_id,
+        eas_platform, eas_profile, installer = 'npm' } = parse.data;
+        const build_id = node_crypto_1.default.randomBytes(16).toString('hex');
+        const fn = [
+            new Date().getTime(),
+            eas_platform,
+            eas_profile,
+            build_id
+        ].join('__');
+        // If user has provided BINARY_OUTPUT_DIRECTORY in env, use that
+        // Else, fallback to output directory
+        const easBuildOutputPath = node_path_1.default.resolve(((_b = process === null || process === void 0 ? void 0 : process.env) === null || _b === void 0 ? void 0 : _b.BINARY_OUTPUT_DIRECTORY)
+            ? ((_c = process === null || process === void 0 ? void 0 : process.env) === null || _c === void 0 ? void 0 : _c.BINARY_OUTPUT_DIRECTORY, fn)
+            : (process.cwd(), 'builds', fn));
+        console.log(`EXTRACTED PATH => ${extractedPath}`);
+        console.log(`BUILD OUTPUT PATH => ${easBuildOutputPath}`);
+        // const eas_auto_submit = parse.data.eas_auto_submit === "true";
+        let platformParsed;
+        switch (true) {
+            case eas_platform === "ios":
+                platformParsed = 'ios';
+                break;
+            case eas_platform === 'android':
+                platformParsed = 'android';
+                break;
+        }
+        // TODO: chdir to directory, install dependencies
+        // TODO: check for `yarn.lock` to run `yarn install`, `package-lock.json` to run `npm i`, etc.
+        // const easBuildCommandWithArgs = [
+        //   `git init &&`,
+        //   `git add . &&`,
+        //   `git commit -m "ready to build" &&`,
+        //   `${builderToolToUse} &&`,
+        //   `EXPO_TOKEN=${eas_access_token}`,
+        //   'eas build',
+        //   '--profile', eas_profile.toString(),
+        //   '--platform', eas_platform.toString(),
+        //   '--local',
+        //   '--non-interactive',
+        //   '--output', `"${easBuildOutputPath}"`,
+        // ]
+        const easBinaryLocation = (0, node_child_process_1.execSync)(`which eas`, { encoding: 'utf-8' }).trim();
+        console.log("EAS BINARY => ", easBinaryLocation.toString());
+        // // All these are defined values - i.e. no user input
+        // // We're safe to exec them, as this also ensures steps are performed in the order expected
+        // try {
+        //   execSync(`git init`)
+        // } catch (err) {
+        //   console.error("Error with git init: ", err)
+        // }
+        // try {
+        //   execSync(`git add .`);
+        // } catch (err) {
+        //   console.error("Error with git add: ", err)
+        // }
+        // try {
+        //   execSync(`git commit -m "ready to build"`);
+        // } catch (err) {
+        //   console.error("Error with git commit: ", err)
+        // }
+        try {
+            switch (installer) {
+                case 'yarn':
+                    (0, node_child_process_1.execSync)('yarn', {
+                        stdio: 'inherit',
+                        env: Object.assign(Object.assign({}, process.env), { PATH: process.env.PATH, EXPO_TOKEN: eas_access_token }),
+                    });
+                    break;
+                case 'bun':
+                    (0, node_child_process_1.execSync)('bun install', {
+                        stdio: 'inherit',
+                        env: Object.assign(Object.assign({}, process.env), { PATH: process.env.PATH, EXPO_TOKEN: eas_access_token }),
+                    });
+                    break;
+                case "pnpm":
+                    (0, node_child_process_1.execSync)('pnpm install', {
+                        stdio: 'inherit',
+                        env: Object.assign(Object.assign({}, process.env), { PATH: process.env.PATH, EXPO_TOKEN: eas_access_token }),
+                    });
+                    break;
+                case 'npm':
+                default:
+                    (0, node_child_process_1.execSync)('npm i --force', {
+                        stdio: 'inherit',
+                        env: Object.assign(Object.assign({}, process.env), { PATH: process.env.PATH, EXPO_TOKEN: eas_access_token }),
+                    });
+                    break;
+            }
+        }
+        catch (err) {
+            console.error("Error with installer step: ", err);
+        }
+        process.chdir(extractedPath);
+        console.log(`Process cwd is now => `, process.cwd());
+        const easBuildArgs = [
+            `build`,
+            `--profile`, eas_profile.toString(),
+            `--platform`, eas_platform.toString(),
+            `--local`,
+            `--non-interactive`,
+            `--output`, easBuildOutputPath
+        ];
+        // We run this with spawn as there's som user input
+        // We've sanitised it as much as possible, but we still want to minimise risk
+        const easBuildResult = (0, node_child_process_1.spawn)('eas', easBuildArgs, {
+            stdio: 'inherit',
+            shell: false,
+            env: Object.assign(Object.assign({}, process.env), { PATH: process.env.PATH, EXPO_TOKEN: eas_access_token }),
+        });
+        easBuildResult.on('error', (error) => {
+            console.error('Error spawning process:', error);
+        });
+        easBuildResult.on('close', (code, signal) => {
+            console.log(`Process exited with code ${code}, signal: ${signal === null || signal === void 0 ? void 0 : signal.toString()}`);
+        });
+        easBuildResult.on('message', (msg) => {
+            console.log(`Process msg: ${msg.toString()}`);
+        });
+        // easBuildResult.addListener('spawn', () => {
+        //   console.log('[EAS BUILD] [SPAWN]')
+        // })
+        // easBuildResult.addListener('disconnect', () => {
+        //   console.log('[EAS BUILD] [DISCONNECT]')
+        // })
+        // easBuildResult.addListener('error', (msg) => {
+        //   console.log('[EAS BUILD] [ERROR]', msg.toString())
+        // })
+        // easBuildResult.addListener('exit', () => {
+        //   console.log('[EAS BUILD] COMPLETED!')
+        // })
+        // easBuildResult.stdout.on('close', () => {
+        //   console.log('[STDOUT] [EAS BUILD] CLOSE!')
+        // })
+        // easBuildResult.stdout.on('data', (msg) => {
+        //   console.log('[STDOUT] [EAS BUILD]', msg)
+        // })
+        // easBuildResult.stdout.on('end', () => {
+        //   console.log('[STDOUT] [EAS BUILD] END!')
+        // })
+        // easBuildResult.stdout.on('error', (err) => {
+        //   console.log('[STDOUT] [ERR] [EAS BUILD] ', err.message)
+        // })
+        // easBuildResult.stdout.on('pause', () => {
+        //   console.log('[STDOUT] [EAS BUILD] PAUSE!')
+        // })
+        // easBuildResult.stdout.on('readable', () => {
+        //   console.log('[STDOUT] [EAS BUILD] READABLE!')
+        // })
+        // easBuildResult.stdout.on('resume', () => {
+        //   console.log('[STDOUT] [EAS BUILD] RESUME!')
+        // })
+        // easBuildResult.stderr.on('close', () => {
+        //   console.log('[STDERR] [EAS BUILD] CLOSE!')
+        // })
+        // easBuildResult.stderr.on('data', (msg) => {
+        //   console.log('[STDERR] [EAS BUILD]', msg)
+        // })
+        // easBuildResult.stderr.on('end', () => {
+        //   console.log('[STDERR] [EAS BUILD] END!')
+        // })
+        // easBuildResult.stderr.on('error', (err) => {
+        //   console.log('[STDERR] [ERR] [EAS BUILD] ', err.message)
+        // })
+        // easBuildResult.stderr.on('pause', () => {
+        //   console.log('[STDERR] [EAS BUILD] PAUSE!')
+        // })
+        // easBuildResult.stderr.on('readable', () => {
+        //   console.log('[STDERR] [EAS BUILD] READABLE!')
+        // })
+        // easBuildResult.stderr.on('resume', () => {
+        //   console.log('[STDERR] [EAS BUILD] RESUME!')
+        // })
+        // exec(
+        //   easBuildCommandWithArgs,
+        //   {
+        //     cwd: extractedPath
+        //   },
+        //   (err, stdout, stderr) => {
+        //     if (err) console.log('[ERR] => ', err);
+        //     if (stdout) console.log('[STDOUT] => ', stdout);
+        //     if (stderr) console.log('[STDERR] => ', stderr);
+        //   }
+        // )
+        const responseData = {
+            ok: true,
+            status: 'in_progress',
+            build_id,
+            command: easBuildArgs,
+            status_url: `${((_d = process.env.SITE_BASE_URL) !== null && _d !== void 0 ? _d : "")}/status/${build_id}`,
+        };
+        console.log("Processing... Response => ", JSON.stringify(responseData, null, 2));
+        res.status(200).json(responseData);
+    });
+};
+exports.configureRoute = configureRoute;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@chronsyn/eas-on-infra",
+  "version": "0.0.1",
+  "main": "dist/application.core.js",
+  "private": false,
+  "scripts": {
+    "build": "yarn tsc",
+    "serve": "node dist/application.core.js"
+  },
+  "bin": {
+    "eas-on-infra": "./dist/client/root.js"
+  },
+  "_developer_comments": {
+    "client_example_command": "npx eas-on-infra build --profile production --platform ios --installer npm --config_file_path .env --build_server http://192.168.1.25:3000"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@types/archiver": "^7.0.0",
+    "@types/express": "^5.0.6",
+    "@types/express-busboy": "^8.0.4",
+    "@types/express-fileupload": "^1.5.1",
+    "@types/multer": "^2.0.0",
+    "@types/node": "^25.0.2",
+    "@types/unzipper": "^0.10.11",
+    "@types/yargs": "^17.0.35",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@socialgouv/streaming-file-encryption": "^1.1.0",
+    "archiver": "^7.0.1",
+    "busboy": "^1.6.0",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "express-busboy": "^10.1.0",
+    "express-fileupload": "^1.5.2",
+    "form-data": "^4.0.5",
+    "multer": "^2.0.2",
+    "node-fetch": "^3.3.2",
+    "unzipper": "^0.12.3",
+    "yargs": "^18.0.0",
+    "zod": "^4.2.1"
+  }
+}

package/src/application.core.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import express from 'express';
+import dotenv from 'dotenv';
+
+import { configureRoute as postIngressRoute } from './ingress';
+
+dotenv.config({})
+
+const config = {
+  ...process.env
+}
+
+const app = express()
+
+postIngressRoute(app)
+
+export const runServer = () => app.listen(config.PORT, () => {
+  console.log(`App listening on ${config.PORT}`)
+})

package/src/client/root.ts

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+import dotenv from 'dotenv';
+import { runBuild } from "./send-build";
+import { runServer } from '../application.core';
+dotenv.config()
+
+const argv = yargs(hideBin(process.argv)).parseSync()
+
+const { $0, _, ...restArgs } = argv;
+
+enum ESubcommand {
+  build = "build",
+  serve = "serve",
+  publish = "publish",
+  submit = "submit",
+  deploy = "deploy",
+  login = "login",
+  logout = "logout",
+  open = "open",
+  upload = "upload",
+}
+
+const [ subcommand ] = _ as [ESubcommand];
+
+if (!subcommand) {
+  console.log(`You did not provide a command to run`)
+  process.exit(1);
+}
+
+switch (subcommand) {
+  case ESubcommand.build:
+    runBuild()
+    break;
+  case ESubcommand.serve:
+    runServer()
+    break;
+  default:
+    console.log(`The "${subcommand}" option is not implemented or not recognised.`)
+    break;
+}

package/src/client/send-build.ts

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+
+import fetch from "node-fetch";
+
+import FormData from "form-data";
+import archiver from "archiver";
+
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import z from 'zod';
+
+import dotenv from 'dotenv';
+dotenv.config()
+
+const argv = yargs(hideBin(process.argv)).parseSync()
+
+const ZArgs = z.object({
+  access_token: z.string(),
+  profile: z.string(),
+  platform: z.enum(['ios', 'android']),
+  config_file_path: z.string(),
+  build_server: z.url(),
+  installer: z.enum([
+    'npm',  // npm i
+    'yarn', // yarn
+    'bun',  // bun install
+    'pnpm', // pnpm install
+  ]).optional()
+}).strict()
+const { $0, _, ...restArgs } = argv;
+
+export const runBuild = async () => {
+
+  const parsedArgs = ZArgs.safeParse({
+    ...restArgs,
+    access_token: process?.env?.ELB_EAS_ACCESS_TOKEN ?? restArgs?.access_token
+  })
+
+  if (parsedArgs.error) {
+    throw new Error("Error processing command", { cause: parsedArgs.error })
+  }
+
+  // console.log(parsedArgs)
+
+  console.log("Zipping bundle...");
+
+  // Define a custome extension so we can still include zip files (in case user project has any in)
+  const bundleFileExtension = '.ELBZIP';
+  const bundleFileName =  [new Date().getTime(), crypto.randomBytes(16).toString('hex'), bundleFileExtension].join('_');
+  const outputBundlePath = path.resolve(
+    process.cwd(),
+    bundleFileName   
+  );
+  const outputBundleStream = fs.createWriteStream(outputBundlePath);
+  const archive = archiver('zip', { zlib: { level: 9 } })
+
+  // Catch warnings
+  archive.on("warning", (err) => {
+    if (err.code === 'ENOENT') {
+      console.warn(err)
+    } else {
+      throw err;
+    }
+  })
+
+  // Handle errors
+  archive.on("error", (err) => {
+    throw err;
+  })
+
+  // Pipe archive to file
+  archive.pipe(outputBundleStream);
+
+  const directories = (await fsPromises.readdir(process.cwd(), { withFileTypes: true }))
+    .filter(ent => ent.isDirectory())
+    .map(ent => ent.name)
+    .filter(ent => {
+      const ignoredEntries = [
+        'node_modules',
+      ]
+
+      return !ignoredEntries.includes(ent)
+    })
+
+  const rootDirFiles = (await fsPromises.readdir(process.cwd(), { withFileTypes: true }))
+    .filter(ent => ent.isFile())
+    .map(ent => ent.name)
+    .filter(ent => {
+      if (parsedArgs?.data?.config_file_path) {
+        const fileIsEnvConfigFile = path.basename(parsedArgs.data.config_file_path);
+        // Include the config file the user specified
+        if (ent === fileIsEnvConfigFile) {
+          return true;
+        }
+      }
+
+      // Exclude other .env files
+      if (ent.includes(".env")) {
+        return false;
+      }
+      
+      // Don't include any files which use the same extension as we use for our bundle
+      if (ent.includes(bundleFileExtension)) {
+        return false;
+      }
+      return true;
+    })
+
+  // console.log(JSON.stringify({directories, rootDirFiles, outputBundlePath}, null, 2))
+
+  for (const file of rootDirFiles) {
+    const filePath = path.resolve(process.cwd(), file)
+    archive.append(fs.createReadStream(filePath), { name: file })
+  }
+
+  for (const dir of directories) {
+    const dirPath = path.resolve(process.cwd(), dir);
+    archive.directory(dirPath, dir)
+  }
+
+  await archive.finalize()
+
+  outputBundleStream.on('close', async () => {
+    console.log("Bundle close!")
+
+    const formData = new FormData()
+    formData.append("bundle", fs.createReadStream(outputBundlePath))
+    formData.append("eas_profile", parsedArgs.data.profile);
+    formData.append("eas_platform", parsedArgs.data.platform);
+    formData.append("eas_access_token", parsedArgs.data.access_token);
+    formData.append("installer", parsedArgs.data.installer);
+
+    const request = await fetch(`${parsedArgs.data.build_server}/ingress`, {
+      method: 'POST',
+      body: formData,
+      // Note: node-fetch handles the headers automatically when using FormData
+      // But you might need to disable SSL verification if needed:
+      // agent: new (require('https').Agent)({ rejectUnauthorized: false })
+    });
+
+    const response = await request.json()
+
+    console.log(JSON.stringify(response, null, 2))
+    fs.rmSync(outputBundlePath)
+
+    // formData.append('bundle', {
+    //   [Symbol.toStringTag]: 'file',
+    //   name: bundleFileName,
+    //   stream: () => fs.createReadStream(outputBundlePath)
+    // })
+
+    // formData.append('bundle', fileAsBlob, bundleFileName);
+
+    // formData.append("eas_profile", parsedArgs.data.profile);
+    // formData.append("eas_platform", parsedArgs.data.platform);
+    // formData.append("eas_access_token", parsedArgs.data.access_token);
+    // const url = [parsedArgs.data.build_server, 'ingress'].join('/');
+    // const options = {
+    //   method: 'POST',
+    //   headers: {
+    //     'Content-Type': 'multipart/form-data; boundary=---bundle'
+    //   },
+    //   body: formData
+    // }
+    // const request = await fetch(url, options)
+  });
+
+  outputBundleStream.on('end', () => {
+    console.log("Bundle end!")
+  });
+
+  // const fileAsBlob = await fs.openAsBlob(outputBundlePath);
+  // console.log(fileAsBlob);
+
+  // const formData = new FormData()
+  // formData.append("bundle", fs.createReadStream(outputBundlePath))
+
+  // // formData.append('bundle', {
+  // //   [Symbol.toStringTag]: 'file',
+  // //   name: bundleFileName,
+  // //   stream: () => fs.createReadStream(outputBundlePath)
+  // // })
+
+  // // formData.append('bundle', fileAsBlob, bundleFileName);
+
+  // formData.append("eas_profile", parsedArgs.data.profile);
+  // formData.append("eas_platform", parsedArgs.data.platform);
+  // formData.append("eas_access_token", parsedArgs.data.access_token);
+  // const url = [parsedArgs.data.build_server, 'ingress'].join('/');
+  // const options = {
+  //   method: 'POST',
+  //   headers: {
+  //     'Content-Type': 'multipart/form-data; boundary=---bundle'
+  //   },
+  //   body: formData
+  // }
+  // const request = await fetch(url, options)
+  // fs.rmSync(outputBundlePath)
+
+}