containerify 2.0.0

package/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2018 Erlend Oftedal
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,59 @@
+# containerify
+
+containerify allows you to build node.js docker images without docker, allowing you to build a node.js docker image _from within a docker container_. This means you can build the container image on Kubernetes or Openshift - or locally in a docker container for more hermetic builds.
+
+It will pull an image you specify from a given registry, add the node.js application from a given folder, and push the result to a(nother) given registry.
+
+## How to install
+
+```
+npm install -g containerify
+```
+
+## How to use
+
+This will pull the `node:13-slim` image from Docker hub, build the image by adding the application in `src/`, and push the result to the given registry, and set time timestamp of files in the created layers and configs to the current timestamp of the latest git commit.
+
+```
+containerify --fromImage node:13-slim --folder src/ --toImage myapp:latest --toRegistry https://registry.example.com/v2/ --setTimeStamp=$(git show -s --format="%aI" HEAD)
+```
+
+### Command line options
+
+```
+Usage: containerify [options]
+
+Options:
+  --fromImage <name:tag>         Required: Image name of base image - [path/]image:tag
+  --toImage <name:tag>           Required: Image name of target image - [path/]image:tag
+  --folder <full path>           Required: Base folder of node application (contains package.json)
+  --fromRegistry <registry url>  Optional: URL of registry to pull base image from - Default: https://registry-1.docker.io/v2/
+  --fromToken <token>            Optional: Authentication token for from registry
+  --toRegistry <registry url>    Optional: URL of registry to push base image to - Default: https://registry-1.docker.io/v2/
+  --toToken <token>              Optional: Authentication token for target registry
+  --toTar <path>                 Optional: Export to tar file
+  --registry <path>              Optional: Convenience argument for setting both from and to registry
+  --platform <platform>          Optional: Preferred platform, e.g. linux/amd64 or arm64
+  --token <path>                 Optional: Convenience argument for setting token for both from and to registry
+  --user <user>                  Optional: User account to run process in container - default: 1000
+  --workdir <directory>          Optional: Workdir where node app will be added and run from - default: /app
+  --entrypoint <entrypoint>      Optional: Entrypoint when starting container - default: npm start
+  --labels <labels>              Optional: Comma-separated list of key value pairs to use as labels
+  --label <label>                Optional: Single label (name=value). This option can be used multiple times. Wrap in double quotes if value has spaces or other characters that can cause arugment parsing issues.
+  --envs <envs>                  Optional: Comma-separated list of key value paris to use av environment variables.
+  --env <env>                    Optional: Single environment variable (name=value). This option can be used multiple times.
+  --setTimeStamp <timestamp>     Optional: Set a specific ISO 8601 timestamp on all entries (e.g. git commit hash). Default: 1970 in tar files, and current time on manifest/config
+  --verbose                      Verbose logging
+  --allowInsecureRegistries      Allow insecure registries (with self-signed/untrusted cert)
+  --customContent <dirs/files>   Optional: Skip normal node_modules and applayer and include specified root folder files/directories instead
+  --extraContent <dirs/files>    Optional: Add specific content. Specify as local-path:absolute-container-path,local-path2:absolute-container-path2 etc
+  --layerOwner <gid:uid>         Optional: Set specific gid and uid on files in the added layers
+  --buildFolder <path>           Optional: Use a specific build folder when creating the image
+  -h, --help                     output usage information
+```
+
+## Detailed info
+
+Everything in the specified folder (`--folder`) is currently added to the image. It adds one layer with `package.json`, `package-lock.json` and `node_modules` and then a separate layer with the rest.
+
+You may want to prune dev-dependencies and remove any unwanted files before running `containerify`.

package/lib/MIMETypes.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerV2 = exports.OCI = void 0;
+exports.OCI = {
+    index: 'application/vnd.oci.image.index.v1+json',
+    manifest: 'application/vnd.oci.image.manifest.v1+json',
+    layer: {
+        tar: 'application/vnd.oci.image.layer.v1.tar',
+        gzip: 'application/vnd.oci.image.layer.v1.tar+gzip'
+    },
+    config: 'application/vnd.oci.image.config.v1+json'
+};
+exports.DockerV2 = {
+    index: 'application/vnd.docker.distribution.manifest.list.v2+json',
+    manifest: 'application/vnd.docker.distribution.manifest.v2+json',
+    layer: {
+        tar: 'application/vnd.docker.image.rootfs.diff.tar',
+        gzip: 'application/vnd.docker.image.rootfs.diff.tar.gzip',
+    },
+    config: 'application/vnd.docker.container.image.v1+json'
+};

package/lib/appLayerCreator.js

