@journeyapps/cloudcode-build-agent 0.0.0-dev.9188dcc → 0.0.0-dev.9aa2c43

package/dist/run.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = void 0;
+const spawn_stream_1 = require("./spawn-stream");
+async function* runCommand(command, args, options) {
+    const { childProcess, stream } = (0, spawn_stream_1.spawnStream)(command, args, { cwd: options?.cwd, splitLines: true, ...options });
+    let exitCode = null;
+    for await (let event of stream) {
+        yield event;
+        if (event.exitCode != null) {
+            exitCode = event.exitCode;
+        }
+    }
+    if (exitCode != 0) {
+        throw new Error(`Command failed with code ${exitCode}`);
+    }
+}
+exports.runCommand = runCommand;
+//# sourceMappingURL=run.js.map

package/dist/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":";;;AAAA,iDAA+D;AAGxD,KAAK,SAAS,CAAC,CAAC,UAAU,CAC/B,OAAe,EACf,IAAc,EACd,OAA+B;IAE/B,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,IAAA,0BAAW,EAAC,OAAO,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAEjH,IAAI,QAAQ,GAAkB,IAAI,CAAC;IAEnC,IAAI,KAAK,EAAE,IAAI,KAAK,IAAI,MAAM,EAAE;QAC9B,MAAM,KAAK,CAAC;QACZ,IAAI,KAAK,CAAC,QAAQ,IAAI,IAAI,EAAE;YAC1B,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;SAC3B;KACF;IAED,IAAI,QAAQ,IAAI,CAAC,EAAE;QACjB,MAAM,IAAI,KAAK,CAAC,4BAA4B,QAAQ,EAAE,CAAC,CAAC;KACzD;AACH,CAAC;AAnBD,gCAmBC"}

package/dist/spawn-stream.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { SpawnOptions } from 'child_process';
+export interface StreamOptions {
+    splitLines?: boolean;
+}
+export declare function spawnStream(command: string, args: string[], options: SpawnOptions & StreamOptions): {
+    childProcess: import("child_process").ChildProcessWithoutNullStreams;
+    stream: AsyncIterable<SpawnStreamEvent>;
+};
+export interface SpawnStreamEvent {
+    event: 'stdout' | 'stderr' | 'exit';
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+}

package/dist/spawn-stream.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnStream = void 0;
+const child_process_1 = require("child_process");
+const stream_1 = require("stream");
+function spawnStream(command, args, options) {
+    const process = (0, child_process_1.spawn)(command, args, {
+        ...options,
+        stdio: 'pipe'
+    });
+    return {
+        childProcess: process,
+        stream: processToStream(process, options)
+    };
+}
+exports.spawnStream = spawnStream;
+function processToStream(process, options) {
+    const combinedStream = new stream_1.PassThrough({ objectMode: true });
+    async function* transform(stream, key) {
+        stream.setEncoding('utf-8');
+        let iterable = stream;
+        if (options.splitLines) {
+            iterable = splitLines(iterable);
+        }
+        for await (const chunk of iterable) {
+            yield {
+                event: key,
+                [key]: chunk
+            };
+        }
+    }
+    if (process.stdout) {
+        stream_1.Readable.from(transform(process.stdout, 'stdout')).pipe(combinedStream, { end: false });
+    }
+    if (process.stderr) {
+        stream_1.Readable.from(transform(process.stderr, 'stderr')).pipe(combinedStream, { end: false });
+    }
+    process.on('exit', (code) => {
+        combinedStream.write({ exitCode: code }, () => {
+            combinedStream.end();
+        });
+    });
+    return combinedStream;
+}
+async function* splitLines(stream) {
+    let buffer = '';
+    for await (const chunk of stream) {
+        buffer += chunk;
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+        for (let line of lines) {
+            yield `${line}\n`;
+        }
+    }
+    if (buffer) {
+        yield buffer;
+    }
+}
+//# sourceMappingURL=spawn-stream.js.map

