makefx 1.0.3 → 1.0.5

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: 1.0.3
+Version: 1.0.5

package/makefx.mjs

@@ -7,7 +7,9 @@ import { spawn } from "node:child_process";
 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 { createReadStream, createWriteStream } from "node:fs";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 import https from "node:https";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -3215,7 +3217,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var net = __require("net");
 	var tls = __require("tls");
 	var { randomBytes: randomBytes$1, createHash: createHash$2 } = __require("crypto");
-	var { Duplex: Duplex$2, Readable } = __require("stream");
+	var { Duplex: Duplex$2, Readable: Readable$1 } = __require("stream");
 	var { URL: URL$1 } = __require("url");
 	var PerMessageDeflate = require_permessage_deflate();
 	var Receiver = require_receiver();
@@ -5873,11 +5875,40 @@ async function downloadFile(input) {
 	}
 	const headers = {};
 	if (input.accessToken) headers.Authorization = `Bearer ${input.accessToken}`;
-	const response = await fetch(`${input.baseUrl}${input.requestPath}`, { headers });
-	if (!response.ok) throw new Error(`Failed to download ${input.requestPath}: ${response.status} ${response.statusText}`);
-	const buffer = new Uint8Array(await response.arrayBuffer());
+	const requestUrl = `${input.baseUrl}${input.requestPath}`;
+	let response;
+	try {
+		response = await fetch(requestUrl, { headers });
+	} catch (error) {
+		throw new Error(`Failed to download ${input.requestPath}: ${formatFetchError(error)}`);
+	}
+	if (!response.ok) {
+		const errorText = await readErrorText(response);
+		throw new Error(`Failed to download ${input.requestPath}: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
+	}
 	await mkdir(path.dirname(input.outputPath), { recursive: true });
-	await writeFile(input.outputPath, buffer);
+	if (!response.body) throw new Error(`Failed to download ${input.requestPath}: response body was empty`);
+	try {
+		await pipeline(Readable.fromWeb(response.body), createWriteStream(input.outputPath));
+	} catch (error) {
+		throw new Error(`Failed to write download ${input.requestPath} to ${input.outputPath}: ${formatFetchError(error)}`);
+	}
+	return {
+		headers: response.headers,
+		requestUrl
+	};
+}
+async function readErrorText(response) {
+	try {
+		return (await response.text()).slice(0, 500).trim();
+	} catch {
+		return "";
+	}
+}
+function formatFetchError(error) {
+	if (!(error instanceof Error)) return String(error);
+	const cause = error.cause instanceof Error ? ` (${error.cause.message})` : "";
+	return `${error.message}${cause}`;
 }
 async function downloadImage(input) {
 	await downloadFile({
@@ -7235,8 +7266,8 @@ function validateAudioModeRequiredVoiceOptions(options, mode) {
 async function executeGenerate(parsed, ctx, client, deps, mediaKind, followOptions = {}) {
 	const prompt = getPrompt(parsed, "generate");
 	const outputPath = getOutputPath$1(parsed);
-	const name = requireOption(parsed, "name");
-	const assetType = requireOption(parsed, "type");
+	const name = requireOption$1(parsed, "name");
+	const assetType = requireOption$1(parsed, "type");
 	const musicProvider = parseMusicProviderOption(parsed, mediaKind, assetType);
 	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 	const videoFrameRefs = parseVideoFrameReferenceOptions(parsed, "generate", mediaKind).refs;
@@ -7331,7 +7362,7 @@ function parseMusicProviderOption(parsed, mediaKind, assetType) {
 async function executeRefine(parsed, ctx, client, deps, mediaKind) {
 	const prompt = getPrompt(parsed, "refine");
 	const outputPath = getOutputPath$1(parsed);
-	const sourceVariantId = requireOption(parsed, "variant");
+	const sourceVariantId = requireOption$1(parsed, "variant");
 	const state = await requestSpaceState(client);
 	const sourceVariant = state.variants.find((variant) => variant.id === sourceVariantId);
 	if (!sourceVariant) throw new Error(`Variant not found in space sync state: ${sourceVariantId}`);
@@ -7400,10 +7431,10 @@ async function executeRefine(parsed, ctx, client, deps, mediaKind) {
 async function executeDerive(parsed, ctx, client, deps, mediaKind, followOptions = {}) {
 	const prompt = getPrompt(parsed, "derive");
 	const outputPath = getOutputPath$1(parsed);
-	const name = requireOption(parsed, "name");
-	const assetType = requireOption(parsed, "type");
+	const name = requireOption$1(parsed, "name");
+	const assetType = requireOption$1(parsed, "type");
 	const videoFrameRefs = parseVideoFrameReferenceOptions(parsed, "derive", mediaKind).refs;
-	const refs = parsed.options.refs ? parseRefs(requireOption(parsed, "refs")) : [];
+	const refs = parsed.options.refs ? parseRefs(requireOption$1(parsed, "refs")) : [];
 	const referenceRefs = videoFrameRefs.length > 0 ? videoFrameRefs : refs;
 	if (referenceRefs.length === 0) throw new Error("--refs is required");
 	const imageOptions = parseImageGenerationOptions(parsed, mediaKind);
@@ -7614,10 +7645,10 @@ function timestampToIso(timestamp) {
 async function executeBatch(parsed, ctx, client, deps, mediaKind, saveBatchManifest) {
 	const prompt = getPrompt(parsed, "batch");
 	const outputDir = getOutputDir(parsed);
-	const name = requireOption(parsed, "name");
-	const assetType = requireOption(parsed, "type");
+	const name = requireOption$1(parsed, "name");
+	const assetType = requireOption$1(parsed, "type");
 	const musicProvider = parseMusicProviderOption(parsed, mediaKind, assetType);
-	const count = parseBatchCount(requireOption(parsed, "count"));
+	const count = parseBatchCount(requireOption$1(parsed, "count"));
 	const mode = parseBatchMode(parsed.options.mode || "explore");
 	const refs = parsed.options.refs ? parseRefs(parsed.options.refs) : [];
 	const imageOptions = parseImageGenerationOptions(parsed, mediaKind);
@@ -8205,7 +8236,7 @@ function getOutputExtension(variant, mediaKind) {
 function isImageManifestMedia(media) {
 	return media.mediaKind === "image" && Boolean(media.imageKey);
 }
-function requireOption(parsed, name) {
+function requireOption$1(parsed, name) {
 	const value = parsed.options[name];
 	if (!value || value === "true") throw new Error(`--${name} is required`);
 	return value;
@@ -8651,8 +8682,10 @@ async function handleAssets(parsed) {
 	}
 }
 async function executeAssets(parsed, deps = defaultDeps$3) {
-	const ctx = await buildContext$3(parsed, deps);
 	const subcommand = parsed.positionals[0] || "list";
+	if (subcommand === "search") return searchAssets(parsed, deps);
+	if (subcommand === "clone") return cloneAsset(parsed, deps);
+	const ctx = await buildContext$3(parsed, deps);
 	if (subcommand === "list") {
 		const assets = await listAssets(ctx, deps);
 		if (parsed.options.json === "true") deps.print(JSON.stringify(assets.map(toAssetJson), null, 2));
@@ -8677,24 +8710,24 @@ async function executeAssets(parsed, deps = defaultDeps$3) {
 		const ref = parsed.positionals[1];
 		if (!ref) throw new Error("Variant ID or legacy image key is required: makefx assets download <variant-id-or-legacy-image-key> -o <file>");
 		const outputPath = getOutputPath(parsed);
-		const resolved = await resolveDownloadRef(ref, ctx, deps);
-		await deps.downloadFile({
+		const resolved = resolveDownloadRef(ref, ctx);
+		const metadata = getDownloadedVariantMetadata(resolved, await deps.downloadFile({
 			baseUrl: ctx.baseUrl,
 			accessToken: ctx.accessToken,
 			requestPath: resolved.requestPath,
 			outputPath,
 			force: ctx.force
-		});
+		}));
 		await recordDownloadedMirror({
 			ctx,
 			deps,
 			outputPath,
-			variant: resolved.variant
+			variant: metadata.mirrorVariant
 		});
-		deps.print(`Downloaded ${resolved.mediaKey} to ${outputPath}`);
+		deps.print(`Downloaded ${metadata.mediaKey} to ${outputPath}`);
 		return {
 			type: "download",
-			mediaKey: resolved.mediaKey,
+			mediaKey: metadata.mediaKey,
 			outputPath,
 			variant: resolved.variant
 		};
@@ -8754,6 +8787,85 @@ async function buildContext$3(parsed, deps) {
 		projectRoot: projectConfig?.projectRoot
 	};
 }
+async function buildAuthContext(parsed, deps) {
+	const env = resolveCommandEnvironment(parsed, await deps.loadProjectConfig());
+	const config = await deps.loadConfig(env);
+	if (!config) throw new Error(`Not logged in to ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
+	if (config.token.expiresAt < Date.now()) throw new Error(`Token expired for ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
+	if (env === "local") process$1.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+	return {
+		env,
+		baseUrl: deps.resolveBaseUrl(env),
+		accessToken: config.token.accessToken
+	};
+}
+function requireOption(parsed, names, usage) {
+	for (const name of names) {
+		const value = normalizeOption(parsed.options[name]);
+		if (value) return value;
+	}
+	throw new Error(usage);
+}
+async function searchAssets(parsed, deps) {
+	const ctx = await buildAuthContext(parsed, deps);
+	const query = parsed.positionals.slice(1).join(" ").trim();
+	const params = new URLSearchParams();
+	if (query) params.set("q", query);
+	const mediaKind = normalizeOption(parsed.options.media) ?? normalizeOption(parsed.options["media-kind"]);
+	const assetType = normalizeOption(parsed.options.type);
+	const limit = normalizeOption(parsed.options.limit);
+	if (mediaKind) params.set("media_kind", mediaKind);
+	if (assetType) params.set("type", assetType);
+	if (limit) params.set("limit", limit);
+	const response = await deps.fetch(`${ctx.baseUrl}/api/assets/search?${params.toString()}`, { headers: { Authorization: `Bearer ${ctx.accessToken}` } });
+	if (!response.ok) throw new Error(`Search failed: ${response.status} - ${await response.text()}`);
+	const results = (await response.json()).results ?? [];
+	if (parsed.options.json === "true") deps.print(JSON.stringify(results, null, 2));
+	else printAssetSearchResults(results, deps.print);
+	return {
+		type: "search",
+		results
+	};
+}
+async function cloneAsset(parsed, deps) {
+	const ctx = await buildAuthContext(parsed, deps);
+	const sourceVariantId = parsed.positionals[1] ?? normalizeOption(parsed.options.variant);
+	if (!sourceVariantId) throw new Error("Usage: makefx assets clone <variant-id> --from-space <source-space-id> --to-space <target-space-id>");
+	const sourceSpaceId = requireOption(parsed, ["from-space", "source-space"], "Usage: makefx assets clone <variant-id> --from-space <source-space-id> --to-space <target-space-id>");
+	const targetSpaceId = requireOption(parsed, ["to-space", "target-space"], "Usage: makefx assets clone <variant-id> --from-space <source-space-id> --to-space <target-space-id>");
+	const body = {
+		sourceSpaceId,
+		sourceVariantId
+	};
+	const name = normalizeOption(parsed.options.name);
+	const type = normalizeOption(parsed.options.type);
+	if (name) body.name = name;
+	if (type) body.type = type;
+	const response = await deps.fetch(`${ctx.baseUrl}/api/spaces/${encodeURIComponent(targetSpaceId)}/assets/clone`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${ctx.accessToken}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(body)
+	});
+	if (!response.ok) throw new Error(`Clone failed: ${response.status} - ${await response.text()}`);
+	const payload = await response.json();
+	if (parsed.options.json === "true") deps.print(JSON.stringify(payload, null, 2));
+	else {
+		const asset = payload.asset;
+		const variantPayload = payload.variant;
+		const variant = variantPayload?.variant ?? variantPayload;
+		deps.print(`Cloned variant ${sourceVariantId} into space ${targetSpaceId}`);
+		if (asset?.id) deps.print(`  Asset:   ${asset.id}${asset.name ? ` (${asset.name})` : ""}`);
+		if (variant?.id) deps.print(`  Variant: ${variant.id}`);
+	}
+	return {
+		type: "clone",
+		asset: payload.asset,
+		variant: payload.variant
+	};
+}
 async function recordDownloadedMirror(input) {
 	const variant = input.variant;
 	if (!variant || !input.deps.recordMirrorForFile) return;
@@ -8800,7 +8912,7 @@ async function fetchJson(ctx, deps, apiPath) {
 	}
 	return response.json();
 }
-async function resolveDownloadRef(ref, ctx, deps) {
+function resolveDownloadRef(ref, ctx) {
 	if (looksLikeStorageKey(ref)) {
 		if (!isLegacyImageStorageKey(ref)) throw new Error("Direct media key downloads are not supported. Pass a variant ID so the authenticated media endpoint can authorize the download.");
 		return {
@@ -8808,19 +8920,32 @@ async function resolveDownloadRef(ref, ctx, deps) {
 			requestPath: `/api/images/${ref}`
 		};
 	}
-	const assets = await listAssets(ctx, deps);
-	for (const asset of assets) {
-		const variant = (await getAssetDetails(ctx, deps, asset.id)).variants.find((candidate) => candidate.id === ref);
-		if (!variant) continue;
-		const mediaKey = variant.media_key || variant.image_key;
-		if (mediaKey) return {
-			mediaKey,
-			requestPath: `/api/spaces/${encodeURIComponent(ctx.spaceId)}/variants/${encodeURIComponent(variant.id)}/media`,
-			variant
-		};
-		throw new Error(`Variant ${ref} has no downloadable media; status is ${variant.status}`);
-	}
-	throw new Error(`Variant not found in space ${ctx.spaceId}: ${ref}`);
+	return {
+		mediaKey: ref,
+		requestPath: `/api/spaces/${encodeURIComponent(ctx.spaceId)}/variants/${encodeURIComponent(ref)}/media`
+	};
+}
+function getDownloadedVariantMetadata(resolved, download) {
+	if (resolved.variant) return {
+		mediaKey: resolved.variant.media_key || resolved.variant.image_key || resolved.mediaKey,
+		mirrorVariant: resolved.variant
+	};
+	const headers = download?.headers;
+	const variantId = headers?.get("x-makefx-variant-id");
+	const assetId = headers?.get("x-makefx-asset-id");
+	const mediaKind = headers?.get("x-makefx-media-kind");
+	const mediaKey = headers?.get("x-makefx-media-key") || resolved.mediaKey;
+	if (!variantId || !assetId) return { mediaKey };
+	return {
+		mediaKey,
+		mirrorVariant: {
+			id: variantId,
+			asset_id: assetId,
+			media_kind: mediaKind || "image",
+			media_key: mediaKey,
+			image_key: mediaKey.startsWith("images/") ? mediaKey : null
+		}
+	};
 }
 function looksLikeStorageKey(value) {
 	return value.includes("/") || [
@@ -8859,6 +8984,19 @@ function printAssetList(assets, print) {
 	print("-".repeat(113));
 	for (const asset of assets) print(formatTimestamp(asset.updated_at).padEnd(21) + truncate(asset.type || "unknown", 12).padEnd(14) + truncate(asset.media_kind || "-", 7).padEnd(9) + truncate(asset.active_variant_id || "-", 24).padEnd(26) + truncate(asset.id, 26).padEnd(28) + truncate(asset.name, 32));
 }
+function printAssetSearchResults(results, print) {
+	if (results.length === 0) {
+		print("No matching assets found.");
+		return;
+	}
+	for (const result of results) {
+		print(`${result.assetName} (${result.assetId})`);
+		print(`  Space:   ${result.spaceName} (${result.spaceId})`);
+		print(`  Type:    ${result.assetType ?? "-"}  Media: ${result.mediaKind}`);
+		print(`  Active:  ${result.activeVariantId ?? "-"}${result.activeVariantStatus ? ` (${result.activeVariantStatus})` : ""}`);
+		print(`  Counts:  variants=${result.variantCount} completed=${result.completedVariantCount} starred=${result.starredVariantCount}`);
+	}
+}
 function printAssetDetails(details, ctx, print) {
 	const { asset, variants, lineage } = details;
 	print(`\nAsset ${asset.id}\n`);
@@ -8950,9 +9088,11 @@ function printUsage$2() {
 Usage:
   makefx assets
   makefx assets --json
+  makefx assets search "query" [--media image|audio|video] [--type <type>] [--json]
   makefx assets show <asset-id>
   makefx assets show <asset-id> --json
   makefx assets download <variant-id|legacy-image-key> -o output-file
+  makefx assets clone <variant-id> --from-space <source-space-id> --to-space <target-space-id>
   makefx assets delete <asset-id>
   makefx assets rename <asset-id> "<new-name>"
   makefx assets set-active <asset-id> <variant-id>
@@ -9364,7 +9504,7 @@ Options:
 }
 //#endregion
 //#region src/cli/index.ts
-var CLI_VERSION = "1.0.3+9dc1e273aed1";
+var CLI_VERSION = "1.0.5+22056848942e";
 async function main() {
 	const argv = process$1.argv.slice(2);
 	if (argv[0] === "--") argv.shift();
@@ -9551,8 +9691,10 @@ Continue:
 
 Inspect:
   assets                                 List assets
+  assets search "query"                  Search assets across Spaces
   assets show <asset-id>                 Show variants and lineage
   assets download <variant-id> -o <file> Download variant media
+  assets clone <variant-id> --from-space <id> --to-space <id>
   variants rate <variant-id> approved|rejected
   variants star <variant-id>
 
@@ -9939,9 +10081,11 @@ function printAssetsHelp() {
 Usage:
   makefx assets
   makefx assets --json
+  makefx assets search "query" [--media image|audio|video] [--type <type>] [--json]
   makefx assets show <asset-id>
   makefx assets show <asset-id> --json
   makefx assets download <variant-id|legacy-image-key> -o output-file
+  makefx assets clone <variant-id> --from-space <source-space-id> --to-space <target-space-id>
   makefx assets delete <asset-id>
   makefx assets rename <asset-id> "<new-name>"
   makefx assets set-active <asset-id> <variant-id>

package/package.json

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