@@ -0,0 +1,239 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tar = require("tar");
+const fs_1 = require("fs");
+const fse = require("fs-extra");
+const fss = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const minizlib_1 = require("minizlib");
+const fileutil = require("./fileutil");
+const logger_1 = require("./logger");
+const utils_1 = require("./utils");
+const version_1 = require("./version");
+const depLayerPossibles = ["package.json", "package-lock.json", "node_modules"];
+const ignore = [".git", ".gitignore", ".npmrc", ".DS_Store", "npm-debug.log", ".svn", ".hg", "CVS"];
+function statCache(layerOwner) {
+    if (!layerOwner)
+        return null;
+    // We use the stat cache to overwrite uid and gid in image.
+    // A bit hacky
+    const statCacheMap = new Map();
+    const a = layerOwner.split(":");
+    const gid = parseInt(a[0]);
+    const uid = parseInt(a[1]);
+    return {
+        get: function (name) {
+            if (statCacheMap.has(name))
+                return statCacheMap.get(name);
+            const stat = fss.statSync(name);
+            stat.uid = uid;
+            stat.gid = gid;
+            stat.atime = new Date(0);
+            stat.mtime = new Date(0);
+            stat.ctime = new Date(0);
+            stat.birthtime = new Date(0);
+            stat.atimeMs = 0;
+            stat.mtimeMs = 0;
+            stat.ctimeMs = 0;
+            stat.birthtimeMs = 0;
+            statCacheMap.set(name, stat);
+            return stat;
+        },
+        set: function (name, stat) {
+            statCacheMap.set(name, stat);
+        },
+        has: function () {
+            return true;
+        },
+    };
+}
+const tarDefaultConfig = {
+    preservePaths: false,
+    follow: true,
+};
+function calculateHashOfBuffer(buf) {
+    const hash = crypto.createHash("sha256");
+    hash.update(buf);
+    return hash.digest("hex");
+}
+function calculateHash(path) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash("sha256");
+        const stream = fss.createReadStream(path);
+        stream.on("error", (err) => reject(err));
+        stream.on("data", (chunk) => hash.update(chunk));
+        stream.on("end", () => resolve(hash.digest("hex")));
+    });
+}
+function copySync(src, dest) {
+    const copyOptions = { overwrite: true, dereference: true };
+    const destFolder = dest.substring(0, dest.lastIndexOf("/"));
+    logger_1.default.debug("Copying " + src + " to " + dest);
+    fse.ensureDirSync(destFolder);
+    fse.copySync(src, dest, copyOptions);
+}
+function addEmptyLayer(config, options, operation, action) {
+    logger_1.default.info(`Applying ${operation}`);
+    config.history.push({
+        created: options.setTimeStamp || new Date().toISOString(),
+        created_by: "/bin/sh -c #(nop) " + operation,
+        empty_layer: true,
+    });
+    action(config);
+}
+function getHashOfUncompressed(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash("sha256");
+            const gunzip = new minizlib_1.Gunzip({});
+            gunzip.on("data", (chunk) => hash.update(chunk));
+            gunzip.on("end", () => resolve(hash.digest("hex")));
+            gunzip.on("error", (err) => reject(err));
+            fss
+                .createReadStream(file)
+                .pipe(gunzip)
+                .on("error", (err) => reject(err));
+        });
+    });
+}
+function addDataLayer(tmpdir, todir, options, config, manifest, files, comment) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.default.info("Adding layer for " + comment + " ...");
+        const buildDir = yield fileutil.ensureEmptyDir(path.join(tmpdir, "build"));
+        files.map((f) => {
+            if (Array.isArray(f)) {
+                copySync(path.join(options.folder, f[0]), path.join(buildDir, f[1]));
+            }
+            else {
+                copySync(path.join(options.folder, f), path.join(buildDir, options.workdir, f));
+            }
+        });
+        const layerFile = path.join(todir, "layer.tar.gz");
+        if (options.layerOwner)
+            logger_1.default.info("Setting file ownership to: " + options.layerOwner);
+        const filesToTar = fss.readdirSync(buildDir);
+        if (filesToTar.length == 0) {
+            throw new Error("No files found for layer: " +
+                comment +
+                (comment == "dependencies" ? ". Did you forget to run npm install?" : ""));
+        }
+        yield tar.c(Object.assign({}, tarDefaultConfig, Object.assign({ statCache: statCache(options.layerOwner), portable: !options.layerOwner, prefix: "/", cwd: buildDir, file: layerFile, gzip: true, noMtime: !options.setTimeStamp }, (options.setTimeStamp ? { mtime: new Date(options.setTimeStamp) } : {}))), filesToTar);
+        const fhash = yield calculateHash(layerFile);
+        const finalName = path.join(todir, fhash + ".tar.gz");
+        yield fse.move(layerFile, finalName);
+        manifest.layers.push({
+            mediaType: (0, utils_1.getManifestLayerType)(manifest),
+            size: yield fileutil.sizeOf(finalName),
+            digest: "sha256:" + fhash,
+        });
+        const dhash = yield getHashOfUncompressed(finalName);
+        config.rootfs.diff_ids.push("sha256:" + dhash);
+        config.history.push({
+            created: options.setTimeStamp || new Date().toISOString(),
+            created_by: `containerify:${version_1.VERSION}`,
+            comment: comment,
+        });
+    });
+}
+function copyLayers(fromdir, todir, layers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(layers.map((layer) => __awaiter(this, void 0, void 0, function* () {
+            const file = layer.digest.split(":")[1] + (0, utils_1.getLayerTypeFileEnding)(layer);
+            yield fse.copy(path.join(fromdir, file), path.join(todir, file));
+        })));
+    });
+}
+function parseCommandLineToParts(entrypoint) {
+    return entrypoint
+        .split('"')
+        .map((p, i) => {
+        if (i % 2 == 1)
+            return [p];
+        return p.split(" ");
+    })
+        .reduce((a, b) => a.concat(b), [])
+        .filter((a) => a != "");
+}
+function addAppLayers(options, config, todir, manifest, tmpdir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (options.customContent) {
+            yield addEnvsLayer(options, config);
+            yield addLabelsLayer(options, config);
+            yield addDataLayer(tmpdir, todir, options, config, manifest, options.customContent, "custom");
+        }
+        else {
+            addEmptyLayer(config, options, `WORKDIR ${options.workdir}`, (config) => (config.config.WorkingDir = options.workdir));
+            const entrypoint = parseCommandLineToParts(options.entrypoint);
+            addEmptyLayer(config, options, `ENTRYPOINT ${JSON.stringify(entrypoint)}`, (config) => (config.config.Entrypoint = entrypoint));
+            addEmptyLayer(config, options, `USER ${options.user}`, (config) => {
+                config.config.User = options.user;
+                config.container_config.User = options.user;
+            });
+            yield addEnvsLayer(options, config);
+            yield addLabelsLayer(options, config);
+            const appFiles = (yield fs_1.promises.readdir(options.folder)).filter((l) => !ignore.includes(l));
+            const depLayerContent = appFiles.filter((l) => depLayerPossibles.includes(l));
+            const appLayerContent = appFiles.filter((l) => !depLayerPossibles.includes(l));
+            yield addDataLayer(tmpdir, todir, options, config, manifest, depLayerContent, "dependencies");
+            yield addDataLayer(tmpdir, todir, options, config, manifest, appLayerContent, "app");
+        }
+        if (options.extraContent) {
+            for (const i in options.extraContent) {
+                yield addDataLayer(tmpdir, todir, options, config, manifest, [options.extraContent[i]], "extra");
+            }
+        }
+    });
+}
+function addLabelsLayer(options, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (Object.keys(options.labels).length > 0) {
+            addEmptyLayer(config, options, `LABELS ${JSON.stringify(options.labels)}`, (config) => {
+                config.config.Labels = options.labels;
+                config.container_config.Labels = options.labels;
+            });
+        }
+    });
+}
+function addEnvsLayer(options, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (options.envs.length > 0) {
+            addEmptyLayer(config, options, `ENV ${JSON.stringify(options.envs)}`, (config) => {
+                // Keep old environment variables
+                config.config.Env = (0, utils_1.unique)([...config.config.Env, ...options.envs]);
+                config.container_config.Env = (0, utils_1.unique)([...config.config.Env, ...options.envs]);
+            });
+        }
+    });
+}
+function addLayers(tmpdir, fromdir, todir, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.default.info("Parsing image ...");
+        const manifest = yield fse.readJson(path.join(fromdir, "manifest.json"));
+        const config = yield fse.readJson(path.join(fromdir, "config.json"));
+        config.container_config = config.container_config || {};
+        logger_1.default.info("Adding new layers...");
+        yield copyLayers(fromdir, todir, manifest.layers);
+        yield addAppLayers(options, config, todir, manifest, tmpdir);
+        logger_1.default.info("Writing final image...");
+        const configContent = Buffer.from(JSON.stringify(config));
+        const configHash = calculateHashOfBuffer(configContent);
+        const configFile = path.join(todir, configHash + ".json");
+        yield fs_1.promises.writeFile(configFile, configContent);
+        manifest.config.digest = "sha256:" + configHash;
+        manifest.config.size = yield fileutil.sizeOf(configFile);
+        yield fs_1.promises.writeFile(path.join(todir, "manifest.json"), JSON.stringify(manifest));
+    });
+}
+exports.default = {
+    addLayers,
+};