package/dist/spawn-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-stream.js","sourceRoot":"","sources":["../src/spawn-stream.ts"],"names":[],"mappings":";;;AAAA,iDAAkE;AAClE,mCAA+C;AAM/C,SAAgB,WAAW,CAAC,OAAe,EAAE,IAAc,EAAE,OAAqC;IAChG,MAAM,OAAO,GAAG,IAAA,qBAAK,EAAC,OAAO,EAAE,IAAI,EAAE;QACnC,GAAG,OAAO;QACV,KAAK,EAAE,MAAM;KACd,CAAC,CAAC;IAEH,OAAO;QACL,YAAY,EAAE,OAAO;QACrB,MAAM,EAAE,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC;KAC1C,CAAC;AACJ,CAAC;AAVD,kCAUC;AASD,SAAS,eAAe,CAAC,OAAqB,EAAE,OAAsB;IACpE,MAAM,cAAc,GAAG,IAAI,oBAAW,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IAE7D,KAAK,SAAS,CAAC,CAAC,SAAS,CAAC,MAAgB,EAAE,GAAwB;QAClE,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAC5B,IAAI,QAAQ,GAA0B,MAAM,CAAC;QAC7C,IAAI,OAAO,CAAC,UAAU,EAAE;YACtB,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;SACjC;QACD,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,QAAQ,EAAE;YAClC,MAAM;gBACJ,KAAK,EAAE,GAAG;gBACV,CAAC,GAAG,CAAC,EAAE,KAAK;aACb,CAAC;SACH;IACH,CAAC;IAED,IAAI,OAAO,CAAC,MAAM,EAAE;QAClB,iBAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;KACzF;IACD,IAAI,OAAO,CAAC,MAAM,EAAE;QAClB,iBAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;KACzF;IAED,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAmB,EAAE,EAAE;QACzC,cAAc,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE;YAC5C,cAAc,CAAC,GAAG,EAAE,CAAC;QACvB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,KAAK,SAAS,CAAC,CAAC,UAAU,CAAC,MAA6B;IACtD,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE;QAChC,MAAM,IAAI,KAAK,CAAC;QAChB,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACjC,MAAM,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;QACtB,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE;YACtB,MAAM,GAAG,IAAI,IAAI,CAAC;SACnB;KACF;IACD,IAAI,MAAM,EAAE;QACV,MAAM,MAAM,CAAC;KACd;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@journeyapps/cloudcode-build-agent",
-  "version": "0.0.0-dev.9188dcc",
+  "version": "0.0.0-dev.9aa2c43",
   "description": "",
   "main": "./dist/index",
   "types": "./dist/index",
@@ -9,11 +9,21 @@
     "cloudcode-build-agent": "./bin.js"
   },
   "dependencies": {
+    "child-process-promise": "^2.2.1",
     "fs-jetpack": "5.1.0",
+    "lodash": "4.17.21",
+    "node-fetch": "<3",
+    "semver": "7.3.8",
+    "tar": "6.1.13",
     "yargs": "17.6.2"
   },
   "devDependencies": {
-    "@types/node": "^18.6.3",
+    "@types/child-process-promise": "2.2.2",
+    "@types/lodash": "4.14.191",
+    "@types/node": "14.18.36",
+    "@types/node-fetch": "2.6.2",
+    "@types/semver": "7.3.13",
+    "@types/tar": "6.1.4",
     "@types/yargs": "17.0.22",
     "typescript": "4.9.5"
   },

package/src/builder.ts

@@ -1,7 +1,122 @@
-import { spawnSync } from 'child_process';
+import * as path from 'node:path';
+import * as jetpack from 'fs-jetpack';
+import * as semver from 'semver';
 
-// Detect tasks in given path and build them.
-export async function buildTasks(src: string, dest: string, only?: string) {}
+import { ensureCustomNodeVersion } from './installer';
+import { detectTasks, DetectedTask } from './detect_tasks';
+import { runCommand } from './run';
 
