@isomorph.ai/cli 0.2.0

package/dist/packages/harbour-cli/src/upload.js

@@ -0,0 +1,163 @@
+import { readFile, lstat } from "node:fs/promises";
+import { relative, resolve, sep } from "node:path";
+import { deflateRawSync } from "node:zlib";
+import { sha256Bytes } from "../../../src/digest.js";
+import { isProhibitedSecretPath } from "../../../src/secret-paths.js";
+export async function archiveForManifest(root, manifest) {
+    const rootAbsolute = resolve(root);
+    if ((await lstat(rootAbsolute)).isSymbolicLink())
+        throw new Error("Isomorph rejected an unsafe app boundary.");
+    const files = [];
+    const seen = new Set();
+    for (const entry of manifest.files) {
+        if (seen.has(entry.path) || isProhibitedSecretPath(entry.path) || entry.path.includes("\\") || entry.path.startsWith("/"))
+            throw new Error("Isomorph rejected an unsafe source path.");
+        seen.add(entry.path);
+        const absolute = resolve(rootAbsolute, entry.path);
+        if (!absolute.startsWith(rootAbsolute + sep))
+            throw new Error("Isomorph rejected a path outside the selected app.");
+        let current = rootAbsolute;
+        for (const component of entry.path.split("/")) {
+            current = resolve(current, component);
+            if ((await lstat(current)).isSymbolicLink())
+                throw new Error("Isomorph rejected an unsafe source path.");
+        }
+        const info = await lstat(absolute);
+        if (!info.isFile())
+            throw new Error("The app changed while it was being packaged.");
+        const content = new Uint8Array(await readFile(absolute));
+        if (content.byteLength !== entry.bytes || await sha256Bytes(content) !== entry.sha256)
+            throw new Error(`The app changed while it was being packaged (${entry.path}).`);
+        files.push({ path: relative(rootAbsolute, absolute).split(sep).join("/"), content });
+    }
+    const body = new Uint8Array(deterministicZip(files.sort((left, right) => left.path.localeCompare(right.path))));
+    return { body, digest: await sha256Bytes(body) };
+}
+function deterministicZip(files) {
+    const local = [];
+    const central = [];
+    let offset = 0;
+    for (const file of files) {
+        const name = Buffer.from(file.path, "utf8");
+        const raw = Buffer.from(file.content);
+        const compressed = deflateRawSync(raw, { level: 9 });
+        const crc = crc32(raw);
+        const header = Buffer.alloc(30);
+        header.writeUInt32LE(0x04034b50, 0);
+        header.writeUInt16LE(20, 4);
+        header.writeUInt16LE(0x0800, 6);
+        header.writeUInt16LE(8, 8);
+        header.writeUInt16LE(0, 10);
+        header.writeUInt16LE(0x21, 12);
+        header.writeUInt32LE(crc, 14);
+        header.writeUInt32LE(compressed.byteLength, 18);
+        header.writeUInt32LE(raw.byteLength, 22);
+        header.writeUInt16LE(name.byteLength, 26);
+        const directory = Buffer.alloc(46);
+        directory.writeUInt32LE(0x02014b50, 0);
+        directory.writeUInt16LE(0x0314, 4);
+        directory.writeUInt16LE(20, 6);
+        directory.writeUInt16LE(0x0800, 8);
+        directory.writeUInt16LE(8, 10);
+        directory.writeUInt16LE(0, 12);
+        directory.writeUInt16LE(0x21, 14);
+        directory.writeUInt32LE(crc, 16);
+        directory.writeUInt32LE(compressed.byteLength, 20);
+        directory.writeUInt32LE(raw.byteLength, 24);
+        directory.writeUInt16LE(name.byteLength, 28);
+        directory.writeUInt32LE((0o100644 << 16) >>> 0, 38);
+        directory.writeUInt32LE(offset, 42);
+        local.push(header, name, compressed);
+        central.push(directory, name);
+        offset += header.byteLength + name.byteLength + compressed.byteLength;
+    }
+    const centralBytes = central.reduce((sum, value) => sum + value.byteLength, 0);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(files.length, 8);
+    end.writeUInt16LE(files.length, 10);
+    end.writeUInt32LE(centralBytes, 12);
+    end.writeUInt32LE(offset, 16);
+    return Buffer.concat([...local, ...central, end]);
+}
+function crc32(bytes) {
+    let crc = 0xffffffff;
+    for (const byte of bytes) {
+        crc ^= byte;
+        for (let bit = 0; bit < 8; bit += 1)
+            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+export async function putMultipart(upload, body, progress) {
+    if (body.byteLength !== upload.compressedBytes)
+        throw new Error("The app package changed after the upload session was prepared.");
+    const completed = new Map((upload.acknowledgedParts ?? []).map(part => [part.partNumber, part.etag]));
+    let acknowledgedBytes = [...completed.keys()].reduce((sum, partNumber) => sum + Math.min(upload.partSizeBytes, body.byteLength - (partNumber - 1) * upload.partSizeBytes), 0);
+    progress?.(acknowledgedBytes, body.byteLength);
+    await mapConcurrent(upload.parts, 3, async (part) => {
+        const start = (part.partNumber - 1) * upload.partSizeBytes;
+        const bytes = body.subarray(start, Math.min(body.byteLength, start + upload.partSizeBytes));
+        if (part.url.startsWith("local://")) {
+            completed.set(part.partNumber, `local-${part.partNumber}`);
+            acknowledgedBytes += bytes.byteLength;
+            progress?.(Math.min(acknowledgedBytes, body.byteLength), body.byteLength);
+            return;
+        }
+        let response;
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            try {
+                response = await fetch(part.url, { method: "PUT", headers: part.requiredHeaders ?? {}, body: Buffer.from(bytes), redirect: "error" });
+                if (response.ok)
+                    break;
+                if (![408, 429, 500, 502, 503, 504].includes(response.status))
+                    throw new Error(`The app package part upload failed (${response.status}).`);
+            }
+            catch (error) {
+                if (attempt === 2)
+                    throw error;
+            }
+            await new Promise(resolve => setTimeout(resolve, 250 * 2 ** attempt));
+        }
+        if (!response?.ok)
+            throw new Error(`The app package part upload failed (${response?.status ?? "network"}).`);
+        const etag = response.headers.get("etag");
+        if (!etag)
+            throw new Error("The app package part upload did not return an ETag.");
+        completed.set(part.partNumber, etag);
+        acknowledgedBytes += bytes.byteLength;
+        progress?.(Math.min(acknowledgedBytes, body.byteLength), body.byteLength);
+    });
+    return [...completed].sort(([left], [right]) => left - right).map(([partNumber, etag]) => ({ partNumber, etag }));
+}
+async function mapConcurrent(items, concurrency, work) {
+    let cursor = 0;
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, async () => { while (cursor < items.length)
+        await work(items[cursor++]); }));
+}
+export async function putExact(upload, body) {
+    if (upload.url.startsWith("local://"))
+        return;
+    const headers = { ...(upload.requiredHeaders ?? {}), ...(upload.contentType ? { "content-type": upload.contentType } : {}) };
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            const response = await fetch(upload.url, { method: "PUT", headers, body: Buffer.from(body), redirect: "error" });
+            if (!response.ok) {
+                if (![408, 429, 500, 502, 503, 504].includes(response.status))
+                    throw new Error(`Isomorph source upload failed (${response.status}).`);
+                throw new Error(`Isomorph source upload failed (${response.status}).`);
+            }
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            const retryable = error instanceof Error && (!/\(\d{3}\)/.test(error.message) || /\((408|429|500|502|503|504)\)/.test(error.message));
+            if (attempt === 0 && retryable)
+                await new Promise(resolve => setTimeout(resolve, 250));
+            else
+                break;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Isomorph source upload failed.");
+}

package/dist/packages/harbour-cli/src/version.js

@@ -0,0 +1 @@
+export const CLI_VERSION = "0.2.0";