package/lib/cli.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = require("os");
+const commander_1 = require("commander");
+const path = require("path");
+const fse = require("fs-extra");
+const fs = require("fs");
+const registry_1 = require("./registry");
+const appLayerCreator_1 = require("./appLayerCreator");
+const tarExporter_1 = require("./tarExporter");
+const logger_1 = require("./logger");
+const utils_1 = require("./utils");
+const fileutil_1 = require("./fileutil");
+const version_1 = require("./version");
+const possibleArgs = {
+    "--fromImage <name:tag>": "Required: Image name of base image - [path/]image:tag",
+    "--toImage <name:tag>": "Required: Image name of target image - [path/]image:tag",
+    "--folder <full path>": "Required: Base folder of node application (contains package.json)",
+    "--file <path>": "Optional: Name of configuration file (defaults to containerify.json if found on path)",
+    "--fromRegistry <registry url>": "Optional: URL of registry to pull base image from - Default: https://registry-1.docker.io/v2/",
+    "--fromToken <token>": "Optional: Authentication token for from registry",
+    "--toRegistry <registry url>": "Optional: URL of registry to push base image to - Default: https://registry-1.docker.io/v2/",
+    "--toToken <token>": "Optional: Authentication token for target registry",
+    "--toTar <path>": "Optional: Export to tar file",
+    "--registry <path>": "Optional: Convenience argument for setting both from and to registry",
+    "--platform <platform>": "Optional: Preferred platform, e.g. linux/amd64 or arm64",
+    "--token <path>": "Optional: Convenience argument for setting token for both from and to registry",
+    "--user <user>": "Optional: User account to run process in container - default: 1000",
+    "--workdir <directory>": "Optional: Workdir where node app will be added and run from - default: /app",
+    "--entrypoint <entrypoint>": "Optional: Entrypoint when starting container - default: npm start",
+    "--labels <labels>": "Optional: Comma-separated list of key value pairs to use as labels",
+    "--label <label>": "Optional: Single label (name=value). This option can be used multiple times.",
+    "--envs <envs>": "Optional: Comma-separated list of key value pairs to use av environment variables.",
+    "--env <env>": "Optional: Single environment variable (name=value). This option can be used multiple times.",
+    "--setTimeStamp <timestamp>": "Optional: Set a specific ISO 8601 timestamp on all entries (e.g. git commit hash). Default: 1970 in tar files, and current time on manifest/config",
+    "--verbose": "Verbose logging",
+    "--allowInsecureRegistries": "Allow insecure registries (with self-signed/untrusted cert)",
+    "--customContent <dirs/files>": "Optional: Skip normal node_modules and applayer and include specified root folder files/directories instead",
+    "--extraContent <dirs/files>": "Optional: Add specific content. Specify as local-path:absolute-container-path,local-path2:absolute-container-path2 etc",
+    "--layerOwner <gid:uid>": "Optional: Set specific gid and uid on files in the added layers",
+    "--buildFolder <path>": "Optional: Use a specific build folder when creating the image",
+    "--version": "Get containerify version",
+};
+function setKeyValue(target, keyValue) {
+    const [k, v] = keyValue.split("=", 2);
+    target[k.trim()] = v.trim();
+}
+const cliLabels = {};
+commander_1.program.on("option:label", (ops) => {
+    setKeyValue(cliLabels, ops);
+});
+const cliEnv = {};
+commander_1.program.on("option:env", (ops) => {
+    setKeyValue(cliEnv, ops);
+});
+const cliOptions = Object.entries(possibleArgs)
+    .reduce((program, [k, v]) => {
+    program.option(k, v);
+    return program;
+}, commander_1.program)
+    .parse()
+    .opts();
+if (cliOptions.version) {
+    console.log(`containerify v${version_1.VERSION}`);
+    process.exit(0);
+}
+const keys = Object.keys(possibleArgs).map((k) => k.split(" ")[0].replace("--", ""));
+const defaultOptions = {
+    workdir: "/app",
+    user: "1000",
+    entrypoint: "npm start",
+};
+if (cliOptions.file && !fs.existsSync(cliOptions.file)) {
+    logger_1.default.error(`Config file '${cliOptions.file}' not found`);
+    process.exit(1);
+}
+if (!cliOptions.file && fs.existsSync(`${cliOptions.folder}/containerify.json`)) {
+    cliOptions.file = "containerify.json";
+}
+const configFromFile = cliOptions.file ? JSON.parse(fs.readFileSync(cliOptions.file, "utf-8")) : {};
+Object.keys(configFromFile).forEach((k) => {
+    if (!keys.includes(k)) {
+        logger_1.default.error(`Unknown option in config-file '${cliOptions.file}': ${k}`);
+        process.exit(1);
+    }
+});
+const labelsOpt = {};
+(_b = (_a = cliOptions.labels) === null || _a === void 0 ? void 0 : _a.split(",")) === null || _b === void 0 ? void 0 : _b.forEach((x) => setKeyValue(labelsOpt, x));
+Object.keys(labelsOpt)
+    .filter((l) => Object.keys(cliLabels).includes(l))
+    .forEach((l) => {
+    exitWithErrorIf(true, `Label ${l} specified both with --labels and --label`);
+});
+const labels = Object.assign(Object.assign(Object.assign({}, configFromFile.labels), labelsOpt), cliLabels); //Let cli arguments override file
+const envOpt = {};
+(_d = (_c = cliOptions.envs) === null || _c === void 0 ? void 0 : _c.split(",")) === null || _d === void 0 ? void 0 : _d.forEach((x) => setKeyValue(envOpt, x));
+Object.keys(envOpt)
+    .filter((l) => Object.keys(cliEnv).includes(l))
+    .forEach((l) => {
+    exitWithErrorIf(true, `Env ${l} specified both with --envs and --env`);
+});
+const envs = Object.assign(Object.assign(Object.assign({}, configFromFile.envs), envOpt), cliEnv); //Let cli arguments overide file
+const cliParams = (0, utils_1.omit)(cliOptions, [
+    "label",
+    "labels",
+    "env",
+    "envs",
+    "customContent",
+    "extraContent",
+]);
+cliParams.customContent = (_e = cliOptions.customContent) === null || _e === void 0 ? void 0 : _e.split(",");
+cliParams.extraContent = (_f = cliOptions.extraContent) === null || _f === void 0 ? void 0 : _f.split(",").map((x) => x.split(":"));
+const options = Object.assign(Object.assign(Object.assign(Object.assign({}, defaultOptions), configFromFile), cliParams), { labels, envs: Object.entries(envs).map(([k, v]) => `${k}=${v}`) });
+function exitWithErrorIf(check, error) {
+    if (check) {
+        logger_1.default.error("ERROR: " + error);
+        commander_1.program.help({ error: true });
+    }
+}
+if (options.verbose)
+    logger_1.default.enableDebug();
+if (options.allowInsecureRegistries)
+    process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = "0";
+exitWithErrorIf(!!options.registry && !!options.fromRegistry, "Do not set both --registry and --fromRegistry");
+exitWithErrorIf(!!options.registry && !!options.toRegistry, "Do not set both --registry and --toRegistry");
+exitWithErrorIf(!!options.token && !!options.fromToken, "Do not set both --token and --fromToken");
+exitWithErrorIf(!!options.token && !!options.toToken, "Do not set both --token and --toToken");
+if (options.setTimeStamp) {
+    try {
+        options.setTimeStamp = new Date(options.setTimeStamp).toISOString();
+    }
+    catch (e) {
+        exitWithErrorIf(true, "Failed to parse date: " + e);
+    }
+    logger_1.default.info("Setting all dates to: " + options.setTimeStamp);
+}
+if (options.layerOwner) {
+    if (!options.layerOwner.match("^[0-9]+:[0-9]+$")) {
+        exitWithErrorIf(true, "layerOwner should be on format <number>:<number> (e.g. 1000:1000) but was: " + options.layerOwner);
+    }
+}
+if (options.registry) {
+    options.fromRegistry = options.registry;
+    options.toRegistry = options.registry;
+}
+if (options.token) {
+    options.fromToken = options.token;
+    options.toToken = options.token;
+}
+exitWithErrorIf(!options.folder, "--folder must be specified");
+exitWithErrorIf(!options.fromImage, "--fromImage must be specified");
+exitWithErrorIf(!options.toImage, "--toImage must be specified");
+exitWithErrorIf(!options.toRegistry && !options.toTar, "Must specify either --toTar or --toRegistry");
+exitWithErrorIf(!options.toRegistry && !options.toToken && !options.toTar, "A token must be given when uploading to docker hub");
+if (options.toRegistry && !options.toRegistry.endsWith("/"))
+    options.toRegistry += "/";
+if (options.fromRegistry && !options.fromRegistry.endsWith("/"))
+    options.fromRegistry += "/";
+if (!options.fromRegistry && !((_j = (_h = (_g = options.fromImage) === null || _g === void 0 ? void 0 : _g.split(":")) === null || _h === void 0 ? void 0 : _h[0]) === null || _j === void 0 ? void 0 : _j.includes("/"))) {
+    options.fromImage = "library/" + options.fromImage;
+}
+if (options.customContent) {
+    options.customContent.forEach((p) => {
+        exitWithErrorIf(!fs.existsSync(p), "Could not find " + p + " in the base folder " + options.folder);
+    });
+}
+if (options.extraContent) {
+    options.extraContent.forEach((p) => {
+        exitWithErrorIf(p.length != 2, "Invalid extraContent - use comma between files/dirs, and : to separate local path and container path");
+        exitWithErrorIf(!fs.existsSync(options.folder + p[0]), "Could not find `" + p[0] + "` in the folder " + options.folder);
+    });
+}
+function run(options) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield fse.pathExists(options.folder)))
+            throw new Error("No such folder: " + options.folder);
+        const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "containerify-"));
+        logger_1.default.debug("Using " + tmpdir);
+        const fromdir = yield (0, fileutil_1.ensureEmptyDir)(path.join(tmpdir, "from"));
+        const todir = yield (0, fileutil_1.ensureEmptyDir)(path.join(tmpdir, "to"));
+        const fromRegistry = options.fromRegistry
+            ? (0, registry_1.createRegistry)(options.fromRegistry, (_a = options.fromToken) !== null && _a !== void 0 ? _a : "")
+            : (0, registry_1.createDockerRegistry)(options.fromToken);
+        yield fromRegistry.download(options.fromImage, fromdir, (0, utils_1.getPreferredPlatform)(options.platform));
+        yield appLayerCreator_1.default.addLayers(tmpdir, fromdir, todir, options);
+        if (options.toTar) {
+            yield tarExporter_1.default.saveToTar(todir, tmpdir, options.toTar, [options.toImage], options);
+        }
+        if (options.toRegistry) {
+            const toRegistry = (0, registry_1.createRegistry)(options.toRegistry, (_b = options.toToken) !== null && _b !== void 0 ? _b : "");
+            yield toRegistry.upload(options.toImage, todir);
+        }
+        logger_1.default.debug("Deleting " + tmpdir + " ...");
+        yield fse.remove(tmpdir);
+        logger_1.default.debug("Done");
+    });
+}
+logger_1.default.debug("Running with config:", options);
+run(options)
+    .then(() => {
+    logger_1.default.info("Done!");
+    process.exit(0);
+})
+    .catch((error) => {
+    logger_1.default.error(error);
+    process.exit(1);
+});