-// Build a single task in the specified subdirectory.
-async function buildTask(src: string, dest: string, config: any) {}
+import * as _ from 'lodash';
+
+export type GeneralTaskConfig = {
+  app_id: string;
+  env: string;
+  backend_id: string;
+  backend_url: string;
+};
+
+export type BuildOptions = {
+  only?: string;
+  custom_node_installation_path?: string;
+};
+
+type ToolPaths = { bin_path: string; node_bin: string; npm_bin: string };
+
+export async function buildTasks(
+  project_path: string,
+  dest: string,
+  config: GeneralTaskConfig,
+  options?: BuildOptions
+) {
+  const tasks = await detectTasks(project_path, options?.only);
+
+  // Use the version of nodejs that's running this script as the default.
+  const default_tool_paths = {
+    bin_path: path.dirname(process.execPath),
+    node_bin: process.execPath,
+    npm_bin: path.join(path.dirname(process.execPath), 'npm')
+  };
+
+  for (const task of tasks) {
+    let custom_tool_paths;
+    if (task.required_node_version) {
+      // FIXME: when defaulting to project_path, the custom node installation is copied into the builder's workdir as well.
+      const custom_node_installation_path = options?.custom_node_installation_path ?? project_path;
+      const custom_node_path = path.resolve(
+        custom_node_installation_path,
+        `node-${semver.major(task.required_node_version)}`
+      );
+      custom_tool_paths = await ensureCustomNodeVersion(task.required_node_version, custom_node_path);
+    }
+    const node_version = task.required_node_version ?? process.version;
+
+    await buildTask(task, project_path, dest, config, {
+      node_version,
+      ...(custom_tool_paths ?? default_tool_paths)
+    });
+  }
+}
+
+export async function buildTask(
+  task: DetectedTask,
+  project_path: string,
+  dest: string,
+  config: GeneralTaskConfig,
+  node_context: { node_version: string } & ToolPaths
+) {
+  const builder_package = task.builder_package;
+  const builder_script = task.builder_script;
+  const { bin_path, node_bin, npm_bin } = node_context;
+  const builder_bin = path.resolve(bin_path, builder_script);
+
+  if (!jetpack.exists(node_bin)) {
+    throw new Error(`Node binary not found: ${node_bin}`);
+  }
+
+  console.debug(
+    `[${task.task_name}] Installing builder script "${builder_package}" for node ${node_context.node_version}`
+  );
+  // debug(`Installing builder script "${builder_package}" for node ${node_version}`);
+
+  const stream1 = runCommand(node_bin, [npm_bin, '--global', 'install', builder_package], {
+    cwd: project_path,
+    env: process.env
+  });
+  for await (let event of stream1) {
+    const log = event.stdout ?? event.stderr;
+    if (log) {
+      console.log(`[${task.task_name} - install]`, log.trimRight());
+    }
+  }
+
+  if (!jetpack.exists(builder_bin)) {
+    console.error(`[${task.task_name}] ${builder_bin} not found`);
+    throw new Error(`Builder script not found for task ${task.task_name}`);
+  }
+
+  const builder_args: string[] = [];
+  // --src ./ --out ./dist/echo --task echo --appId 'appid' --env 'testing' --backendId 'backendid' --backendUrl 'http://run.journeyapps.test'
+  builder_args.push(builder_bin);
+  builder_args.push('--src', project_path);
+  builder_args.push(`--out`, path.join(dest, task.task_name));
+  builder_args.push(`--zip`, path.join(dest, `${task.task_name}.zip`));
+  builder_args.push(`--task`, `${task.task_name}`);
+  builder_args.push(`--appId`, config.app_id);
+  builder_args.push(`--env`, config.env);
+  builder_args.push(`--backendId`, config.backend_id);
+  builder_args.push(`--backendUrl`, config.backend_url);
+  // builder_args.push(`--runInstallScripts`, 'true'); // TODO: handle this from feature flags somehow
+
+  console.debug(`[${task.task_name}] Trying: ${node_bin} ${builder_args.join(' ')}`);
+  // debug(`Trying: ${node_bin} ${builder_args.join(' ')}`);
+
+  const stream2 = runCommand(node_bin, builder_args, { cwd: project_path, env: process.env });
+
+  for await (let event of stream2) {
+    const log = event.stdout ?? event.stderr;
+    if (log) {
+      console.log(`[${task.task_name} - build]`, log.trimRight());
+    }
+  }
+  // console.debug('----');
+}

package/src/cli.ts

@@ -2,40 +2,41 @@
 
 import * as yargs from 'yargs';
 
-import { ProcessError, buildTasks, prepareBuildEnvForTasks } from './';
+import { buildTasks } from './';
 
 const DEFAULT_SRC_PATH = './';
