feat: initial build

tasks/build.ts

@@ -1,19 +1,91 @@
-import { compile } from '../'
+import { compile } from '../src/nexe'
+import { 
+  getUnBuiltReleases, 
+  getLatestGitRelease 
+} from './releases'
+import * as ci from './ci'
+import { getTarget } from '../src/target'
+import { pathExistsAsync, statAsync, readFileAsync, execFileAsync } from '../src/util'
 import got = require('got')
 
 const env = process.env,
   branchName = env.CIRCLE_BRANCH || env.APPVEYOR_REPO_BRANCH,
-  isScheduled = Boolean(env.APPVEYOR_SCHEDULED_BUILD),
-  isWindows = branchName.includes('win32') && Boolean(env.APPVEYOR),
+  isScheduled = Boolean(env.APPVEYOR_SCHEDULED_BUILD || env.NEXE_TRIGGERED),
+  isLinux = Boolean(env.TRAVIS),
+  isWindows = Boolean(env.APPVEYOR),
+  isMac = Boolean(env.CIRCLECI),
   isPullRequest = Boolean(env.CIRCLE_PR_NUMBER) || Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER)
 
 async function build () {
   if (isScheduled) {
-    const releases = await
+    const releases = await getUnBuiltReleases()
+    if (!releases.length) {
+      return
+    }
+    const windowsBuild = releases.find(x => x.platform === 'windows')
+    const macBuild = releases.find(x => x.platform === 'mac')
+    const linuxOrAlpine = releases.find(x => x.platform === 'linux' || x.platform === 'alpine')
+
+    if (linuxOrAlpine) {
+      await ci.triggerDockerBuild(linuxOrAlpine)
+    }
+    if (macBuild) {
+      await ci.triggerMacBuild(macBuild)
+    }
+    if (windowsBuild) {
+      await ci.triggerWindowsBuild(windowsBuild)
+    }
+  }
+
+  if (env.NEXE_VERSION) {
+    const 
+      target = getTarget(env.NEXE_VERSION),
+      output = isWindows ? './out.exe' : './out',
+      options = {
+        empty: true,
+        build: true,
+        make: [target.arch],
+        version: target.version,
+        output
+      }
+    if (isWindows) {
+      await compile(options)
+    }
+
+    if (isMac) {
+      await compile(options)
+    }
+
+    if (isLinux) {}
+
+    if (await pathExistsAsync(output)) {
+      await assertNexeBinary(output)
+      const gitRelease = await getLatestGitRelease()
+      await got(gitRelease.upload_url.split('{')[0], {
+        query: { name: target.toString() },
+        body: await readFileAsync(output),
+        headers: {
+          'Authorization': 'token ' + env.GITHUB_TOKEN,
+          'Content-Type': 'application/octet-stream'
+        }
+      })
+      console.log(target + ' uploaded.')
+    }
   }
 }
 
-build().catch(x => {
-  console.error(x)
-  process.exit(1)
-})
+function assertNexeBinary (file: string) {
+  return execFileAsync(file).catch(e => {
+    if (e && e.stack && e.stack.includes('Invalid Nexe binary')) {
+      return
+    }
+    throw e
+  })
+}
+
+if (require.main === module) {
+  build().catch(x => {
+    console.error(x)
+    process.exit(1)
+  })
+}

tasks/ci.ts

@@ -0,0 +1,46 @@
+import { NexeTarget } from './releases'
+import got = require('got')
+import * as assert from 'assert'
+const { env } = process
+
+export function triggerDockerBuild(release: NexeTarget) {
+  return Promise.resolve()
+  // assert.ok(env.TRAVIS_TOKEN)
+  // const travis = `https://api.travis-ci.org/repo/nexe/nexe/requests`
+  // return got(travis, {
+  //   json: true,
+  //   body: {
+  //     request: {
+  //       branch: 'master',
+  //       config: {
+  //         merge_mode: 'deep_merge',
+  //         env: {
+  //           NEXE_VERSION: release
+  //         }
+  //       }
+  //     }
+  //   },
+  //   headers: {
+  //     'Travis-API-Version': '3',
+  //     'Authorization': `token ${env.TRAVIS_TOKEN}`
+  //   }
+  // })
+}
+
+export function triggerMacBuild (release: NexeTarget) {
+  return Promise.resolve()
+  // assert.ok(env.CIRCLE_TOKEN)
+  // const circle = `https://circleci.com/api/v1.1/project/github/nexe/nexe/tree/master?circle-token=${env.CIRCLE_TOKEN}`
+  // return got(circle, {
+  //   json: true,
+  //   body: {
+  //     build_parameters: {
+  //       NEXE_VERSION: release
+  //     }
+  //   }
+  // })
+}
+
+export function triggerWindowsBuild (release: NexeTarget) {
+  return Promise.resolve(env.NEXE_VERSION = release.toString())
+}

tasks/releases.ts

@@ -0,0 +1,62 @@
+import got = require('got')
+import {
+  NodePlatform,
+  NodeArch,
+  platforms,
+  architectures,
+  NexeTarget,
+  getTarget,
+  targetsEqual,
+} from '../src/target'
+export { NexeTarget }
+
+export interface GitRelease {
+  tag_name: string
+  assets_url: string
+  upload_url: string
+  assets: Array<{ name: string }>
+}
+
+interface NodeRelease {
+  version: string
+}
+
+async function getJson<T> (url: string) {
+  return JSON.parse((await got(url)).body) as T
+}
+
+//TODO only build the latest of each major...?
+function isBuildableVersion (version: string) {
+  const major = +version.split('.')[0]
+  return ![0, 1, 2, 3, 4, 5, 7].includes(major)
+    || version === '4.8.4'
+}
+
+export function getLatestGitRelease () {
+  return getJson<GitRelease>('https://api.github.com/repos/nexe/nexe/releases/latest')
+}
+
+export async function getUnBuiltReleases () {
+  const nodeReleases = (await getJson<NodeRelease[]>('https://nodejs.org/download/release/index.json'))
+  const existingVersions = (await getLatestGitRelease())
+    .assets.map(x => getTarget(x.name))
+
+  const versionMap: { [key:string]: true } = {}
+  return nodeReleases.reduce((versions: NexeTarget[], { version }) => {
+    version = version.replace('v', '').trim()
+    if (!isBuildableVersion(version) || versionMap[version]) {
+      return versions
+    }
+    versionMap[version] = true
+    platforms.forEach(platform => {
+      architectures.forEach(arch => {
+        if (arch === 'x86' && platform === 'mac') return
+        versions.push(getTarget({ platform, arch, version }))
+      })
+    })
+    return versions
+  }, [])
+  .filter(
+    x => !existingVersions.some(t => targetsEqual(t, x))
+  )
+}