package/lib/fileutil.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureEmptyDir = exports.sizeOf = void 0;
+const fs_1 = require("fs");
+const fse = require("fs-extra");
+const fss = require("fs");
+function sizeOf(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield fs_1.promises.lstat(file)).size;
+    });
+}
+exports.sizeOf = sizeOf;
+function ensureEmptyDir(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (fss.existsSync(path))
+            yield fse.remove(path);
+        yield fs_1.promises.mkdir(path);
+        return path;
+    });
+}
+exports.ensureEmptyDir = ensureEmptyDir;
+exports.default = {
+    sizeOf,
+    ensureEmptyDir,
+};

package/lib/logger.js

@@ -0,0 +1,31 @@
+"use strict";
+/* eslint-disable no-console */
+Object.defineProperty(exports, "__esModule", { value: true });
+let debugEnabled = false;
+function timeString() {
+    return new Date().toISOString();
+}
+function dolog(logger, parts) {
+    logger.apply(console, [timeString()].concat(parts));
+}
+function log(level, msg) {
+    if (level == "error")
+        return dolog(console.error, ["ERROR"].concat(msg));
+    if (level == "info")
+        return dolog(console.log, msg);
+    if (level == "debug" && debugEnabled)
+        return dolog(console.log, ["DEBUG"].concat(msg));
+}
+const logger = {
+    enableDebug: () => (debugEnabled = true),
+    info: function (...msg) {
+        log("info", msg);
+    },
+    error: function (...msg) {
+        log("error", msg);
+    },
+    debug: function (...msg) {
+        log("debug", msg);
+    },
+};
+exports.default = logger;

