makefx 0.2.4 → 0.2.6

package/README.md

@@ -176,4 +176,4 @@ Run `makefx --help` or `makefx help <command>` for command-specific options.
 - Media generation guide: https://makefx.app/docs/media-playbooks
 - Source: https://github.com/krasnoperov/inventory
 
-Version: 0.2.4
+Version: 0.2.6

package/makefx.mjs

@@ -4,9 +4,10 @@ import process$1 from "node:process";
 import { createHash, randomBytes } from "node:crypto";
 import http from "node:http";
 import { spawn } from "node:child_process";
-import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { createReadStream } from "node:fs";
 import https from "node:https";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -5160,6 +5161,167 @@ function resolveMediaType(ext, requestedMediaKind) {
 	return mediaType;
 }
 //#endregion
+//#region src/shared/websocket-types.ts
+var DEFAULT_MEDIA_KIND = "image";
+//#endregion
+//#region src/cli/lib/mirror-store.ts
+var MIRROR_REGISTRY_VERSION = 1;
+var MIRROR_REGISTRY_FILE = "mirrors.json";
+function getMirrorRegistryPath(projectRoot = process.cwd()) {
+	return path.join(projectRoot, ".inventory", MIRROR_REGISTRY_FILE);
+}
+async function readMirrorRegistry(projectRoot = process.cwd()) {
+	const registryPath = getMirrorRegistryPath(projectRoot);
+	let raw;
+	try {
+		raw = await readFile(registryPath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return emptyRegistry();
+		throw error;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error(`Mirror registry is not valid JSON: ${registryPath}. Move it aside or delete it so the CLI can recreate it.`);
+	}
+	if (!isMirrorRegistry(parsed)) throw new Error(`Mirror registry has an unsupported format: ${registryPath}`);
+	return parsed;
+}
+async function writeMirrorRegistry(registry, projectRoot = process.cwd()) {
+	const registryPath = getMirrorRegistryPath(projectRoot);
+	await mkdir(path.dirname(registryPath), { recursive: true });
+	const tempPath = `${registryPath}.${process.pid}.${Date.now()}.tmp`;
+	await writeFile(tempPath, `${JSON.stringify(registry, null, 2)}\n`, "utf8");
+	await rename(tempPath, registryPath);
+	return registryPath;
+}
+async function fingerprintFile(filePath) {
+	const fileStat = await stat(filePath);
+	if (!fileStat.isFile()) throw new Error(`Mirror source is not a file: ${filePath}`);
+	const hash = createHash("sha256");
+	await new Promise((resolve, reject) => {
+		const stream = createReadStream(filePath);
+		stream.on("data", (chunk) => hash.update(chunk));
+		stream.on("error", reject);
+		stream.on("end", resolve);
+	});
+	return {
+		sha256: hash.digest("hex"),
+		sizeBytes: fileStat.size
+	};
+}
+async function resolveMirrorForFile(input) {
+	const projectRoot = input.projectRoot ?? process.cwd();
+	const registry = await readMirrorRegistry(projectRoot);
+	const fingerprint = await fingerprintFile(input.filePath);
+	const pathAlias = toMirrorPathAlias(input.filePath, projectRoot);
+	const mediaKind = input.mediaKind ?? "image";
+	return {
+		fingerprint,
+		digestEntry: findMirrorByDigest(registry, {
+			...input,
+			mediaKind,
+			...fingerprint
+		}),
+		pathEntry: findMirrorByPath(registry, {
+			...input,
+			mediaKind,
+			pathAlias
+		}),
+		pathAlias
+	};
+}
+async function recordMirrorForFile(input) {
+	const projectRoot = input.projectRoot ?? process.cwd();
+	const registry = await readMirrorRegistry(projectRoot);
+	const fingerprint = await fingerprintFile(input.filePath);
+	const pathAlias = toMirrorPathAlias(input.filePath, projectRoot);
+	const mediaKind = input.mediaKind ?? "image";
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	movePathAliasToCurrentMirror(registry, {
+		...input,
+		mediaKind,
+		pathAlias
+	});
+	const existing = findMirrorByDigest(registry, {
+		...input,
+		mediaKind,
+		...fingerprint
+	});
+	const entry = {
+		version: MIRROR_REGISTRY_VERSION,
+		baseUrl: input.baseUrl,
+		...input.environment ? { environment: input.environment } : {},
+		spaceId: input.spaceId,
+		sha256: fingerprint.sha256,
+		sizeBytes: fingerprint.sizeBytes,
+		paths: mergePathAliases(existing?.paths ?? [], pathAlias),
+		assetId: input.assetId,
+		variantId: input.variantId,
+		mediaKind,
+		mediaKey: input.mediaKey ?? null,
+		updatedAt: now
+	};
+	if (existing) {
+		const index = registry.entries.indexOf(existing);
+		registry.entries[index] = entry;
+	} else registry.entries.push(entry);
+	await writeMirrorRegistry(registry, projectRoot);
+	return entry;
+}
+function describeMirrorMismatch(filePath, entry) {
+	return [
+		`Local reference changed since it was mirrored: ${filePath}`,
+		`Previously mirrored to variant ${entry.variantId} in space ${entry.spaceId}.`,
+		"Use the existing variant ID explicitly, restore the original file, or upload/register a new reference intentionally."
+	].join(" ");
+}
+function findMirrorByDigest(registry, input) {
+	return registry.entries.find((entry) => entry.baseUrl === input.baseUrl && entry.spaceId === input.spaceId && entry.sha256 === input.sha256 && entry.sizeBytes === input.sizeBytes && entry.mediaKind === input.mediaKind && environmentMatches(entry.environment, input.environment));
+}
+function findMirrorByPath(registry, input) {
+	return registry.entries.find((entry) => entry.baseUrl === input.baseUrl && entry.spaceId === input.spaceId && entry.paths.includes(input.pathAlias) && entry.mediaKind === input.mediaKind && environmentMatches(entry.environment, input.environment));
+}
+function environmentMatches(entryEnvironment, inputEnvironment) {
+	return (entryEnvironment ?? "") === (inputEnvironment ?? "");
+}
+function movePathAliasToCurrentMirror(registry, input) {
+	for (const entry of registry.entries) {
+		if (entry.baseUrl !== input.baseUrl || entry.spaceId !== input.spaceId || entry.mediaKind !== input.mediaKind || !environmentMatches(entry.environment, input.environment)) continue;
+		entry.paths = entry.paths.filter((pathAlias) => pathAlias !== input.pathAlias);
+	}
+}
+function toMirrorPathAlias(filePath, projectRoot) {
+	const absolutePath = path.resolve(filePath);
+	const relativePath = path.relative(projectRoot, absolutePath);
+	if (relativePath && !relativePath.startsWith("..") && !path.isAbsolute(relativePath)) return normalizePath(relativePath);
+	return normalizePath(absolutePath);
+}
+function normalizePath(value) {
+	return value.split(path.sep).join("/");
+}
+function mergePathAliases(paths, pathAlias) {
+	return Array.from(new Set([...paths, pathAlias])).sort();
+}
+function emptyRegistry() {
+	return {
+		version: MIRROR_REGISTRY_VERSION,
+		entries: []
+	};
+}
+function isMirrorRegistry(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const registry = value;
+	if (registry.version !== MIRROR_REGISTRY_VERSION || !Array.isArray(registry.entries)) return false;
+	return registry.entries.every(isMirrorEntry);
+}
+function isMirrorEntry(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const entry = value;
+	return entry.version === MIRROR_REGISTRY_VERSION && typeof entry.baseUrl === "string" && (entry.environment === void 0 || typeof entry.environment === "string") && typeof entry.spaceId === "string" && typeof entry.sha256 === "string" && typeof entry.sizeBytes === "number" && Array.isArray(entry.paths) && entry.paths.every((item) => typeof item === "string") && typeof entry.assetId === "string" && typeof entry.variantId === "string" && typeof entry.mediaKind === "string" && (entry.mediaKey === void 0 || entry.mediaKey === null || typeof entry.mediaKey === "string") && typeof entry.updatedAt === "string";
+}
+//#endregion
 //#region src/cli/commands/upload.ts
 /**
 * Upload Command - Upload one media file to create variants
@@ -5176,6 +5338,7 @@ var defaultDeps$12 = {
 	fetch,
 	readFile,
 	stat,
+	recordMirrorForFile,
 	print: console.log
 };
 var UploadUsageError = class extends Error {};
@@ -5318,6 +5481,18 @@ async function executeUpload(parsed, deps = defaultDeps$12) {
 			lineage: upload.lineage,
 			organization
 		};
+		await recordUploadMirror({
+			deps,
+			projectRoot: projectConfig?.projectRoot,
+			env,
+			baseUrl,
+			spaceId,
+			filePath,
+			assetId: upload.asset?.id ?? upload.variant.asset_id,
+			variantId: upload.variant.id,
+			mediaKind: upload.variant.media_kind || mediaType.mediaKind,
+			mediaKey: upload.variant.media_key || upload.variant.image_key
+		});
 		if (jsonOutput) {
 			deps.print(JSON.stringify(result, null, 2));
 			return result;
@@ -5359,6 +5534,24 @@ async function executeUpload(parsed, deps = defaultDeps$12) {
 		throw error;
 	}
 }
+async function recordUploadMirror(input) {
+	if (!input.deps.recordMirrorForFile) return;
+	try {
+		await input.deps.recordMirrorForFile({
+			projectRoot: input.projectRoot,
+			baseUrl: input.baseUrl,
+			environment: input.env,
+			spaceId: input.spaceId,
+			filePath: input.filePath,
+			assetId: input.assetId,
+			variantId: input.variantId,
+			mediaKind: input.mediaKind,
+			mediaKey: input.mediaKey
+		});
+	} catch (error) {
+		console.warn(`Warning: upload succeeded but mirror registry was not updated: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
 function parseJsonObjectOption(value, optionName) {
 	if (value === void 0) return void 0;
 	let parsed;
@@ -5631,9 +5824,6 @@ Examples:
 `);
 }
 //#endregion
-//#region src/shared/websocket-types.ts
-var DEFAULT_MEDIA_KIND = "image";
-//#endregion
 //#region src/cli/lib/image-transfer.ts
 var MAX_FILE_SIZE_MB = 10;
 var MAX_FILE_SIZE_BYTES = MAX_FILE_SIZE_MB * 1024 * 1024;
@@ -21455,6 +21645,19 @@ var VIDEO_GENERATION_REQUEST_TIMEOUT_MS = 72e4;
 function getGenerationRequestTimeoutMs(mediaKind) {
 	return mediaKind === "video" ? VIDEO_GENERATION_REQUEST_TIMEOUT_MS : GENERATION_REQUEST_TIMEOUT_MS;
 }
+/**
+* Thrown when a mutation's confirmation broadcast does not arrive within the
+* timeout. The server write may still have landed — callers can re-read state
+* to confirm. Distinct from server-rejection errors (PERMISSION_DENIED,
+* VALIDATION_ERROR, …), which reject with their own message and must not be
+* treated as a missing confirmation.
+*/
+var ServerConfirmationTimeoutError = class extends Error {
+	constructor(message = "Timed out waiting for server confirmation") {
+		super(message);
+		this.name = "ServerConfirmationTimeoutError";
+	}
+};
 var WebSocketClient = class WebSocketClient {
 	ws = null;
 	baseUrl;
@@ -22031,7 +22234,7 @@ var WebSocketClient = class WebSocketClient {
 				reject,
 				timeout: setTimeout(() => {
 					this.removeWaiter(waiter);
-					reject(/* @__PURE__ */ new Error("Timed out waiting for server confirmation"));
+					reject(new ServerConfirmationTimeoutError());
 				}, timeoutMs)
 			};
 			this.mutationWaiters.push(waiter);
@@ -22885,6 +23088,8 @@ var defaultDeps$10 = {
 	resolveBaseUrl,
 	createClient: WebSocketClient.create,
 	uploadLocalReference: uploadLocalImageAsReference,
+	resolveMirrorForFile,
+	recordMirrorForFile,
 	downloadImage,
 	downloadFile,
 	saveRunManifest,
@@ -23602,12 +23807,41 @@ async function resolveReferenceVariantIds(refs, ctx, deps, variants = [], mediaK
 	const variantIds = [];
 	for (const ref of refs) {
 		if (await deps.fileExists(ref)) {
+			const localReferenceMediaKind = mediaKind === "video" ? CLI_GENERATION_MEDIA_KIND : mediaKind;
+			const mirror = deps.resolveMirrorForFile ? await deps.resolveMirrorForFile({
+				projectRoot: ctx.projectRoot,
+				baseUrl: ctx.baseUrl,
+				environment: ctx.env,
+				spaceId: ctx.spaceId,
+				filePath: ref,
+				mediaKind: localReferenceMediaKind
+			}) : void 0;
+			if (mirror?.pathEntry && (mirror.pathEntry.sha256 !== mirror.fingerprint.sha256 || mirror.pathEntry.sizeBytes !== mirror.fingerprint.sizeBytes)) throw new Error(describeMirrorMismatch(ref, mirror.pathEntry));
+			if (mirror?.digestEntry) {
+				validateReferenceVariant(mirror.digestEntry.variantId, variants, mediaKind);
+				await recordReusedReferenceMirror({
+					ref,
+					ctx,
+					deps,
+					entry: mirror.digestEntry
+				});
+				variantIds.push(mirror.digestEntry.variantId);
+				continue;
+			}
+			if (mirror?.pathEntry) throw new Error(describeMirrorMismatch(ref, mirror.pathEntry));
 			const uploaded = await deps.uploadLocalReference({
 				baseUrl: ctx.baseUrl,
 				accessToken: ctx.accessToken,
 				spaceId: ctx.spaceId,
 				filePath: ref
 			});
+			if (deps.recordMirrorForFile) await recordUploadedReferenceMirror({
+				ref,
+				ctx,
+				deps,
+				uploaded,
+				mediaKind: localReferenceMediaKind
+			});
 			variantIds.push(uploaded.variant.id);
 			continue;
 		}
@@ -23617,6 +23851,40 @@ async function resolveReferenceVariantIds(refs, ctx, deps, variants = [], mediaK
 	}
 	return variantIds;
 }
+async function recordReusedReferenceMirror(input) {
+	try {
+		await input.deps.recordMirrorForFile?.({
+			projectRoot: input.ctx.projectRoot,
+			baseUrl: input.ctx.baseUrl,
+			environment: input.ctx.env,
+			spaceId: input.ctx.spaceId,
+			filePath: input.ref,
+			assetId: input.entry.assetId,
+			variantId: input.entry.variantId,
+			mediaKind: input.entry.mediaKind,
+			mediaKey: input.entry.mediaKey
+		});
+	} catch (error) {
+		console.warn(`Warning: reused mirrored reference but mirror registry alias was not updated: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+async function recordUploadedReferenceMirror(input) {
+	try {
+		await input.deps.recordMirrorForFile?.({
+			projectRoot: input.ctx.projectRoot,
+			baseUrl: input.ctx.baseUrl,
+			environment: input.ctx.env,
+			spaceId: input.ctx.spaceId,
+			filePath: input.ref,
+			assetId: input.uploaded.asset?.id ?? input.uploaded.variant.asset_id,
+			variantId: input.uploaded.variant.id,
+			mediaKind: input.uploaded.variant.media_kind ?? input.mediaKind,
+			mediaKey: input.uploaded.variant.media_key ?? input.uploaded.variant.image_key
+		});
+	} catch (error) {
+		console.warn(`Warning: reference upload succeeded but mirror registry was not updated: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
 function validateReferenceVariant(ref, variants, mediaKind) {
 	const variant = variants.find((candidate) => candidate.id === ref);
 	if (!variant) throw new Error(`Reference variant not found in space sync state: ${ref}`);
@@ -24387,6 +24655,7 @@ var defaultDeps$6 = {
 	resolveBaseUrl,
 	fetch,
 	downloadFile,
+	recordMirrorForFile,
 	createMutationClient: (env, spaceId) => WebSocketClient.create(env, spaceId),
 	print: console.log
 };
@@ -24443,6 +24712,12 @@ async function executeAssets(parsed, deps = defaultDeps$6) {
 			outputPath,
 			force: ctx.force
 		});
+		await recordDownloadedMirror({
+			ctx,
+			deps,
+			outputPath,
+			variant: resolved.variant
+		});
 		deps.print(`Downloaded ${resolved.mediaKey} to ${outputPath}`);
 		return {
 			type: "download",
@@ -24476,7 +24751,7 @@ async function executeAssets(parsed, deps = defaultDeps$6) {
 		const assetId = parsed.positionals[1];
 		const variantId = parsed.positionals[2] || normalizeOption(parsed.options.variant);
 		if (!assetId || !variantId) throw new Error("Usage: makefx assets set-active <asset-id> <variant-id>");
-		const asset = await withAssetClient(ctx, deps, (client) => client.setActiveVariant(assetId, variantId));
+		const asset = await setActiveVariant(ctx, deps, assetId, variantId);
 		deps.print(`Set active variant of asset ${assetId} to ${asset.active_variant_id}`);
 		return {
 			type: "set-active",
@@ -24502,15 +24777,45 @@ async function buildContext$6(parsed, deps) {
 		spaceId,
 		baseUrl: deps.resolveBaseUrl(env),
 		accessToken: config.token.accessToken,
-		force: parsed.options.force === "true"
+		force: parsed.options.force === "true",
+		projectRoot: projectConfig?.projectRoot
 	};
 }
+async function recordDownloadedMirror(input) {
+	const variant = input.variant;
+	if (!variant || !input.deps.recordMirrorForFile) return;
+	try {
+		await input.deps.recordMirrorForFile({
+			projectRoot: input.ctx.projectRoot,
+			baseUrl: input.ctx.baseUrl,
+			environment: input.ctx.env,
+			spaceId: input.ctx.spaceId,
+			filePath: input.outputPath,
+			assetId: variant.asset_id,
+			variantId: variant.id,
+			mediaKind: variant.media_kind || "image",
+			mediaKey: variant.media_key || variant.image_key
+		});
+	} catch (error) {
+		console.warn(`Warning: download succeeded but mirror registry was not updated: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
 async function listAssets$1(ctx, deps) {
 	return (await fetchJson(ctx, deps, `/api/spaces/${ctx.spaceId}/assets`)).assets || [];
 }
 async function getAssetDetails(ctx, deps, assetId) {
 	return fetchJson(ctx, deps, `/api/spaces/${ctx.spaceId}/assets/${assetId}`);
 }
+async function setActiveVariant(ctx, deps, assetId, variantId) {
+	try {
+		return await withAssetClient(ctx, deps, (client) => client.setActiveVariant(assetId, variantId));
+	} catch (error) {
+		if (!(error instanceof ServerConfirmationTimeoutError)) throw error;
+		const { asset } = await getAssetDetails(ctx, deps, assetId);
+		if (asset.active_variant_id === variantId) return asset;
+		throw error;
+	}
+}
 async function fetchJson(ctx, deps, apiPath) {
 	const response = await deps.fetch(`${ctx.baseUrl}${apiPath}`, { headers: {
 		"Authorization": `Bearer ${ctx.accessToken}`,
@@ -26247,7 +26552,7 @@ Options:
 }
 //#endregion
 //#region src/cli/index.ts
-var CLI_VERSION = "0.2.4+f4148f7b2b61";
+var CLI_VERSION = "0.2.6+be63b9dd565a";
 async function main() {
 	const argv = process$1.argv.slice(2);
 	if (argv[0] === "--") argv.shift();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "makefx",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Command-line interface for AI-assisted game asset production with Make Effects.",
   "license": "MIT",
   "type": "module",