-const DEFAULT_OUT_PATH = '';
+const DEFAULT_OUT_PATH = './dist/cloudcode';
+const DEFAULT_TMP_PATH = '/tmp/cloudcode-build-agent/node';
 
 yargs
   .command(
     ['build', '$0'], // $0 means this is the default command
     'build tasks',
     (yargs) => {
-      return yargs
-        .option('only', { string: true })
-        .option('path', { default: DEFAULT_SRC_PATH })
-        .option('out', { default: DEFAULT_OUT_PATH });
+      return (
+        yargs
+          .option('only', { string: true })
+          .option('path', { default: DEFAULT_SRC_PATH })
+          .option('out', { default: DEFAULT_OUT_PATH })
+          .option('node_work_dir', { default: DEFAULT_TMP_PATH })
+          // TODO: investigate yargs.config() for reading task config blob from a file. But how to ensure required args?
+          .option('appId', { string: true, demandOption: true, describe: "CloudCode's reference id" })
+          .option('env', { string: true, demandOption: true })
+          .option('backendId', { string: true, demandOption: true })
+          .option('backendUrl', { string: true, demandOption: true })
+      );
     },
     handled(async (argv) => {
-      // iterate over task directories and run: 'yarn cloudcode-build'.
-      // optionally filtered by `argv.only` to build a single task.
-
-      await buildTasks(argv.path, argv.out, argv.only);
-    })
-  )
-  .command(
-    'prepare-env',
-    'Install node environments and packages for each task',
-    (yargs) => {
-      return yargs.option('only', { string: true }).option('path', { default: DEFAULT_SRC_PATH });
-    },
-    handled(async (argv) => {
-      // iterate over task directories:
-      //   ensure required node version for task CC version is installed - What if too old - error?
-      //   run yarn install
-
-      await prepareBuildEnvForTasks(argv.path, argv.only);
+      const config = {
+        app_id: argv.appId,
+        env: argv.env,
+        backend_id: argv.backendId,
+        backend_url: argv.backendUrl
+      };
+      await buildTasks(argv.path, argv.out, config, {
+        only: argv.only,
+        custom_node_installation_path: argv.node_work_dir
+      });
     })
   )
   .option('verbose', {
@@ -48,13 +49,8 @@ function handled<T>(fn: (argv: T) => Promise<void>): (argv: T) => Promise<void>
     try {
       await fn(argv);
     } catch (err) {
-      if (err instanceof ProcessError) {
-        console.error(err.message);
-        process.exit(err.status);
-      } else {
-        console.error(err.stack);
-        process.exit(1);
-      }
+      console.error(err.stack);
+      process.exit(1);
     }
   };
 }

package/src/defs.ts

@@ -0,0 +1,34 @@
+// TODO: maybe publish (some of) this from the CC service?
+export const SUPPORTED_VERSIONS = [
+  // {
+  //   // proposed
+  //   version: '1.13.0',
+  //   node: '16.19.1',
+  //   builder_package: '@journeyapps/cloudcode-build@1.13.0',
+  //   builder_script: 'cloudcode-build'
+  // },
+  {
+    version: '1.12.0',
+    node: '16.19.1', // FIXME: maybe the very specific node version here is too brittle? Should we just specify the major version?
+    builder_package: '@journeyapps/cloudcode-build-legacy@1.12.0',
+    builder_script: 'cloudcode-build-legacy'
+  },
+  {
+    version: '1.11.2',
+    node: '14.21.3',
+    builder_package: '@journeyapps/cloudcode-build-legacy@1.12.0',
+    builder_script: 'cloudcode-build-legacy'
+  },
+  {
+    version: '1.11.1',
+    node: '14.21.3',
+    builder_package: '@journeyapps/cloudcode-build-legacy@1.12.0',
+    builder_script: 'cloudcode-build-legacy'
+  },
+  {
+    version: '1.11.0',
+    node: '14.21.3',
+    builder_package: '@journeyapps/cloudcode-build-legacy@1.12.0',
+    builder_script: 'cloudcode-build-legacy'
+  }
+];

package/src/detect_tasks.ts

