@netlify/zip-it-and-ship-it 15.3.4 → 15.4.0

package/dist/feature_flags.d.ts

@@ -7,6 +7,7 @@ export declare const defaultFlags: {
     readonly zisi_esbuild_fail_double_glob: false;
     readonly zisi_add_instrumentation_loader: true;
     readonly zisi_netlify_play: false;
+    readonly zisi_container_functions: false;
 };
 export type FeatureFlags = Partial<Record<keyof typeof defaultFlags, boolean>>;
 export declare const getFlags: (input?: Record<string, boolean>, flags?: {
@@ -18,4 +19,5 @@ export declare const getFlags: (input?: Record<string, boolean>, flags?: {
     readonly zisi_esbuild_fail_double_glob: false;
     readonly zisi_add_instrumentation_loader: true;
     readonly zisi_netlify_play: false;
+    readonly zisi_container_functions: false;
 }) => FeatureFlags;

package/dist/feature_flags.js

@@ -17,6 +17,7 @@ export const defaultFlags = {
     // Adds the `___netlify-telemetry.mjs` file to the function bundle.
     zisi_add_instrumentation_loader: true,
     zisi_netlify_play: false,
+    zisi_container_functions: false,
 };
 // List of supported flags and their default value.
 export const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({

package/dist/runtimes/container/archive.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Reports whether the file at `path` is a container image archive, in either
+ * the OCI or the Docker flavor.
+ *
+ * The check reads tar headers rather than trusting the extension, since a
+ * `.tar` in a functions directory could be anything. Only header blocks are
+ * read, never entry contents, so the cost does not scale with image size.
+ */
+export declare const isImageArchive: (path: string) => Promise<boolean>;

package/dist/runtimes/container/archive.js

@@ -0,0 +1,100 @@
+import { open } from 'fs/promises';
+// A tar header block is 512 bytes, and file contents are padded to the same
+// boundary.
+const BLOCK_SIZE = 512;
+// The entry name occupies the first 100 bytes of a header.
+const NAME_LENGTH = 100;
+// The entry size is a 12-byte octal string starting at offset 124.
+const SIZE_OFFSET = 124;
+const SIZE_LENGTH = 12;
+// The header checksum is an 8-byte octal string starting at offset 148.
+const CHECKSUM_OFFSET = 148;
+const CHECKSUM_LENGTH = 8;
+// How many entries to inspect before giving up.
+const MAX_ENTRIES = 4096;
+// An OCI archive is a tar of an OCI layout. Always carries this marker file.
+const OCI_LAYOUT_MARKER = 'oci-layout';
+// A Docker archive declares its images in a root manifest.
+const DOCKER_MANIFEST_MARKER = 'manifest.json';
+/**
+ * Reports whether the file at `path` is a container image archive, in either
+ * the OCI or the Docker flavor.
+ *
+ * The check reads tar headers rather than trusting the extension, since a
+ * `.tar` in a functions directory could be anything. Only header blocks are
+ * read, never entry contents, so the cost does not scale with image size.
+ */
+export const isImageArchive = async (path) => {
+    let handle;
+    try {
+        handle = await open(path, 'r');
+        const header = Buffer.alloc(BLOCK_SIZE);
+        let offset = 0;
+        for (let entry = 0; entry < MAX_ENTRIES; entry++) {
+            const { bytesRead } = await handle.read(header, 0, BLOCK_SIZE, offset);
+            if (bytesRead < BLOCK_SIZE) {
+                return false;
+            }
+            const name = readName(header);
+            // Two consecutive empty blocks terminate a tar archive; a single empty
+            // name means we have run out of entries to look at.
+            if (name === '') {
+                return false;
+            }
+            // A tar header checksums its own bytes, so a file whose leading bytes
+            // merely imitate a marker name fails here.
+            if (!hasValidChecksum(header)) {
+                return false;
+            }
+            if (name === OCI_LAYOUT_MARKER || name === DOCKER_MANIFEST_MARKER) {
+                return true;
+            }
+            const size = readSize(header);
+            if (size === undefined) {
+                return false;
+            }
+            // Skip the header and the entry's contents, rounded up to a block.
+            offset += BLOCK_SIZE + Math.ceil(size / BLOCK_SIZE) * BLOCK_SIZE;
+        }
+        return false;
+    }
+    catch {
+        // Unreadable, a directory, or not a tar at all: not an image archive.
+        return false;
+    }
+    finally {
+        await handle?.close();
+    }
+};
+const readName = (header) => {
+    const raw = header.subarray(0, NAME_LENGTH);
+    const end = raw.indexOf(0);
+    return raw.subarray(0, end === -1 ? NAME_LENGTH : end).toString('utf8');
+};
+// The checksum field holds the sum of all header bytes with the field itself
+// read as spaces.
+const hasValidChecksum = (header) => {
+    const raw = header.subarray(CHECKSUM_OFFSET, CHECKSUM_OFFSET + CHECKSUM_LENGTH).toString('utf8');
+    const expected = parseInt(raw.replace(/\0/g, '').trim(), 8);
+    if (Number.isNaN(expected)) {
+        return false;
+    }
+    let unsigned = 0;
+    let signed = 0;
+    for (let index = 0; index < BLOCK_SIZE; index++) {
+        const inChecksumField = index >= CHECKSUM_OFFSET && index < CHECKSUM_OFFSET + CHECKSUM_LENGTH;
+        const byte = inChecksumField ? 0x20 : header[index];
+        unsigned += byte;
+        signed += byte < 0x80 ? byte : byte - 0x100;
+    }
+    return expected === unsigned || expected === signed;
+};
+const readSize = (header) => {
+    const raw = header.subarray(SIZE_OFFSET, SIZE_OFFSET + SIZE_LENGTH).toString('utf8');
+    const octal = raw.replace(/\0/g, '').trim();
+    if (octal === '') {
+        return 0;
+    }
+    const size = parseInt(octal, 8);
+    return Number.isNaN(size) || size < 0 ? undefined : size;
+};

package/dist/runtimes/container/index.d.ts

@@ -0,0 +1,3 @@
+import { Runtime } from '../runtime.js';
+declare const runtime: Runtime;
+export default runtime;

package/dist/runtimes/container/index.js

@@ -0,0 +1,57 @@
+import { basename, dirname, extname } from 'path';
+import { copyFile } from 'copy-file';
+import { cachedLstat } from '../../utils/fs.js';
+import getInternalValue from '../../utils/get_internal_value.js';
+import { nonNullable } from '../../utils/non_nullable.js';
+import { RUNTIME } from '../runtime.js';
+import { isImageArchive } from './archive.js';
+// The extension a container image archive is expected to carry. Restricting by
+// extension first keeps us from reading every file in the functions directory.
+const ARCHIVE_EXTENSION = '.tar';
+const findFunctionsInPaths = async function ({ cache, featureFlags, paths }) {
+    const functions = await Promise.all(paths.map((path) => findFunctionInPath({ cache, featureFlags, path })));
+    return functions.filter(nonNullable);
+};
+const findFunctionInPath = async function ({ cache, featureFlags, path }) {
+    if (!featureFlags.zisi_container_functions) {
+        return;
+    }
+    if (extname(path) !== ARCHIVE_EXTENSION) {
+        return;
+    }
+    const stat = await cachedLstat(cache.lstatCache, path);
+    if (stat.isDirectory()) {
+        return;
+    }
+    if (!(await isImageArchive(path))) {
+        return;
+    }
+    return processArchive({ cache, path });
+};
+const processArchive = async ({ cache, path }) => {
+    const stat = await cachedLstat(cache.lstatCache, path);
+    return {
+        extension: ARCHIVE_EXTENSION,
+        filename: basename(path),
+        mainFile: path,
+        name: basename(path, ARCHIVE_EXTENSION),
+        srcDir: dirname(path),
+        srcPath: path,
+        stat,
+    };
+};
+const zipFunction = async function ({ config, destFolder, filename, srcPath, isInternal }) {
+    const destPath = `${destFolder}/${filename}`;
+    await copyFile(srcPath, destPath);
+    return {
+        config,
+        displayName: config.name,
+        generator: config.generator ?? getInternalValue(isInternal),
+        path: destPath,
+        // A container starts from the entrypoint recorded in its own image config.
+        // There is no entry file for the platform to call into.
+        entryFilename: '',
+    };
+};
+const runtime = { findFunctionsInPaths, findFunctionInPath, name: RUNTIME.CONTAINER, zipFunction };
+export default runtime;

package/dist/runtimes/index.js

@@ -2,6 +2,7 @@ import { extname, basename } from 'path';
 import { getConfigForFunction } from '../config.js';
 import { defaultFlags } from '../feature_flags.js';
 import { FunctionBundlingUserError } from '../utils/error.js';
+import containerRuntime from './container/index.js';
 import goRuntime from './go/index.js';
 import jsRuntime from './node/index.js';
 import { ENTRY_FILE_NAME } from './node/utils/entry_file.js';
@@ -43,7 +44,7 @@ const findFunctionsInRuntime = async function ({ cache, dedupe = false, featureF
 // The order of this array determines the priority of the runtimes. If a path
 // is used by the first time, it won't be made available to the subsequent
 // runtimes.
-const RUNTIMES = [jsRuntime, goRuntime, rustRuntime];
+const RUNTIMES = [containerRuntime, jsRuntime, goRuntime, rustRuntime];
 /**
  * Gets a list of functions found in a list of paths.
  */

package/dist/runtimes/runtime.d.ts

@@ -11,6 +11,7 @@ import { Logger } from '../utils/logger.js';
 import type { BundlerReason, NodeBundlerName } from './node/bundlers/types.js';
 import type { StaticAnalysisResult } from './node/in_source_config/index.js';
 export declare const RUNTIME: {
+    readonly CONTAINER: "container";
     readonly GO: "go";
     readonly JAVASCRIPT: "js";
     readonly RUST: "rs";

package/dist/runtimes/runtime.js

@@ -1,4 +1,5 @@
 export const RUNTIME = {
+    CONTAINER: 'container',
     GO: 'go',
     JAVASCRIPT: 'js',
     RUST: 'rs',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "15.3.4",
+  "version": "15.4.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -100,5 +100,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "584d4952868504a07a5741b8c37fbef6b10b61b2"
+  "gitHead": "aaee524cfed2fc082e6cb7268ce7230071b39068"
 }