package/lib/registry.js

@@ -0,0 +1,335 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDockerRegistry = exports.createRegistry = void 0;
+const https = require("https");
+const http = require("http");
+const URL = require("url");
+const fs_1 = require("fs");
+const path = require("path");
+const fse = require("fs-extra");
+const fss = require("fs");
+const fileutil = require("./fileutil");
+const logger_1 = require("./logger");
+const MIMETypes_1 = require("./MIMETypes");
+const utils_1 = require("./utils");
+const redirectCodes = [307, 303, 302];
+function request(options, callback) {
+    return (options.protocol == "https:" ? https : http).request(options, (res) => {
+        callback(res);
+    });
+}
+function isOk(httpStatus) {
+    return httpStatus >= 200 && httpStatus < 300;
+}
+function getHash(digest) {
+    return digest.split(":")[1];
+}
+function parseImage(imageStr) {
+    const ar = imageStr.split(":");
+    const tag = ar[1] || "latest";
+    const ipath = ar[0];
+    return { path: ipath, tag: tag };
+}
+function toError(res) {
+    return `Unexpected HTTP status ${res.statusCode} : ${res.statusMessage}`;
+}
+function dl(uri, headers) {
+    logger_1.default.debug("dl", uri);
+    return new Promise((resolve, reject) => {
+        followRedirects(uri, headers, (result) => {
+            var _a;
+            if ("error" in result)
+                return reject(result.error);
+            const { res } = result;
+            logger_1.default.debug(res.statusCode, res.statusMessage, res.headers["content-type"], res.headers["content-length"]);
+            if (!isOk((_a = res.statusCode) !== null && _a !== void 0 ? _a : 0))
+                return reject(toError(res));
+            const data = [];
+            res
+                .on("data", (chunk) => data.push(chunk.toString()))
+                .on("end", () => {
+                resolve(data.reduce((a, b) => a.concat(b)));
+            });
+        });
+    });
+}
+function dlJson(uri, headers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const data = yield dl(uri, headers);
+        return JSON.parse(Buffer.from(data).toString("utf-8"));
+    });
+}
+function dlToFile(uri, file, headers) {
+    return new Promise((resolve, reject) => {
+        followRedirects(uri, headers, (result) => {
+            var _a;
+            if ("error" in result)
+                return reject(result.error);
+            const { res } = result;
+            logger_1.default.debug(res.statusCode, res.statusMessage, res.headers["content-type"], res.headers["content-length"]);
+            if (!isOk((_a = res.statusCode) !== null && _a !== void 0 ? _a : 0))
+                return reject(toError(res));
+            res.pipe(fss.createWriteStream(file)).on("finish", () => {
+                logger_1.default.debug("Done " + file + " - " + res.headers["content-length"] + " bytes ");
+                resolve();
+            });
+        });
+    });
+}
+function followRedirects(uri, headers, cb, count = 0) {
+    logger_1.default.debug("rc", uri);
+    const options = Object.assign({}, URL.parse(uri));
+    options.headers = headers;
+    options.method = "GET";
+    request(options, (res) => {
+        var _a;
+        if (redirectCodes.includes((_a = res.statusCode) !== null && _a !== void 0 ? _a : 0)) {
+            if (count > 10)
+                return cb({ error: "Too many redirects for " + uri });
+            const location = res.headers.location;
+            if (!location)
+                return cb({ error: "Redirect, but missing location header" });
+            return followRedirects(location, headers, cb, count + 1);
+        }
+        cb({ res });
+    }).end();
+}
+function buildHeaders(accept, auth) {
+    const headers = { accept: accept };
+    if (auth)
+        headers.authorization = auth;
+    return headers;
+}
+function headOk(url, headers) {
+    return new Promise((resolve, reject) => {
+        logger_1.default.debug(`HEAD ${url}`);
+        const options = URL.parse(url);
+        options.headers = headers;
+        options.method = "HEAD";
+        request(options, (res) => {
+            logger_1.default.debug(`HEAD ${url}`, res.statusCode);
+            if (res.statusCode == 404)
+                return resolve(false);
+            if (res.statusCode == 200)
+                return resolve(true);
+            reject(toError(res));
+        }).end();
+    });
+}
+function uploadContent(uploadUrl, file, fileConfig, auth) {
+    return new Promise((resolve, reject) => {
+        logger_1.default.debug("Uploading: ", file);
+        let url = uploadUrl;
+        if (fileConfig.digest)
+            url += (url.indexOf("?") == -1 ? "?" : "&") + "digest=" + fileConfig.digest;
+        const options = URL.parse(url);
+        options.method = "PUT";
+        options.headers = {
+            authorization: auth,
+            "content-length": fileConfig.size,
+            "content-type": fileConfig.mediaType,
+        };
+        logger_1.default.debug("POST", url);
+        const req = request(options, (res) => {
+            var _a;
+            logger_1.default.debug(res.statusCode, res.statusMessage, res.headers["content-type"], res.headers["content-length"]);
+            if ([200, 201, 202, 203].includes((_a = res.statusCode) !== null && _a !== void 0 ? _a : 0)) {
+                resolve();
+            }
+            else {
+                const data = [];
+                res.on("data", (d) => data.push(d.toString()));
+                res.on("end", () => {
+                    reject(`Error uploading to ${uploadUrl}. Got ${res.statusCode} ${res.statusMessage}:\n${data.join("")}`);
+                });
+            }
+        });
+        fss.createReadStream(file).pipe(req);
+    });
+}
+function createRegistry(registryBaseUrl, token) {
+    const auth = token.startsWith("Basic ") ? token : "Bearer " + token;
+    function exists(image, layer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${registryBaseUrl}${image.path}/blobs/${layer.digest}`;
+            return yield headOk(url, buildHeaders(layer.mediaType, auth));
+        });
+    }
+    function uploadLayerContent(uploadUrl, layer, dir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(layer.digest);
+            const file = path.join(dir, getHash(layer.digest) + (0, utils_1.getLayerTypeFileEnding)(layer));
+            yield uploadContent(uploadUrl, file, layer, auth);
+        });
+    }
+    function getUploadUrl(image) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const url = `${registryBaseUrl}${image.path}/blobs/uploads/`;
+                const options = URL.parse(url);
+                options.method = "POST";
+                options.headers = { authorization: auth };
+                request(options, (res) => {
+                    logger_1.default.debug("POST", `${url}`, res.statusCode);
+                    if (res.statusCode == 202) {
+                        const { location } = res.headers;
+                        if (location)
+                            resolve(location);
+                        reject("Missing location for 202");
+                    }
+                    else {
+                        const data = [];
+                        res
+                            .on("data", (c) => data.push(c.toString()))
+                            .on("end", () => {
+                            reject(`Error getting upload URL from ${url}. Got ${res.statusCode} ${res.statusMessage}:\n${data.join("")}`);
+                        });
+                    }
+                }).end();
+            });
+        });
+    }
+    function dlManifest(image, preferredPlatform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Accept both manifests and index/manifest lists
+            const res = yield dlJson(`${registryBaseUrl}${image.path}/manifests/${image.tag}`, buildHeaders(`${MIMETypes_1.OCI.index}, ${MIMETypes_1.OCI.manifest}, ${MIMETypes_1.DockerV2.index}, ${MIMETypes_1.DockerV2.manifest}`, auth));
+            // We've received an OCI Index or Docker Manifest List and need to find which manifest we want
+            if (res.mediaType === MIMETypes_1.OCI.index || res.mediaType === MIMETypes_1.DockerV2.index) {
+                const availableManifests = res.manifests;
+                const adequateManifest = pickManifest(availableManifests, preferredPlatform);
+                return dlManifest(Object.assign(Object.assign({}, image), { tag: adequateManifest.digest }), preferredPlatform);
+            }
+            return res;
+        });
+    }
+    function pickManifest(manifests, preferredPlatform) {
+        const matchingArchitectures = new Set();
+        const matchingOSes = new Set();
+        // Find sets of matching architecture and os
+        for (const manifest of manifests) {
+            if (manifest.platform.architecture === preferredPlatform.architecture) {
+                matchingArchitectures.add(manifest);
+            }
+            if (manifest.platform.os === preferredPlatform.os) {
+                matchingOSes.add(manifest);
+            }
+        }
+        // If the intersection of matching architectures and OS is one we've found our optimal match
+        const intersection = new Set([...matchingArchitectures].filter((x) => matchingOSes.has(x)));
+        if (intersection.size == 1) {
+            return intersection.values().next().value;
+        }
+        // If we don't have a perfect match we give a warning and try the first matching architecture
+        if (matchingArchitectures.size >= 1) {
+            const matchingArch = matchingArchitectures.values().next().value;
+            logger_1.default.info(`[WARN] Preferred OS '${preferredPlatform.os}' not available.`);
+            logger_1.default.info("[WARN] Using closest available manifest:", JSON.stringify(matchingArch.platform));
+            return matchingArch;
+        }
+        // If there's no image matching the wanted architecture we bail
+        logger_1.default.error(`No image matching requested architecture: '${preferredPlatform.architecture}'`);
+        logger_1.default.error("Available platforms:", JSON.stringify(manifests.map((m) => m.platform)));
+        throw new Error("No image matching requested architecture");
+    }
+    function dlConfig(image, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield dlJson(`${registryBaseUrl}${image.path}/blobs/${config.digest}`, buildHeaders("*/*", auth));
+        });
+    }
+    function dlLayer(image, layer, folder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(layer.digest);
+            const file = getHash(layer.digest) + (0, utils_1.getLayerTypeFileEnding)(layer);
+            yield dlToFile(`${registryBaseUrl}${image.path}/blobs/${layer.digest}`, path.join(folder, file), buildHeaders(layer.mediaType, auth));
+            return file;
+        });
+    }
+    function upload(imageStr, folder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const image = parseImage(imageStr);
+            const manifestFile = path.join(folder, "manifest.json");
+            const manifest = (yield fse.readJson(manifestFile));
+            logger_1.default.info("Checking layer status...");
+            const layerStatus = yield Promise.all(manifest.layers.map((l) => __awaiter(this, void 0, void 0, function* () {
+                return { layer: l, exists: yield exists(image, l) };
+            })));
+            const layersForUpload = layerStatus.filter((l) => !l.exists);
+            logger_1.default.debug("Needs upload:", layersForUpload.map((l) => l.layer.digest));
+            logger_1.default.info("Uploading layers...");
+            yield Promise.all(layersForUpload.map((l) => __awaiter(this, void 0, void 0, function* () {
+                const url = yield getUploadUrl(image);
+                yield uploadLayerContent(url, l.layer, folder);
+            })));
+            logger_1.default.info("Uploading config...");
+            const configUploadUrl = yield getUploadUrl(image);
+            const configFile = path.join(folder, getHash(manifest.config.digest) + ".json");
+            yield uploadContent(configUploadUrl, configFile, manifest.config, auth);
+            logger_1.default.info("Uploading manifest...");
+            const manifestSize = yield fileutil.sizeOf(manifestFile);
+            yield uploadContent(`${registryBaseUrl}${image.path}/manifests/${image.tag}`, manifestFile, { mediaType: manifest.mediaType, size: manifestSize }, auth);
+        });
+    }
+    function download(imageStr, folder, preferredPlatform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const image = parseImage(imageStr);
+            logger_1.default.info("Downloading manifest...");
+            const manifest = yield dlManifest(image, preferredPlatform);
+            yield fs_1.promises.writeFile(path.join(folder, "manifest.json"), JSON.stringify(manifest));
+            logger_1.default.info("Downloading config...");
+            const config = yield dlConfig(image, manifest.config);
+            if (config.architecture != preferredPlatform.architecture) {
+                logger_1.default.info(`[WARN] Image architecture (${config.architecture}) does not match preferred architecture (${preferredPlatform.architecture}).`);
+            }
+            if (config.os != preferredPlatform.os) {
+                logger_1.default.info(`[WARN] Image OS (${config.os}) does not match preferred OS (${preferredPlatform.os}).`);
+            }
+            yield fs_1.promises.writeFile(path.join(folder, "config.json"), JSON.stringify(config));
+            logger_1.default.info("Downloading layers...");
+            yield Promise.all(manifest.layers.map((layer) => dlLayer(image, layer, folder)));
+            logger_1.default.info("Image downloaded.");
+        });
+    }
+    return {
+        download: download,
+        upload: upload,
+    };
+}
+exports.createRegistry = createRegistry;
+function createDockerRegistry(auth) {
+    const registryBaseUrl = "https://registry-1.docker.io/v2/";
+    function getToken(image) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield dlJson(`https://auth.docker.io/token?service=registry.docker.io&scope=repository:${image.path}:pull`, {});
+            return resp.token;
+        });
+    }
+    function download(imageStr, folder, platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const image = parseImage(imageStr);
+            if (!auth)
+                auth = yield getToken(image);
+            yield createRegistry(registryBaseUrl, auth).download(imageStr, folder, platform);
+        });
+    }
+    function upload(imageStr, folder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!auth)
+                throw new Error("Need auth token to upload to Docker");
+            yield createRegistry(registryBaseUrl, auth).upload(imageStr, folder);
+        });
+    }
+    return {
+        download: download,
+        upload: upload,
+    };
+}
+exports.createDockerRegistry = createDockerRegistry;