@@ -0,0 +1,83 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as jetpack from 'fs-jetpack';
+import * as semver from 'semver';
+import * as defs from './defs';
+
+// TODO: validations for cloudcode specific keys and structure?
+async function readPackage(path: string) {
+  try {
+    const content = await fs.promises.readFile(path, { encoding: 'utf-8' });
+    return JSON.parse(content);
+  } catch (err) {
+    console.error(`ERROR: ${err}`);
+    throw err;
+    // todo: check for enoent and skip?
+    // todo: if json error, throw a CC build error?
+  }
+}
+
+export type DetectedTask = {
+  pkg_path: string;
+  task_name: string;
+  task_version: string;
+  required_node_version?: string;
+  builder_package: string;
+  builder_script: string;
+};
+
+export async function detectTasks(project_path: string, only?: string): Promise<DetectedTask[]> {
+  const package_files = await jetpack.findAsync(path.join(project_path, 'cloudcode'), { matching: '**/package.json' });
+  const filtered_package_files = package_files.filter((pkg_path) => {
+    // FIXME: this is kinda clunky.
+    const pm = /^\/?cloudcode\/([^\/]+)\/package\.json$/.exec(pkg_path);
+    if (!pm) {
+      return false;
+    }
+    const taskName = pm[1];
+
+    if (only != null && only != taskName) {
+      // !(only.indexOf(taskName) >= 0) // TODO: support a specific list of tasks to build?
+      return false;
+    }
+    return true;
+  });
+
+  return Promise.all(
+    filtered_package_files.map(async (pkg_path) => {
+      const task_package = await readPackage(pkg_path);
+
+      const task_name = task_package.name; // CAVEAT: the pkg name _must_ match the dir.
+      const task_version = task_package?.cloudcode?.runtime;
+      // FIXME: Do we want to filter out disabled tasks from the build process?
+
+      console.debug(`Detected task version ${task_version}`);
+
+      const matching = defs.SUPPORTED_VERSIONS.find((v) => {
+        return semver.satisfies(v.version, task_version);
+      });
+      if (!matching) {
+        throw new Error('FIXME: unsupported version');
+      }
+
+      console.debug(`Matching versions: ${JSON.stringify(matching)}`);
+
+      const running_node_version = process.versions.node;
+      let required_node_version;
+      // if (matching?.node && semver.major(matching.node) !== semver.major(running_node_version)) {
+      if (matching?.node && semver.parse(matching.node) !== semver.parse(running_node_version)) {
+        console.debug(`Task requires different node version: v${matching.node}`);
+
+        required_node_version = matching.node;
+      }
+      return {
+        pkg_path,
+        task_name,
+        task_version,
+        required_node_version,
+        builder_package: matching.builder_package,
+        builder_script: matching.builder_script
+      };
+    })
+  );
+}

package/src/index.ts

@@ -1,3 +1 @@
-export * from './errors';
 export * from './builder';
-export * from './installer';

package/src/installer.ts

@@ -1,68 +1,117 @@
-import { spawnSync } from 'child_process';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
 import * as jetpack from 'fs-jetpack';
+import * as path from 'node:path';
+import * as URL from 'node:url';
+import fetch from 'node-fetch';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as tar from 'tar';
 
