@ait-co/console-cli 0.1.15 → 0.1.16

package/dist/cli.mjs

@@ -1017,13 +1017,37 @@ var AitBundleError = class extends Error {
 		this.reason = args.reason;
 	}
 };
+const AIT_MAGIC = new Uint8Array([
+	65,
+	73,
+	84,
+	66,
+	85,
+	78,
+	68,
+	76
+]);
+const ZIP_MAGIC = new Uint8Array([
+	80,
+	75,
+	3,
+	4
+]);
+function startsWith(bytes, prefix) {
+	if (bytes.length < prefix.length) return false;
+	for (let i = 0; i < prefix.length; i++) if (bytes[i] !== prefix[i]) return false;
+	return true;
+}
+function detectBundleFormat(bytes) {
+	if (startsWith(bytes, AIT_MAGIC)) return "ait";
+	if (startsWith(bytes, ZIP_MAGIC)) return "zip";
+	return "unknown";
+}
 /**
-* Read the `.ait` at `path`, extract `app.json`, and pull out
-* `_metadata.deploymentId`. Returns both the id and the raw bytes so the
-* caller can forward them to the S3 upload without re-reading the file.
-*
-* Errors are all surfaced as `AitBundleError` with a structured `reason`
-* so the command layer can render a typed `--json` failure.
+* Read the `.ait` at `path` and pull out `deploymentId`, auto-detecting
+* whether the file is the modern AIT header format or a legacy plain
+* zip. Returns the raw bytes so the caller can forward them to S3
+* without re-reading the file.
 */
 async function readAitBundle(path) {
 	let buf;
@@ -1037,16 +1061,109 @@ async function readAitBundle(path) {
 		});
 	}
 	const bytes = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+	const { deploymentId, format } = deploymentIdFromBundleBytes(bytes, path);
 	return {
-		deploymentId: deploymentIdFromBundleBytes(bytes, path),
-		bytes
+		deploymentId,
+		bytes,
+		format
 	};
 }
 /**
-* Pure helper split out so tests can feed raw zip bytes without a tmp
-* file. Throws `AitBundleError` on any parse failure.
+* Pure helper split out so tests can feed raw bytes without a tmp file.
+* Throws `AitBundleError` on any parse failure. Returns the detected
+* format so callers that want to log it can.
 */
 function deploymentIdFromBundleBytes(bytes, pathForError) {
+	const format = detectBundleFormat(bytes);
+	if (format === "ait") return {
+		deploymentId: deploymentIdFromAitHeader(bytes, pathForError),
+		format
+	};
+	if (format === "zip") return {
+		deploymentId: deploymentIdFromLegacyZip(bytes, pathForError),
+		format
+	};
+	throw new AitBundleError({
+		path: pathForError,
+		reason: "unrecognized-format",
+		message: "bundle does not start with AITBUNDL or PK magic bytes — not a valid .ait or legacy zip bundle"
+	});
+}
+const AIT_MAGIC_SIZE = 8;
+const AIT_VERSION_SIZE = 4;
+const AIT_HEADER_SIZE = AIT_MAGIC_SIZE + AIT_VERSION_SIZE + 8;
+function deploymentIdFromAitHeader(bytes, pathForError) {
+	if (bytes.length < AIT_HEADER_SIZE) throw new AitBundleError({
+		path: pathForError,
+		reason: "invalid-ait",
+		message: "buffer too small to be a valid AIT file"
+	});
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const bundleLen = Number(view.getBigUint64(AIT_MAGIC_SIZE + AIT_VERSION_SIZE, false));
+	if (!Number.isFinite(bundleLen) || bundleLen <= 0) throw new AitBundleError({
+		path: pathForError,
+		reason: "invalid-ait",
+		message: `AIT bundle length is invalid (${bundleLen})`
+	});
+	const bundleStart = AIT_HEADER_SIZE;
+	const bundleEnd = bundleStart + bundleLen;
+	if (bytes.length < bundleEnd) throw new AitBundleError({
+		path: pathForError,
+		reason: "invalid-ait",
+		message: "unexpected end of buffer reading AIT bundle protobuf"
+	});
+	const deploymentId = readProtobufStringFields(bytes.subarray(bundleStart, bundleEnd), [2, 3]).get(2);
+	if (typeof deploymentId !== "string" || deploymentId === "") throw new AitBundleError({
+		path: pathForError,
+		reason: "missing-deployment-id",
+		message: "AIT bundle protobuf is missing deploymentId (field 2)"
+	});
+	return deploymentId;
+}
+function readProtobufStringFields(bytes, wantedFieldNumbers) {
+	const wanted = new Set(wantedFieldNumbers);
+	const out = /* @__PURE__ */ new Map();
+	const decoder = new TextDecoder("utf-8", { fatal: false });
+	let offset = 0;
+	while (offset < bytes.length) {
+		const { value: tag, next } = readVarint(bytes, offset);
+		offset = next;
+		const fieldNumber = Number(tag >> 3n);
+		const wireType = Number(tag & 7n);
+		if (wireType === 0) offset = readVarint(bytes, offset).next;
+		else if (wireType === 1) offset += 8;
+		else if (wireType === 2) {
+			const { value: len, next: afterLen } = readVarint(bytes, offset);
+			offset = afterLen;
+			const payloadEnd = offset + Number(len);
+			if (payloadEnd > bytes.length) break;
+			if (wanted.has(fieldNumber)) out.set(fieldNumber, decoder.decode(bytes.subarray(offset, payloadEnd)));
+			offset = payloadEnd;
+		} else if (wireType === 5) offset += 4;
+		else break;
+	}
+	return out;
+}
+function readVarint(bytes, start) {
+	let value = 0n;
+	let shift = 0n;
+	let i = start;
+	for (let n = 0; n < 10 && i < bytes.length; n++, i++) {
+		const byte = bytes[i];
+		if (byte === void 0) break;
+		value |= BigInt(byte & 127) << shift;
+		if ((byte & 128) === 0) return {
+			value,
+			next: i + 1
+		};
+		shift += 7n;
+	}
+	return {
+		value,
+		next: i
+	};
+}
+function deploymentIdFromLegacyZip(bytes, pathForError) {
 	let entries;
 	try {
 		entries = unzipSync(bytes, { filter: (file) => file.name === "app.json" });
@@ -1195,6 +1312,7 @@ async function runDeploy(args, deps = {}) {
 			workspaceId,
 			appId,
 			deploymentId,
+			bundleFormat: bundleInfo.format,
 			bytes: bundleInfo.bytes.byteLength,
 			steps,
 			memo: memo ?? null,
@@ -1279,6 +1397,7 @@ async function runDeploy(args, deps = {}) {
 			workspaceId,
 			appId,
 			deploymentId,
+			bundleFormat: bundleInfo.format,
 			uploaded,
 			reviewed,
 			released: release,
@@ -5410,7 +5529,7 @@ function resolveVersion() {
 		if (typeof injected === "string" && injected.length > 0) return injected;
 	} catch {}
 	try {
-		return "0.1.15";
+		return "0.1.16";
 	} catch {}
 	return "0.0.0-dev";
 }