package/lib/tarExporter.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tar = require("tar");
+const fs_1 = require("fs");
+const fse = require("fs-extra");
+const path = require("path");
+const logger_1 = require("./logger");
+const tarDefaultConfig = {
+    preservePaths: false,
+    portable: true,
+    follow: true,
+};
+function saveToTar(fromdir, tmpdir, toPath, repoTags, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.default.info("Creating " + toPath + " ...");
+        const targetFolder = path.dirname(toPath);
+        yield fs_1.promises.access(targetFolder).catch(() => __awaiter(this, void 0, void 0, function* () { return yield fs_1.promises.mkdir(targetFolder, { recursive: true }); }));
+        const manifestFile = path.join(fromdir, "manifest.json");
+        const manifest = (yield fse.readJson(manifestFile));
+        const configFile = path.join(fromdir, manifest.config.digest.split(":")[1] + ".json");
+        const config = yield fse.readJson(configFile);
+        const tardir = path.join(tmpdir, "totar");
+        yield fs_1.promises.mkdir(tardir);
+        const layers = yield Promise.all(manifest.layers
+            .map((x) => x.digest.split(":")[1])
+            .map((x) => __awaiter(this, void 0, void 0, function* () {
+            const fn = x + ((yield fse.pathExists(path.join(fromdir, x + ".tar.gz"))) ? ".tar.gz" : ".tar");
+            yield fse.copy(path.join(fromdir, fn), path.join(tardir, fn));
+            return fn;
+        })));
+        const simpleManifest = [
+            {
+                config: "config.json",
+                repoTags: repoTags,
+                layers: layers,
+            },
+        ];
+        yield fs_1.promises.writeFile(path.join(tardir, "manifest.json"), JSON.stringify(simpleManifest));
+        yield fs_1.promises.writeFile(path.join(tardir, "config.json"), JSON.stringify(config));
+        yield tar.c(Object.assign(Object.assign({}, tarDefaultConfig), Object.assign({ cwd: tardir, file: toPath, noMtime: !options.setTimeStamp }, (options.setTimeStamp ? { mtime: new Date(options.setTimeStamp) } : {}))), ["config.json", "manifest.json"].concat(layers));
+        logger_1.default.info("Finished " + toPath);
+    });
+}
+exports.default = {
+    saveToTar,
+};

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLayerTypeFileEnding = exports.getManifestLayerType = exports.getPreferredPlatform = exports.omit = exports.unique = void 0;
+const MIMETypes_1 = require("./MIMETypes");
+function unique(vals) {
+    return [...new Set(vals)];
+}
+exports.unique = unique;
+function omit(obj, keys) {
+    return Object.fromEntries(Object.entries(obj).filter(([k]) => !keys.includes(k)));
+}
+exports.omit = omit;
+function getPreferredPlatform(platform) {
+    var _a, _b;
+    // We assume the input is similar to docker which accepts `<os>/<arch>` and `<arch>`
+    let os = process.platform;
+    let arch = process.arch;
+    if (platform != undefined) {
+        const input = platform.split("/");
+        if (input.length == 1) {
+            arch = input[0];
+        }
+        else if (input.length == 2) {
+            os = input[0];
+            arch = input[1];
+        }
+        else {
+            throw new Error(`Invalid platform ${platform}. Should be on format <os>/<arch> or <arch>`);
+        }
+    }
+    // Mapping from Node's process.platform and Golang's `$GOOS` to Golang's `$GOOS`
+    // Incomplete, but cover the most common OS-types
+    // https://nodejs.org/api/process.html#processplatform
+    // https://go.dev/doc/install/source#environment
+    const OS_MAPPING = {
+        aix: "aix",
+        darwin: "darwin",
+        freebsd: "freebsd",
+        linux: "linux",
+        openbsd: "openbsd",
+        sunos: "solaris",
+        solaris: "solaris",
+        win32: "windows",
+        windows: "windows",
+    };
+    const targetOS = (_a = Object.entries(OS_MAPPING).find(([k]) => k == os)) === null || _a === void 0 ? void 0 : _a[1];
+    if (targetOS == undefined) {
+        throw new Error(`Platform ${os} not supported. Supported platforms are '${Object.keys(OS_MAPPING)}`);
+    }
+    // Mapping from Node's `process.arch` and Golang's `$GOARCH` to Golang's `$GOARCH` (incomplete)
+    // Incomplete, but cover the most common architectures
+    // https://nodejs.org/api/process.html#processarch
+    // https://go.dev/doc/install/source#environment
+    const ARCH_MAPPING = {
+        ia32: "386",
+        "386": "386",
+        x64: "amd64",
+        amd64: "amd64",
+        arm: "arm",
+        arm64: "arm64",
+    };
+    const targetArch = (_b = Object.entries(ARCH_MAPPING).find(([k]) => k == arch)) === null || _b === void 0 ? void 0 : _b[1];
+    if (targetArch == undefined) {
+        throw new Error(`Architecture ${arch} not supported. Supported architectures are '${Object.keys(ARCH_MAPPING)}'.`);
+    }
+    return {
+        os: targetOS,
+        architecture: targetArch,
+    };
+}
+exports.getPreferredPlatform = getPreferredPlatform;
+function getManifestLayerType(manifest) {
+    if (manifest.mediaType === MIMETypes_1.OCI.manifest) {
+        return MIMETypes_1.OCI.layer.gzip;
+    }
+    if (manifest.mediaType === MIMETypes_1.DockerV2.manifest) {
+        return MIMETypes_1.DockerV2.layer.gzip;
+    }
+    throw new Error(`${manifest.mediaType} not recognized.`);
+}
+exports.getManifestLayerType = getManifestLayerType;
+function getLayerTypeFileEnding(layer) {
+    switch (layer.mediaType) {
+        case MIMETypes_1.OCI.layer.gzip:
+        case MIMETypes_1.DockerV2.layer.gzip:
+            return ".tar.gz";
+        case MIMETypes_1.OCI.layer.tar:
+        case MIMETypes_1.DockerV2.layer.tar:
+            return ".tar";
+        default:
+            throw new Error(`Layer mediaType ${layer.mediaType} not known.`);
+    }
+}
+exports.getLayerTypeFileEnding = getLayerTypeFileEnding;