-const SUPPORTED_VERSIONS = [
-  {
-    version: '1.12.0',
-    node: '16'
-  },
-  {
-    version: '1.11.2',
-    node: '14'
-  },
-  {
-    version: '1.11.1',
-    node: '14'
-  },
-  {
-    version: '1.11.0',
-    node: '14'
+export async function ensureCustomNodeVersion(node_version: string, install_path: string) {
+  if (!jetpack.exists(path.join(install_path, 'bin/node'))) {
+    console.debug(`[node ${node_version}] Installing to ${install_path}`);
+    await jetpack.dirAsync(install_path);
+    await downloadAndInstallNode(node_version, install_path);
+  } else {
+    console.debug(`[node ${node_version}] Already installed in ${install_path}`);
   }
-];
-
-export async function prepareBuildEnvForTasks(project_path: string, only?: string) {
-  // const subdirs = (await fs.readdir(project_path, { withFileTypes: true }))
-  //   .filter((dirent) => dirent.isDirectory())
-  //   .map((d) => d.name);
-
-  // for (const dir of subdirs) {
-  //   try {
-  //   } catch (err) {
-  //     console.error(`ERROR: ${err}`)
-  //       // todo: check for enoent and skip
-  //       // todo: if json error, throw a CC build error
-  //   }
-  // }
-
-  const package_files = await jetpack.findAsync(path.join(project_path, 'cloudcode'), { matching: '**/package.json' });
-
-  for (const pkg_path of package_files) {
-    console.log(pkg_path);
-    const pm = /^\/?cloudcode\/([^\/]+)\/package\.json$/.exec(pkg_path);
-    if (!pm) {
-      continue;
-    }
-    const taskName = pm[1];
+  return nodePaths(install_path);
+}
 
-    if (only != null && only != taskName) {
-      // !(only.indexOf(taskName) >= 0)
-      continue;
-    }
+/* Basically this, but for different dirs.
+    curl https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}-linux-${PLATFORM}64.tar.gz -L | tar -xzC /node-dedicated && \
+    mv /node-dedicated/node-v${NODE_VERSION}-linux-${PLATFORM}64/bin/node /node-dedicated/node 
+*/
+// TODO: feature to find the latest minor and patch for a given major version?
+export async function downloadAndInstallNode(node_version: string, destination: string) {
+  // eg. https://nodejs.org/dist/v18.14.2/node-v18.14.2-linux-x64.tar.xz
+  const ARCH = os.arch();
+  const PLATFORM = os.platform();
+  const node_download_url = `https://nodejs.org/dist/v${node_version}/node-v${node_version}-${PLATFORM}-${ARCH}.tar.gz`;
 
-    try {
-      const content = await fs.readFile(pkg_path, { encoding: 'utf-8' });
-      const task_package = JSON.parse(content);
-      const task_version = task_package?.cloudcode?.runtime;
-
-      // check task version against supported versions, install relevant node version and yarn
-      // cwd into directory and run the correct node's yarn.
-      console.log(`Detected task version ${task_version}`);
-    } catch (err) {
-      console.error(`ERROR: ${err}`);
-      // todo: check for enoent and skip
-      // todo: if json error, throw a CC build error
-    }
+  await downloadAndExtractTarball(node_download_url, destination);
+  return nodePaths(destination);
+}
+
+export function nodePaths(destination: string) {
+  return {
+    bin_path: path.resolve(destination, 'bin'),
+    node_bin: path.resolve(destination, 'bin', 'node'),
+    npm_bin: path.resolve(destination, 'bin', 'npm')
+  };
+}
+
+export async function downloadAndExtractTarball(url: string, dest: string) {
+  const tmpdir = os.tmpdir();
+
+  const filename = path.basename(URL.parse(url).pathname as string);
+  const base = path.basename(filename, '.tar.gz');
+  const download = path.join(tmpdir, filename);
+
+  if (fs.existsSync(download)) {
+    console.debug(`deleting old ${download}`);
+    fs.unlinkSync(download);
   }
+
+  await new Promise(async (resolve, reject) => {
+    console.log(`fetching ${url} into ${download}`);
+
+    const response = await fetch(url);
+    if (!response.ok) {
+      const errorBody = await response.statusText;
+      throw new Error(`Failed to download: ${errorBody}`);
+    }
+
+    const file = fs.createWriteStream(download); // Sink the download stream into a file, so it can be extracted.
+    response.body.pipe(file);
+
+    file.on('finish', async () => {
+      try {
+        console.debug('Extracting...', download);
+
+        tar.extract({
+          cwd: tmpdir,
+          file: download,
+          sync: true
+        });
+
+        const uncomp = path.join(tmpdir, base);
+
+        const dist = path.resolve(dest);
+        // FIXME: dangerous. Add protection or replace.
+        // if (fs.existsSync(dist)) {
+        //   fs.rmSync(dist, { recursive: true });
+        // }
+        if (fs.existsSync(uncomp)) {
+          console.debug(`Moving extracted files from ${uncomp} to ${dist}`);
+          fs.renameSync(uncomp, dist);
+        } else {
+          console.debug(`Can't find extract dir ${uncomp}`);
+        }
+
+        /*
+          FIXME: this seems to sometimes cause errors: eg.
+          ```
+            node:events:505
+                  throw er; // Unhandled 'error' event
+                  ^
+
+            Error: ENOENT: no such file or directory, open '/var/folders/kc/h6m4zpmd23v13s63mygvkslm0000gn/T/node-v16.19.1-darwin-arm64.tar.gz'
+            Emitted 'error' event on ReadStream instance at:
+                at emitErrorNT (node:internal/streams/destroy:157:8)
+                at emitErrorCloseNT (node:internal/streams/destroy:122:3)
+                at processTicksAndRejections (node:internal/process/task_queues:83:21) {
+              errno: -2,
+              code: 'ENOENT',
+              syscall: 'open',
+              path: '/var/folders/kc/h6m4zpmd23v13s63mygvkslm0000gn/T/node-v16.19.1-darwin-arm64.tar.gz'
+          ```
+        */
+        // fs.unlinkSync(file.path);
+
+        resolve(null);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
 }

package/src/run.ts

@@ -0,0 +1,23 @@
+import { spawnStream, SpawnStreamEvent } from './spawn-stream';
+import { SpawnOptions } from 'child_process';
+
+export async function* runCommand(
+  command: string,
+  args: string[],
+  options?: Partial<SpawnOptions>
+): AsyncIterable<SpawnStreamEvent> {
+  const { childProcess, stream } = spawnStream(command, args, { cwd: options?.cwd, splitLines: true, ...options });
+
+  let exitCode: number | null = null;
+
+  for await (let event of stream) {
+    yield event;
+    if (event.exitCode != null) {
+      exitCode = event.exitCode;
+    }
+  }
+
+  if (exitCode != 0) {
+    throw new Error(`Command failed with code ${exitCode}`);
+  }
+}