package/lib/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = "2.0.0";

package/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "containerify",
+	"version": "2.0.0",
+	"description": "Build node.js docker images without docker",
+	"main": "./lib/cli.js",
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1",
+		"prebuild": "node -p \"'export const VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/version.ts",
+		"build": "tsc && chmod ugo+x lib/cli.js",
+		"lint": "eslint . --ext .ts --fix --ignore-path .gitignore",
+		"typecheck": "tsc --noEmit",
+		"check": "npm run lint && npm run typecheck",
+		"dev": "tsc --watch",
+		"integrationTest": "cd tests/integration/ && ./test.sh",
+		"registryTest": "cd tests/localtest/ && ./test.sh"
+	},
+	"bin": {
+		"containerify": "./lib/cli.js"
+	},
+	"author": "Erlend Oftedal <erlend@oftedal.no>",
+	"license": "Apache-2.0",
+	"dependencies": {
+		"commander": "^10.0.0",
+		"fs-extra": "^11.1.0",
+		"tar": "^6.1.13"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/eoftedal/doqr.git"
+	},
+	"files": [
+		"lib/*.js",
+		"bin/*"
+	],
+	"keywords": [
+		"docker",
+		"container",
+		"image"
+	],
+	"devDependencies": {
+		"@types/fs-extra": "^11.0.1",
+		"@types/minizlib": "^2.1.4",
+		"@types/node": "^18.11.19",
+		"@types/tar": "^6.1.3",
+		"@typescript-eslint/eslint-plugin": "^5.51.0",
+		"@typescript-eslint/parser": "^5.51.0",
+		"eslint": "^8.33.0",
+		"eslint-config-prettier": "^8.6.0",
+		"prettier": "^2.8.3",
+		"typescript": "^4.9.5"
+	}
+}