npm - makefx - Versions diffs - 1.6.12 → 2.0.0 - Mend

makefx 1.6.12 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/makefx.js ADDED Viewed

@@ -0,0 +1,3176 @@
+#!/usr/bin/env node
+// src/index.ts
+import process4 from "node:process";
+// src/lib/project.ts
+var SERVICE_NAME = "makefx.app";
+var CONFIG_DIR_NAME = "makefx-cli";
+var ENVIRONMENT_ORIGINS = {
+  production: "https://makefx.app",
+  stage: "https://stage.makefx.app",
+  local: "https://localhost:3002"
+};
+// src/lib/version.ts
+var CLI_VERSION = true ? "2.0.0" : "0.0.0-dev";
+// src/commands/convenience.ts
+import { randomUUID } from "node:crypto";
+import { link, lstat, open as open2, unlink } from "node:fs/promises";
+import { resolve } from "node:path";
+// src/lib/auth.ts
+import { createHash, randomBytes } from "node:crypto";
+import http from "node:http";
+import { spawn } from "node:child_process";
+var DEFAULT_CLIENT_ID = "cli";
+var DEFAULT_REDIRECT_PORT = 8765;
+var AUTH_SCOPES = "openid profile email read write";
+function cliCommand(env = process.env) {
+  return env.npm_command === "exec" ? "npx makefx" : "makefx";
+}
+function generateCodeVerifier() {
+  return base64UrlEncode(randomBytes(32));
+}
+async function generateCodeChallenge(codeVerifier) {
+  const hash = createHash("sha256").update(codeVerifier).digest();
+  return base64UrlEncode(hash);
+}
+function generateState() {
+  return base64UrlEncode(randomBytes(16));
+}
+function base64UrlEncode(buffer) {
+  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+async function waitForAuthorizationCode(port, expectedState) {
+  return new Promise((resolve5, reject) => {
+    const server = http.createServer((req, res) => {
+      if (!req.url) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(getErrorPage("invalid_request", "Invalid request"));
+        return;
+      }
+      const url = new URL(req.url, `http://127.0.0.1:${port}`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404, { "Content-Type": "text/html" });
+        res.end(getErrorPage("not_found", "Page not found"));
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      const errorDescription = url.searchParams.get("error_description");
+      if (state !== expectedState) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(getErrorPage("invalid_request", "This callback does not belong to the login in progress."));
+        return;
+      }
+      if (error) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(getErrorPage(error, errorDescription || void 0));
+        clearTimeout(timeout);
+        server.close();
+        reject(new Error(`OAuth error: ${error}${errorDescription ? ` - ${errorDescription}` : ""}`));
+        return;
+      }
+      if (!code) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(getErrorPage("invalid_request", "Missing authorization code"));
+        clearTimeout(timeout);
+        server.close();
+        reject(new Error("Missing authorization code"));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(getSuccessPage());
+      clearTimeout(timeout);
+      server.close();
+      resolve5({ code });
+    });
+    server.listen(port, "127.0.0.1");
+    server.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(new Error(`Failed to start local callback server: ${error.message}`));
+    });
+    const timeout = setTimeout(
+      () => {
+        server.close();
+        reject(new Error("Login timed out waiting for authorization response"));
+      },
+      5 * 60 * 1e3
+    );
+  });
+}
+function getSuccessPage() {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Login Successful - ${SERVICE_NAME}</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 1rem;
+      backdrop-filter: blur(10px);
+      box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+    }
+    h1 { font-size: 2rem; margin-bottom: 1rem; }
+    p { font-size: 1.1rem; opacity: 0.9; }
+    .checkmark {
+      width: 80px;
+      height: 80px;
+      border-radius: 50%;
+      display: inline-block;
+      stroke-width: 3;
+      stroke: #fff;
+      stroke-miterlimit: 10;
+      box-shadow: inset 0px 0px 0px #fff;
+      animation: fill .4s ease-in-out .4s forwards, scale .3s ease-in-out .9s both;
+      margin-bottom: 1rem;
+    }
+    .checkmark__circle {
+      stroke-dasharray: 166;
+      stroke-dashoffset: 166;
+      stroke-width: 3;
+      stroke-miterlimit: 10;
+      stroke: #fff;
+      fill: none;
+      animation: stroke 0.6s cubic-bezier(0.65, 0, 0.45, 1) forwards;
+    }
+    .checkmark__check {
+      transform-origin: 50% 50%;
+      stroke-dasharray: 48;
+      stroke-dashoffset: 48;
+      animation: stroke 0.3s cubic-bezier(0.65, 0, 0.45, 1) 0.8s forwards;
+    }
+    @keyframes stroke {
+      100% { stroke-dashoffset: 0; }
+    }
+    @keyframes scale {
+      0%, 100% { transform: none; }
+      50% { transform: scale3d(1.1, 1.1, 1); }
+    }
+    @keyframes fill {
+      100% { box-shadow: inset 0px 0px 0px 40px #fff; }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <svg class="checkmark" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 52 52">
+      <circle class="checkmark__circle" cx="26" cy="26" r="25" fill="none"/>
+      <path class="checkmark__check" fill="none" d="M14.1 27.2l7.1 7.2 16.7-16.8"/>
+    </svg>
+    <h1>Login Successful!</h1>
+    <p>You can close this window and return to the terminal.</p>
+  </div>
+</body>
+</html>`;
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (character) => `&#${character.charCodeAt(0)};`);
+}
+function getErrorPage(error, description) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Login Failed - ${SERVICE_NAME}</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+      color: white;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 1rem;
+      backdrop-filter: blur(10px);
+      box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+      max-width: 500px;
+    }
+    h1 { font-size: 2rem; margin-bottom: 1rem; }
+    p { font-size: 1.1rem; opacity: 0.9; margin-bottom: 0.5rem; }
+    .error-code { font-family: monospace; font-size: 0.9rem; opacity: 0.7; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>\u274C Login Failed</h1>
+    <p>${escapeHtml(description || "Authorization was denied or failed.")}</p>
+    <p class="error-code">Error: ${escapeHtml(error)}</p>
+    <p>Please return to the terminal and try again.</p>
+  </div>
+</body>
+</html>`;
+}
+async function openBrowser(url) {
+  return new Promise((resolve5, reject) => {
+    const platform = process.platform;
+    let command;
+    let args;
+    if (platform === "darwin") {
+      command = "open";
+      args = [url];
+    } else if (platform === "win32") {
+      command = "cmd";
+      args = ["/c", "start", '""', url];
+    } else {
+      command = "xdg-open";
+      args = [url];
+    }
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", (error) => reject(error));
+    child.on("spawn", () => {
+      child.unref();
+      resolve5();
+    });
+  });
+}
+// src/lib/errors.ts
+var CliUsageError = class extends Error {
+  name = "CliUsageError";
+};
+var ToolCallError = class extends Error {
+  name = "ToolCallError";
+  structuredContent;
+  jsonOutput;
+  constructor(structuredContent, fallbackMessage, jsonOutput) {
+    super(typeof structuredContent.message === "string" ? structuredContent.message : fallbackMessage);
+    this.structuredContent = structuredContent;
+    this.jsonOutput = jsonOutput;
+  }
+  get code() {
+    return typeof this.structuredContent.code === "string" ? this.structuredContent.code : "tool_error";
+  }
+  get details() {
+    const details = this.structuredContent.details;
+    return details !== null && typeof details === "object" && !Array.isArray(details) ? details : void 0;
+  }
+};
+// src/lib/config.ts
+import { chmod, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+var DEFAULT_ENVIRONMENT = "production";
+var CONFIG_DIR_NAME2 = CONFIG_DIR_NAME;
+var CONFIG_FILE_NAME = "config.json";
+async function loadMultiEnvConfig() {
+  const configPath = await getConfigPath();
+  try {
+    const raw = await readFile(configPath, "utf8");
+    const data = JSON.parse(raw);
+    if (data.environment && data.token && !data.configs) {
+      const legacyConfig = data;
+      return {
+        configs: {
+          [legacyConfig.environment]: legacyConfig
+        }
+      };
+    }
+    return data;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function saveMultiEnvConfig(multiConfig) {
+  const configPath = await getConfigPath();
+  await mkdir(path.dirname(configPath), { recursive: true, mode: 448 });
+  const temporary = `${configPath}.${process.pid}.tmp`;
+  await writeFile(temporary, JSON.stringify(multiConfig, null, 2), { encoding: "utf8", mode: 384 });
+  await chmod(temporary, 384);
+  await rename(temporary, configPath);
+}
+async function saveConfig(config) {
+  await withConfigLock(() => saveConfigHoldingLock(config));
+}
+async function saveConfigHoldingLock(config) {
+  const multiConfig = await loadMultiEnvConfig() || { configs: {} };
+  multiConfig.configs[config.environment] = config;
+  await saveMultiEnvConfig(multiConfig);
+}
+async function loadStoredConfig(environment) {
+  const multiConfig = await loadMultiEnvConfig();
+  if (!multiConfig) return null;
+  const env = environment || DEFAULT_ENVIRONMENT;
+  return multiConfig.configs[env] || null;
+}
+async function listStoredConfigs() {
+  const multiConfig = await loadMultiEnvConfig();
+  return multiConfig ? Object.values(multiConfig.configs) : [];
+}
+async function removeConfig(environment) {
+  await withConfigLock(() => removeConfigHoldingLock(environment));
+}
+async function removeConfigHoldingLock(environment) {
+  if (!environment) {
+    const configPath = await getConfigPath();
+    await rm(configPath);
+    return;
+  }
+  const multiConfig = await loadMultiEnvConfig();
+  if (multiConfig) {
+    delete multiConfig.configs[environment];
+    if (Object.keys(multiConfig.configs).length === 0) {
+      const configPath = await getConfigPath();
+      await rm(configPath);
+    } else {
+      await saveMultiEnvConfig(multiConfig);
+    }
+  }
+}
+var LOCK_STALE_MS = 6e4;
+var LOCK_WAIT_MS = 1e4;
+async function retireStaleLock(lockPath) {
+  let takeover;
+  try {
+    takeover = await open(takeoverPathFor(lockPath), "wx");
+  } catch (error) {
+    if (error.code === "EEXIST") return "takeover-held";
+    throw error;
+  }
+  try {
+    await takeover.close();
+    const age = Date.now() - ((await stat(lockPath).catch(() => null))?.mtimeMs ?? Date.now());
+    if (age <= LOCK_STALE_MS) return "fresh";
+    await rm(lockPath, { force: true });
+    return "retired";
+  } finally {
+    await rm(takeoverPathFor(lockPath), { force: true });
+  }
+}
+function takeoverPathFor(lockPath) {
+  return `${lockPath}.takeover`;
+}
+async function withConfigLock(fn) {
+  const lockPath = `${await getConfigPath()}.lock`;
+  await mkdir(path.dirname(lockPath), { recursive: true, mode: 448 });
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  const owner = `${process.pid}:${Math.random().toString(36).slice(2)}`;
+  for (; ; ) {
+    try {
+      const handle = await open(lockPath, "wx");
+      await handle.writeFile(owner, "utf8");
+      await handle.close();
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+      const age = Date.now() - ((await stat(lockPath).catch(() => null))?.mtimeMs ?? Date.now());
+      const recovery = age > LOCK_STALE_MS ? await retireStaleLock(lockPath) : "fresh";
+      if (recovery === "retired") continue;
+      if (Date.now() > deadline) {
+        throw new Error(
+          recovery === "takeover-held" ? `A crashed process left ${takeoverPathFor(lockPath)}; remove it and ${lockPath} if no other CLI is running` : `Another process holds ${lockPath}; remove it if no other CLI is running`
+        );
+      }
+      await new Promise((resolve5) => setTimeout(resolve5, 50 + Math.random() * 100));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    const holder = await readFile(lockPath, "utf8").catch(() => null);
+    if (holder === owner) {
+      await rm(lockPath, { force: true });
+    }
+  }
+}
+async function getConfigPath() {
+  const baseDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  return path.join(baseDir, CONFIG_DIR_NAME2, CONFIG_FILE_NAME);
+}
+function resolveBaseUrl(env) {
+  switch (env) {
+    case "production":
+      return ENVIRONMENT_ORIGINS.production;
+    case "stage":
+    case "staging":
+      return ENVIRONMENT_ORIGINS.stage;
+    case "local":
+      return ENVIRONMENT_ORIGINS.local;
+    default:
+      throw new CliUsageError(`Unknown environment "${env}". Valid options: production, stage, local`);
+  }
+}
+// src/lib/json.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// src/lib/mcp-transport.ts
+var PROTOCOL_VERSION_META_KEY = "io.modelcontextprotocol/protocolVersion";
+function encodeHeaderValue(value) {
+  if (/^[\x21-\x7E]+$/.test(value)) {
+    return value;
+  }
+  return `=?base64?${Buffer.from(value, "utf8").toString("base64")}?=`;
+}
+function mcpRequestHeaders(line) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return {};
+  }
+  if (!isRecord(message) || typeof message.method !== "string") {
+    return {};
+  }
+  const params = isRecord(message.params) ? message.params : {};
+  const meta = isRecord(params._meta) ? params._meta : {};
+  const version = meta[PROTOCOL_VERSION_META_KEY];
+  if (typeof version !== "string") {
+    return {};
+  }
+  const headers = {
+    "MCP-Protocol-Version": version,
+    "Mcp-Method": message.method
+  };
+  if (message.method === "tools/call" && typeof params.name === "string") {
+    headers["Mcp-Name"] = encodeHeaderValue(params.name);
+  }
+  return headers;
+}
+// src/lib/tokens.ts
+var REFRESH_MARGIN_MS = 5 * 60 * 1e3;
+var REFRESH_TIMEOUT_MS = 1e4;
+function mcpResourceFor(baseUrl) {
+  return `${baseUrl.replace(/\/$/, "")}/mcp`;
+}
+function requireUrl(document, field) {
+  const value = document[field];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Authorization server metadata is missing ${field}`);
+  }
+  return value;
+}
+async function discoverAuthorizationServer(baseUrl, fetchImpl = fetch, signal) {
+  const response = await fetchImpl(`${baseUrl}/.well-known/oauth-authorization-server`, {
+    headers: { accept: "application/json" },
+    signal
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to load authorization server metadata (${response.status})`);
+  }
+  const document = await response.json();
+  const revocationEndpoint = document.revocation_endpoint;
+  return {
+    authorizationEndpoint: requireUrl(document, "authorization_endpoint"),
+    tokenEndpoint: requireUrl(document, "token_endpoint"),
+    ...typeof revocationEndpoint === "string" ? { revocationEndpoint } : {}
+  };
+}
+var TokenRequestError = class extends Error {
+  status;
+  code;
+  constructor(status, code, description) {
+    super(description ? `${code}: ${description}` : code);
+    this.name = "TokenRequestError";
+    this.status = status;
+    this.code = code;
+  }
+};
+async function postForm(endpoint, fields, fetchImpl, signal) {
+  return fetchImpl(endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded", accept: "application/json" },
+    body: new URLSearchParams(fields).toString(),
+    signal
+  });
+}
+async function readTokenResponse(response) {
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new TokenRequestError(
+      response.status,
+      typeof body.error === "string" ? body.error : `http_${response.status}`,
+      typeof body.error_description === "string" ? body.error_description : void 0
+    );
+  }
+  if (typeof body.access_token !== "string" || typeof body.expires_in !== "number") {
+    throw new Error("Token response is missing access_token or expires_in");
+  }
+  return body;
+}
+function storedTokenFrom(response, now = Date.now()) {
+  return {
+    accessToken: response.access_token,
+    expiresAt: now + response.expires_in * 1e3,
+    issuedAt: now,
+    scope: response.scope,
+    ...response.refresh_token ? {
+      refreshToken: response.refresh_token,
+      refreshExpiresAt: now + (response.refresh_token_expires_in ?? 0) * 1e3
+    } : {}
+  };
+}
+async function exchangeCodeForToken(input, fetchImpl = fetch) {
+  const response = await postForm(
+    input.tokenEndpoint,
+    {
+      grant_type: "authorization_code",
+      code: input.code,
+      code_verifier: input.codeVerifier,
+      redirect_uri: input.redirectUri,
+      client_id: input.clientId,
+      resource: mcpResourceFor(input.baseUrl)
+    },
+    fetchImpl
+  );
+  return readTokenResponse(response);
+}
+function isAccessTokenFresh(token, now = Date.now()) {
+  return token.expiresAt - now > REFRESH_MARGIN_MS;
+}
+function canRefresh(token, now = Date.now()) {
+  return Boolean(token.refreshToken) && (token.refreshExpiresAt ?? 0) > now;
+}
+async function refreshStoredToken(config, fetchImpl = fetch) {
+  if (!canRefresh(config.token)) {
+    return null;
+  }
+  return withConfigLock(async () => {
+    const stored = await loadStoredConfig(config.environment);
+    if (stored && stored.token.accessToken !== config.token.accessToken && stored.token.expiresAt > Date.now()) {
+      return stored;
+    }
+    const current = stored ?? config;
+    if (!canRefresh(current.token)) {
+      return null;
+    }
+    return refreshUnlocked(current, fetchImpl);
+  });
+}
+async function refreshUnlocked(config, fetchImpl) {
+  const server = await discoverAuthorizationServer(
+    config.baseUrl,
+    fetchImpl,
+    AbortSignal.timeout(REFRESH_TIMEOUT_MS)
+  );
+  const response = await postForm(
+    server.tokenEndpoint,
+    {
+      grant_type: "refresh_token",
+      refresh_token: config.token.refreshToken ?? "",
+      client_id: config.clientId,
+      resource: mcpResourceFor(config.baseUrl)
+    },
+    fetchImpl,
+    AbortSignal.timeout(REFRESH_TIMEOUT_MS)
+  );
+  let tokens;
+  try {
+    tokens = await readTokenResponse(response);
+  } catch (error) {
+    if (error instanceof TokenRequestError && error.status === 400) {
+      return null;
+    }
+    throw error;
+  }
+  const refreshed = {
+    ...config,
+    token: storedTokenFrom(tokens),
+    user: tokens.user ?? config.user,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveConfigHoldingLock(refreshed);
+  return refreshed;
+}
+async function ensureFreshConfig(config, fetchImpl = fetch) {
+  if (isAccessTokenFresh(config.token)) {
+    return config;
+  }
+  return refreshStoredToken(config, fetchImpl);
+}
+var REVOCATION_TIMEOUT_MS = 5e3;
+async function revokeStoredToken(config, fetchImpl = fetch, timeoutMs = REVOCATION_TIMEOUT_MS) {
+  const signal = AbortSignal.timeout(timeoutMs);
+  try {
+    const server = await discoverAuthorizationServer(config.baseUrl, fetchImpl, signal);
+    if (!server.revocationEndpoint) {
+      return false;
+    }
+    const token = config.token.refreshToken ?? config.token.accessToken;
+    const response = await postForm(
+      server.revocationEndpoint,
+      {
+        token,
+        token_type_hint: config.token.refreshToken ? "refresh_token" : "access_token",
+        client_id: config.clientId
+      },
+      fetchImpl,
+      signal
+    );
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+// src/lib/mcp-bridge.ts
+function createMcpBridge(options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  let config = options.config;
+  let refreshing = null;
+  const endpoint = new URL("/mcp", config.baseUrl).toString();
+  async function send(line, accessToken) {
+    return fetchImpl(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        Authorization: `Bearer ${accessToken}`,
+        ...mcpRequestHeaders(line)
+      },
+      body: line
+    });
+  }
+  async function tokenAfterRejection(rejectedToken) {
+    if (config.token.accessToken !== rejectedToken) {
+      return config.token.accessToken;
+    }
+    refreshing ??= refreshStoredToken(config, fetchImpl).finally(() => {
+      refreshing = null;
+    });
+    const refreshed = await refreshing;
+    if (!refreshed) {
+      return null;
+    }
+    config = refreshed;
+    return config.token.accessToken;
+  }
+  async function forward(line) {
+    let response;
+    try {
+      const token = config.token.accessToken;
+      response = await send(line, token);
+      if (response.status === 401) {
+        const retryToken = await tokenAfterRejection(token);
+        if (retryToken) {
+          response = await send(line, retryToken);
+        }
+      }
+    } catch (error) {
+      return { kind: "unreachable", message: error instanceof Error ? error.message : String(error) };
+    }
+    if (response.status === 202) {
+      return { kind: "accepted" };
+    }
+    const text2 = (await response.text()).trim();
+    if (response.status === 401) {
+      return { kind: "unauthorized", text: text2 };
+    }
+    return { kind: "response", text: text2 };
+  }
+  return { forward, currentConfig: () => config };
+}
+// src/lib/tool-client.ts
+var MCP_VERSION = "2026-07-28";
+function responseJson(text2) {
+  if (text2.startsWith("{")) return JSON.parse(text2);
+  const data = text2.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).at(-1);
+  if (!data) throw new Error("The MCP server returned no response.");
+  return JSON.parse(data);
+}
+function createToolClient(config, fetchImpl = fetch) {
+  const bridge = createMcpBridge({ config, fetchImpl });
+  let nextId = 1;
+  return {
+    async call(name, args) {
+      const line = JSON.stringify({
+        jsonrpc: "2.0",
+        id: nextId++,
+        method: "tools/call",
+        params: {
+          name,
+          arguments: args,
+          _meta: {
+            "io.modelcontextprotocol/protocolVersion": MCP_VERSION,
+            "io.modelcontextprotocol/clientCapabilities": {}
+          }
+        }
+      });
+      const outcome = await bridge.forward(line);
+      if (outcome.kind === "unreachable") throw new Error(`MCP request failed: ${outcome.message}`);
+      if (outcome.kind === "unauthorized") throw new Error("The stored login was rejected. Sign in again.");
+      if (outcome.kind === "accepted")
+        throw new Error("The MCP server accepted a call without returning its result.");
+      const envelope = responseJson(outcome.text);
+      if (envelope.error) throw new Error(envelope.error.message ?? "MCP protocol error.");
+      const result = envelope.result;
+      if (!result) throw new Error("The MCP server returned no tool result.");
+      if (result.isError) {
+        const fallback = result.content?.find(({ type }) => type === "text")?.text ?? "The tool call failed.";
+        throw new ToolCallError(
+          result.structuredContent ?? {
+            code: "tool_error",
+            message: fallback,
+            retryable: false
+          },
+          fallback
+        );
+      }
+      if (!result.structuredContent) throw new Error("The tool returned no structured result.");
+      return result.structuredContent;
+    }
+  };
+}
+async function authenticatedToolClient(parsed) {
+  return createToolClient(await authenticatedConfig(parsed));
+}
+async function authenticatedConfig(parsed) {
+  const environment = parsed.options.local === "true" ? "local" : parsed.options.env ?? DEFAULT_ENVIRONMENT;
+  const hint = `Run: ${cliCommand()} login --env ${environment}`;
+  const stored = await loadStoredConfig(environment);
+  if (!stored) throw new Error(`Not logged in for "${environment}". ${hint}`);
+  const config = await ensureFreshConfig(stored);
+  if (!config) throw new Error(`Credentials for "${environment}" have expired. ${hint}`);
+  return config;
+}
+// src/commands/convenience.ts
+var defaults = {
+  client: authenticatedToolClient,
+  write: (text2) => process.stdout.write(`${text2}
+`),
+  openUrl: openBrowser,
+  id: randomUUID,
+  env: process.env
+};
+var GLOBAL_OPTIONS = ["env", "local", "json", "help"];
+var CONVENIENCE_USAGE = {
+  export: "export --space ACCOUNT/SPACE [--starred-only] [--out PATH] [--json]",
+  open: "open SPACE | open ASSET --space ACCOUNT/SPACE [--no-open]"
+};
+function usage(command) {
+  return `Usage: makefx ${CONVENIENCE_USAGE[command]}`;
+}
+function optional(parsed, name) {
+  const value = parsed.options[name];
+  if (value === "true") throw new CliUsageError(`--${name} requires a value.`);
+  return value;
+}
+function required(parsed, name, command) {
+  const value = optional(parsed, name);
+  if (!value) throw new CliUsageError(`${command} requires --${name} <value>.`);
+  return value;
+}
+function rejectUnexpected(parsed, command, options) {
+  const allowed = /* @__PURE__ */ new Set([...GLOBAL_OPTIONS, ...options]);
+  const unexpected = Object.keys(parsed.options).find((option3) => !allowed.has(option3));
+  if (unexpected) throw new CliUsageError(`Unknown option --${unexpected}. ${usage(command)}`);
+}
+async function destinationAvailable(path2) {
+  try {
+    await lstat(path2);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  throw new Error(`Destination already exists: ${path2}`);
+}
+async function publishJson(destination, value, id) {
+  await destinationAvailable(destination);
+  const temporary = `${destination}.makefx-${id()}.tmp`;
+  let published = false;
+  try {
+    const handle = await open2(temporary, "wx");
+    try {
+      await handle.writeFile(`${JSON.stringify(value, null, 2)}
+`, "utf8");
+    } finally {
+      await handle.close();
+    }
+    await link(temporary, destination);
+    published = true;
+    await unlink(temporary);
+  } finally {
+    if (!published) await unlink(temporary).catch(() => void 0);
+  }
+}
+async function handleExport(parsed, dependencies = defaults) {
+  rejectUnexpected(parsed, "export", ["space", "starred-only", "out"]);
+  if (parsed.positionals.length > 0) {
+    throw new CliUsageError(`export does not accept "${parsed.positionals[0]}". ${usage("export")}`);
+  }
+  const space = required(parsed, "space", "export");
+  const out = optional(parsed, "out");
+  const destination = out ? resolve(out) : void 0;
+  if (destination) await destinationAvailable(destination);
+  const client = await dependencies.client(parsed);
+  const result = await client.call("export_space", {
+    space_id: space,
+    starred_only: parsed.options["starred-only"] === "true"
+  });
+  if (!destination) {
+    dependencies.write(JSON.stringify(result, null, 2));
+    return;
+  }
+  await publishJson(destination, result, dependencies.id);
+  dependencies.write(parsed.options.json === "true" ? JSON.stringify(result, null, 2) : destination);
+}
+function browserDisabled(parsed, env) {
+  if (parsed.options["no-open"] === "true") return true;
+  const value = env.MAKEFX_NO_OPEN?.toLowerCase();
+  return value !== void 0 && !["", "0", "false", "no"].includes(value);
+}
+async function handleOpen(parsed, dependencies = defaults) {
+  rejectUnexpected(parsed, "open", ["space", "no-open"]);
+  if (parsed.positionals.length !== 1) {
+    throw new CliUsageError(`open requires one space or asset id. ${usage("open")}`);
+  }
+  const target = parsed.positionals[0];
+  const space = optional(parsed, "space");
+  const isSpace = target.includes("/");
+  if (isSpace && space) {
+    throw new CliUsageError(`A space target does not accept --space. ${usage("open")}`);
+  }
+  if (!isSpace && !space) {
+    throw new CliUsageError(`An asset target requires --space <value>. ${usage("open")}`);
+  }
+  const client = await dependencies.client(parsed);
+  const result = await client.call(
+    isSpace ? "get_space" : "get_asset",
+    isSpace ? { space_id: target, starred_only: false } : { space_id: space, asset_id: target, wait_seconds: 0 }
+  );
+  const webUrl = result.web_url;
+  if (typeof webUrl !== "string") throw new Error("The tool returned no canonical web_url.");
+  dependencies.write(webUrl);
+  if (!browserDisabled(parsed, dependencies.env)) await dependencies.openUrl(webUrl);
+}
+// src/commands/create.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+// src/lib/json-schema.ts
+import { isDeepStrictEqual } from "node:util";
+var SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "$schema",
+  "type",
+  "enum",
+  "const",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "default",
+  "title",
+  "description",
+  "preview_url",
+  "properties",
+  "required",
+  "additionalProperties",
+  "items",
+  "prefixItems",
+  "anyOf",
+  "oneOf"
+]);
+var TYPES = /* @__PURE__ */ new Set(["object", "array", "string", "number", "integer", "boolean", "null"]);
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function nonnegativeInteger(value) {
+  return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+function schemaList(value, field) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error(`${field} must be a non-empty array.`);
+  }
+  return value.map((candidate, index) => {
+    const child = record(candidate);
+    if (!child) throw new Error(`${field}[${index}] must be an object.`);
+    return child;
+  });
+}
+function assertJsonSchema(schema, field = "params_schema") {
+  const value = record(schema);
+  if (!value) throw new Error(`${field} must be an object.`);
+  for (const key of Object.keys(value)) {
+    if (!SCHEMA_KEYS.has(key)) throw new Error(`${field} uses unsupported keyword "${key}".`);
+  }
+  if (value.type !== void 0 && (typeof value.type !== "string" || !TYPES.has(value.type))) {
+    throw new Error(`${field}.type is invalid.`);
+  }
+  if (value.enum !== void 0 && (!Array.isArray(value.enum) || value.enum.length === 0)) {
+    throw new Error(`${field}.enum must be a non-empty array.`);
+  }
+  for (const name of ["minimum", "maximum"]) {
+    if (value[name] !== void 0 && (typeof value[name] !== "number" || !Number.isFinite(value[name]))) {
+      throw new Error(`${field}.${name} must be a finite number.`);
+    }
+  }
+  if (typeof value.minimum === "number" && typeof value.maximum === "number" && value.minimum > value.maximum) {
+    throw new Error(`${field}.minimum must not exceed maximum.`);
+  }
+  for (const name of ["minLength", "maxLength", "minItems", "maxItems"]) {
+    if (value[name] !== void 0 && !nonnegativeInteger(value[name])) {
+      throw new Error(`${field}.${name} must be a nonnegative integer.`);
+    }
+  }
+  if (typeof value.minLength === "number" && typeof value.maxLength === "number" && value.minLength > value.maxLength) {
+    throw new Error(`${field}.minLength must not exceed maxLength.`);
+  }
+  if (typeof value.minItems === "number" && typeof value.maxItems === "number" && value.minItems > value.maxItems) {
+    throw new Error(`${field}.minItems must not exceed maxItems.`);
+  }
+  for (const name of ["$schema", "title", "description", "preview_url"]) {
+    if (value[name] !== void 0 && typeof value[name] !== "string") {
+      throw new Error(`${field}.${name} must be a string.`);
+    }
+  }
+  if (value.properties !== void 0) {
+    const properties = record(value.properties);
+    if (!properties) throw new Error(`${field}.properties must be an object.`);
+    for (const [name, child] of Object.entries(properties)) {
+      assertJsonSchema(child, `${field}.properties.${name}`);
+    }
+  }
+  if (value.required !== void 0 && (!Array.isArray(value.required) || value.required.some((name) => typeof name !== "string"))) {
+    throw new Error(`${field}.required must be an array of strings.`);
+  }
+  if (value.additionalProperties !== void 0 && typeof value.additionalProperties !== "boolean") {
+    throw new Error(`${field}.additionalProperties must be a boolean.`);
+  }
+  if (value.items !== void 0 && value.items !== false) {
+    assertJsonSchema(value.items, `${field}.items`);
+  }
+  if (value.prefixItems !== void 0) {
+    if (!Array.isArray(value.prefixItems)) throw new Error(`${field}.prefixItems must be an array.`);
+    value.prefixItems.forEach((child, index) => assertJsonSchema(child, `${field}.prefixItems[${index}]`));
+  }
+  for (const name of ["anyOf", "oneOf"]) {
+    if (value[name] === void 0) continue;
+    schemaList(value[name], `${field}.${name}`).forEach(
+      (child, index) => assertJsonSchema(child, `${field}.${name}[${index}]`)
+    );
+  }
+  if ("default" in value) {
+    const result = validate(value, value.default, field);
+    if (!result.ok) throw new Error(`${field}.default is invalid: ${result.issue.message}`);
+  }
+}
+function issue(field, message) {
+  return { ok: false, issue: { field, message } };
+}
+function typeMatches(type, value) {
+  switch (type) {
+    case "object":
+      return record(value) !== void 0;
+    case "array":
+      return Array.isArray(value);
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "integer":
+      return typeof value === "number" && Number.isSafeInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    default:
+      return false;
+  }
+}
+function validate(schema, input, field) {
+  if (typeof schema.type === "string" && !typeMatches(schema.type, input)) {
+    return issue(field, `Expected ${schema.type}.`);
+  }
+  if (schema.const !== void 0 && !isDeepStrictEqual(input, schema.const)) {
+    return issue(field, `Expected ${JSON.stringify(schema.const)}.`);
+  }
+  if (Array.isArray(schema.enum) && !schema.enum.some((candidate) => isDeepStrictEqual(input, candidate))) {
+    return issue(field, `Expected one of ${schema.enum.map((value) => JSON.stringify(value)).join(", ")}.`);
+  }
+  if (typeof input === "number") {
+    if (typeof schema.minimum === "number" && input < schema.minimum) {
+      return issue(field, `Must be at least ${schema.minimum}.`);
+    }
+    if (typeof schema.maximum === "number" && input > schema.maximum) {
+      return issue(field, `Must be at most ${schema.maximum}.`);
+    }
+  }
+  if (typeof input === "string") {
+    const length = Array.from(input).length;
+    if (typeof schema.minLength === "number" && length < schema.minLength) {
+      return issue(field, `Must contain at least ${schema.minLength} characters.`);
+    }
+    if (typeof schema.maxLength === "number" && length > schema.maxLength) {
+      return issue(field, `Must contain at most ${schema.maxLength} characters.`);
+    }
+  }
+  let output = input;
+  if (Array.isArray(input)) {
+    if (typeof schema.minItems === "number" && input.length < schema.minItems) {
+      return issue(field, `Must contain at least ${schema.minItems} items.`);
+    }
+    if (typeof schema.maxItems === "number" && input.length > schema.maxItems) {
+      return issue(field, `Must contain at most ${schema.maxItems} items.`);
+    }
+    const prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems : [];
+    const values = [...input];
+    for (let index = 0; index < values.length; index += 1) {
+      const child = prefixItems[index] ?? record(schema.items);
+      if (!child) {
+        if (schema.items === false && index >= prefixItems.length) {
+          return issue(`${field}[${index}]`, "Unexpected item.");
+        }
+        continue;
+      }
+      const result = validate(child, values[index], `${field}[${index}]`);
+      if (!result.ok) return result;
+      values[index] = result.value;
+    }
+    output = values;
+  }
+  const object2 = record(input);
+  if (object2) {
+    const properties = record(schema.properties) ?? {};
+    const values = { ...object2 };
+    for (const [name, childValue] of Object.entries(properties)) {
+      const child = childValue;
+      if (!(name in values) && "default" in child) values[name] = structuredClone(child.default);
+      if (!(name in values)) continue;
+      const result = validate(child, values[name], `${field}.${name}`);
+      if (!result.ok) return result;
+      values[name] = result.value;
+    }
+    for (const name of schema.required ?? []) {
+      if (!(name in values)) return issue(`${field}.${name}`, "Required value is missing.");
+    }
+    if (schema.additionalProperties === false) {
+      const unexpected = Object.keys(values).find((name) => !(name in properties));
+      if (unexpected) return issue(`${field}.${unexpected}`, "Unknown parameter.");
+    }
+    output = values;
+  }
+  for (const name of ["anyOf", "oneOf"]) {
+    if (schema[name] === void 0) continue;
+    const matches = schemaList(schema[name], name).map((candidate) => validate(candidate, output, field)).filter((result) => result.ok);
+    if (matches.length === 0) return issue(field, "Does not match any allowed value.");
+    if (name === "oneOf" && matches.length !== 1) {
+      return issue(field, "Matches more than one allowed value.");
+    }
+    output = matches[0].value;
+  }
+  return { ok: true, value: output };
+}
+function validateJsonSchema(schema, input) {
+  return validate(schema, input, "params");
+}
+// src/commands/create.ts
+var defaults2 = {
+  client: authenticatedToolClient,
+  write: (text2) => process.stdout.write(`${text2}
+`),
+  id: randomUUID2
+};
+var USAGE = "Usage: makefx create --space ACCOUNT/SPACE --kind image|video|audio --model MODEL [--prompt TEXT] [--ref ASSET:SLOT]... [--param NAME=VALUE]... [--count 1..8] [--name TEXT] [--seed INTEGER] [--position JSON] [--tags JSON] [--note TEXT] [--from-asset ASSET] [--recipe-mode current|exact] [--request-id ID] [--wait] [--json]";
+var CREATE_OPTIONS = /* @__PURE__ */ new Set([
+  "env",
+  "local",
+  "json",
+  "help",
+  "space",
+  "kind",
+  "model",
+  "prompt",
+  "ref",
+  "param",
+  "count",
+  "name",
+  "seed",
+  "position",
+  "tags",
+  "note",
+  "from-asset",
+  "recipe-mode",
+  "request-id",
+  "wait"
+]);
+function required2(parsed, name) {
+  const value = parsed.options[name];
+  if (!value || value === "true") throw new CliUsageError(`create requires --${name} <value>.`);
+  return value;
+}
+function optional2(parsed, name) {
+  const value = parsed.options[name];
+  if (value === "true") throw new CliUsageError(`--${name} requires a value.`);
+  return value;
+}
+function rejectUnexpected2(parsed) {
+  if (parsed.positionals.length > 0) {
+    throw new CliUsageError(`create does not accept "${parsed.positionals[0]}". ${USAGE}`);
+  }
+  const unexpected = Object.keys(parsed.options).find((name) => !CREATE_OPTIONS.has(name));
+  if (unexpected) throw new CliUsageError(`Unknown option --${unexpected}. ${USAGE}`);
+}
+function rejectFlagValues(parsed) {
+  for (const name of ["local", "json", "help", "wait"]) {
+    const value = parsed.options[name];
+    if (value !== void 0 && value !== "true") {
+      throw new CliUsageError(`--${name} does not accept a value. ${USAGE}`);
+    }
+  }
+}
+function pair(value, option3) {
+  const at = value.lastIndexOf(":");
+  if (at <= 0 || at === value.length - 1) throw new CliUsageError(`${option3} must be written as value:name.`);
+  return [value.slice(0, at), value.slice(at + 1)];
+}
+function parameter(value) {
+  const at = value.indexOf("=");
+  if (at <= 0) throw new CliUsageError("--param must be written as name=value.");
+  return [value.slice(0, at), scalar(value.slice(at + 1))];
+}
+function integer(parsed, name) {
+  const value = optional2(parsed, name);
+  if (value === void 0) return void 0;
+  if (value.trim() === "") throw new CliUsageError(`--${name} must be an integer.`);
+  const number = Number(value);
+  if (!Number.isSafeInteger(number)) throw new CliUsageError(`--${name} must be an integer.`);
+  return number;
+}
+function json(parsed, name) {
+  const value = optional2(parsed, name);
+  if (value === void 0) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new CliUsageError(`--${name} must be valid JSON.`);
+  }
+}
+function positionOption(parsed) {
+  const value = json(parsed, "position");
+  if (value === void 0) return void 0;
+  if (value === null || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => key !== "x" && key !== "y") || typeof value.x !== "number" || !Number.isFinite(value.x) || typeof value.y !== "number" || !Number.isFinite(value.y)) {
+    throw new CliUsageError("--position must be a JSON object with finite numeric x and y.");
+  }
+  return value;
+}
+function tagsOption(parsed) {
+  const value = json(parsed, "tags");
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.length > 16 || !value.every((tag) => typeof tag === "string" && tag.length <= 40)) {
+    throw new CliUsageError("--tags must be a JSON array of at most 16 strings up to 40 characters.");
+  }
+  return value;
+}
+function scalar(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (/^-?(?:\d+\.?\d*|\.\d+)$/.test(value)) return Number(value);
+  if (value.startsWith("[") || value.startsWith("{")) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      throw new CliUsageError("--param arrays and objects must be valid JSON.");
+    }
+  }
+  return value;
+}
+function prepareCreate(parsed) {
+  rejectUnexpected2(parsed);
+  rejectFlagValues(parsed);
+  optional2(parsed, "env");
+  const kind = required2(parsed, "kind");
+  if (!["image", "video", "audio"].includes(kind)) {
+    throw new CliUsageError("--kind must be image, video, or audio.");
+  }
+  const model = required2(parsed, "model");
+  const references = (parsed.values.ref ?? []).map((value, order) => {
+    const [asset_id, slot] = pair(value, "--ref");
+    if (asset_id.length > 64 || slot.length > 64) {
+      throw new CliUsageError("--ref asset and slot must each be at most 64 characters.");
+    }
+    return { asset_id, slot, order };
+  });
+  if (references.length > 64) throw new CliUsageError("create accepts at most 64 --ref values.");
+  const count = parsed.options.count === void 0 ? 1 : Number(parsed.options.count);
+  if (!Number.isSafeInteger(count) || count < 1 || count > 8)
+    throw new CliUsageError("--count must be an integer from 1 to 8.");
+  const recipeMode = optional2(parsed, "recipe-mode");
+  if (recipeMode !== void 0 && recipeMode !== "current" && recipeMode !== "exact") {
+    throw new CliUsageError("--recipe-mode must be current or exact.");
+  }
+  const fromAssetId = optional2(parsed, "from-asset");
+  if (recipeMode === "exact" && !fromAssetId) {
+    throw new CliUsageError("--recipe-mode exact requires --from-asset <asset>.");
+  }
+  const name = optional2(parsed, "name");
+  if (name !== void 0 && (!name.trim() || name.length > 120)) {
+    throw new CliUsageError("--name must be 1 to 120 characters and not blank.");
+  }
+  const seed = integer(parsed, "seed");
+  const position = positionOption(parsed);
+  const tags = tagsOption(parsed);
+  const note = optional2(parsed, "note");
+  if (note !== void 0 && note.length > 4e3) {
+    throw new CliUsageError("--note must be at most 4000 characters.");
+  }
+  const requestId = optional2(parsed, "request-id");
+  if (requestId !== void 0 && requestId.length > 64) {
+    throw new CliUsageError("--request-id must be at most 64 characters.");
+  }
+  const prompt = optional2(parsed, "prompt") ?? "";
+  if (prompt.length > 8e3) throw new CliUsageError("--prompt must be at most 8000 characters.");
+  return {
+    spaceId: required2(parsed, "space"),
+    kind,
+    model,
+    prompt,
+    references,
+    params: Object.fromEntries((parsed.values.param ?? []).map(parameter)),
+    count,
+    ...recipeMode === void 0 ? {} : { recipeMode },
+    ...fromAssetId && fromAssetId !== "true" ? { fromAssetId } : {},
+    ...name ? { name } : {},
+    ...seed !== void 0 ? { seed } : {},
+    ...position !== void 0 ? { position } : {},
+    tags,
+    ...note !== void 0 ? { note } : {},
+    ...requestId ? { requestId } : {}
+  };
+}
+function catalogModels(document) {
+  if (typeof document.credit_eur !== "number" || !Number.isFinite(document.credit_eur) || document.credit_eur <= 0) {
+    throw new Error("list_models returned a malformed catalog: credit_eur must be a positive number.");
+  }
+  if (!Array.isArray(document.actions)) {
+    throw new Error("list_models returned a malformed catalog: actions must be an array.");
+  }
+  if (!Array.isArray(document.models))
+    throw new Error("list_models returned a malformed catalog: models must be an array.");
+  const ids = /* @__PURE__ */ new Set();
+  return document.models.map((value, index) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error(`list_models returned a malformed catalog: models[${index}] must be an object.`);
+    }
+    const model = value;
+    if (typeof model.id !== "string" || model.id.length === 0) {
+      throw new Error(`list_models returned a malformed catalog: models[${index}].id must be a string.`);
+    }
+    if (ids.has(model.id))
+      throw new Error(`list_models returned a malformed catalog: duplicate model "${model.id}".`);
+    ids.add(model.id);
+    if (!["image", "video", "audio"].includes(String(model.kind))) {
+      throw new Error(`list_models returned a malformed catalog: model "${model.id}" has an invalid kind.`);
+    }
+    if (!["available", "preview", "unavailable"].includes(String(model.availability))) {
+      throw new Error(
+        `list_models returned a malformed catalog: model "${model.id}" has invalid availability.`
+      );
+    }
+    if (typeof model.hidden !== "boolean") {
+      throw new Error(`list_models returned a malformed catalog: model "${model.id}" has no hidden flag.`);
+    }
+    try {
+      assertJsonSchema(model.params_schema, `model "${model.id}" params_schema`);
+      if (model.params_schema.type !== "object") {
+        throw new Error(`model "${model.id}" params_schema.type must be object.`);
+      }
+    } catch (error) {
+      throw new Error(
+        `list_models returned a malformed catalog: ${error instanceof Error ? error.message : "invalid params_schema."}`
+      );
+    }
+    return {
+      id: model.id,
+      kind: model.kind,
+      availability: model.availability,
+      hidden: model.hidden,
+      paramsSchema: model.params_schema
+    };
+  });
+}
+function createToolArguments(prepared, entry, requestId) {
+  if (entry.kind !== prepared.kind) {
+    throw new CliUsageError(`Model "${prepared.model}" creates ${entry.kind} assets, not ${prepared.kind}.`);
+  }
+  if (entry.availability === "unavailable" && prepared.recipeMode !== "exact") {
+    throw new CliUsageError(
+      `Model "${prepared.model}" is unavailable. Run models --space ${prepared.spaceId} to list the catalog.`
+    );
+  }
+  const validation = validateJsonSchema(entry.paramsSchema, prepared.params);
+  if (!validation.ok) {
+    const field = validation.issue.field.replace(/^params\.?/, "") || "params";
+    throw new CliUsageError(`Invalid --param ${field}: ${validation.issue.message}`);
+  }
+  return {
+    space_id: prepared.spaceId,
+    kind: prepared.kind,
+    model: prepared.model,
+    prompt: prepared.prompt,
+    references: prepared.references,
+    params: validation.value,
+    count: prepared.count,
+    ...prepared.recipeMode === void 0 ? {} : { recipe_mode: prepared.recipeMode },
+    ...prepared.fromAssetId ? { from_asset_id: prepared.fromAssetId } : {},
+    ...prepared.name ? { name: prepared.name } : {},
+    ...prepared.seed !== void 0 ? { seed: prepared.seed } : {},
+    ...prepared.position !== void 0 ? { position: prepared.position } : {},
+    tags: prepared.tags,
+    ...prepared.note !== void 0 ? { note: prepared.note } : {},
+    request_id: prepared.requestId ?? requestId
+  };
+}
+async function handleCreate(parsed, dependencies = defaults2) {
+  const prepared = prepareCreate(parsed);
+  const client = await dependencies.client(parsed);
+  const catalog = await client.call("list_models", { space_id: prepared.spaceId });
+  const entry = catalogModels(catalog).find(({ id, hidden }) => id === prepared.model && !hidden);
+  if (!entry) {
+    throw new CliUsageError(
+      `Unknown model "${prepared.model}". Run models --space ${prepared.spaceId} to list the catalog.`
+    );
+  }
+  const args = createToolArguments(prepared, entry, dependencies.id());
+  const created = await client.call("create_asset", args);
+  const assets = Array.isArray(created.assets) ? created.assets : [];
+  if (parsed.options.wait === "true" && !assets.some(({ renders_in }) => renders_in === "browser")) {
+    const spaceId2 = prepared.spaceId;
+    const failures = await Promise.all(
+      assets.map(async (asset) => {
+        const assetId = asset.asset_id;
+        if (typeof assetId !== "string") return null;
+        while (true) {
+          const result = await client.call("get_asset", {
+            space_id: spaceId2,
+            asset_id: assetId,
+            wait_seconds: 60
+          });
+          const current = result.asset;
+          if (current?.status === "ready") return null;
+          if (current?.status === "failed") {
+            const error = current.error;
+            return error?.message ?? `Asset ${assetId} failed.`;
+          }
+        }
+      })
+    );
+    const messages = failures.filter((message) => message !== null);
+    if (messages.length > 0) throw new Error(messages.join("\n"));
+  }
+  if (parsed.options.json === "true") {
+    dependencies.write(JSON.stringify(created, null, 2));
+    return;
+  }
+  for (const asset of assets) {
+    dependencies.write(
+      [asset.asset_id, asset.web_url].filter((value) => typeof value === "string").join(" ")
+    );
+  }
+}
+// src/commands/login.ts
+import process2 from "node:process";
+async function handleLogin(parsed) {
+  const isLocal = parsed.options.local === "true";
+  const env = isLocal ? "local" : parsed.options.env ?? DEFAULT_ENVIRONMENT;
+  const baseUrl = resolveBaseUrl(env);
+  const clientId = DEFAULT_CLIENT_ID;
+  const redirectPort = DEFAULT_REDIRECT_PORT;
+  const insecure = isLocal;
+  if (insecure) {
+    console.log("\u26A0\uFE0F  SSL certificate verification disabled (local dev mode)");
+    process2.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  }
+  console.log(`Starting login for environment "${env}" using ${baseUrl}`);
+  const server = await discoverAuthorizationServer(baseUrl);
+  const state = generateState();
+  const redirectUri = `http://127.0.0.1:${redirectPort}/callback`;
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = await generateCodeChallenge(codeVerifier);
+  const authUrl = new URL(server.authorizationEndpoint);
+  authUrl.searchParams.set("client_id", clientId);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("scope", AUTH_SCOPES);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("code_challenge", codeChallenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("state", state);
+  authUrl.searchParams.set("resource", mcpResourceFor(baseUrl));
+  console.log("Opening browser for Google authentication...");
+  try {
+    await openBrowser(authUrl.toString());
+  } catch {
+    console.warn("Unable to open browser automatically. Please copy the URL below into your browser:");
+    console.log(authUrl.toString());
+  }
+  const { code } = await waitForAuthorizationCode(redirectPort, state);
+  console.log("Received authorization code. Exchanging for access token...");
+  const tokenResponse = await exchangeCodeForToken({
+    baseUrl,
+    tokenEndpoint: server.tokenEndpoint,
+    code,
+    codeVerifier,
+    redirectUri,
+    clientId
+  });
+  const storedConfig = {
+    environment: env,
+    baseUrl,
+    clientId,
+    token: storedTokenFrom(tokenResponse),
+    user: tokenResponse.user ?? null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveConfig(storedConfig);
+  console.log(`Login successful. Credentials saved to ${await getConfigPath()}`);
+  if (!storedConfig.token.refreshToken) {
+    console.log("No refresh token was issued; you will need to log in again when the session expires.");
+  }
+}
+// src/commands/logout.ts
+async function handleLogout(parsed) {
+  const isLocal = parsed.options.local === "true";
+  const environment = isLocal ? "local" : parsed.options.env || void 0;
+  const configs = environment ? [await loadStoredConfig(environment)].filter((config) => config !== null) : await listStoredConfigs();
+  for (const config of configs) {
+    const revoked = await revokeStoredToken(config);
+    console.log(
+      revoked ? `Revoked access for environment "${config.environment}".` : `Could not reach ${config.baseUrl} to revoke access for "${config.environment}"; the grant expires on its own.`
+    );
+  }
+  try {
+    if (environment) {
+      await removeConfig(environment);
+      console.log(`Removed stored credentials for environment "${environment}".`);
+    } else {
+      await removeConfig();
+      console.log("Removed all stored credentials.");
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      console.log("No stored credentials were found.");
+      return;
+    }
+    throw error;
+  }
+}
+// src/commands/mcp.ts
+import process3 from "node:process";
+async function handleMcp(parsed) {
+  const env = parsed.options.local === "true" ? "local" : parsed.options.env ?? DEFAULT_ENVIRONMENT;
+  const loginHint = `Run: ${cliCommand()} login --env ${env}`;
+  const stored = await loadStoredConfig(env);
+  if (!stored) {
+    console.error(`Not logged in for "${env}". ${loginHint}`);
+    process3.exitCode = 1;
+    return;
+  }
+  const config = await ensureFreshConfig(stored);
+  if (!config) {
+    console.error(`Credentials for "${env}" have expired. ${loginHint}`);
+    process3.exitCode = 1;
+    return;
+  }
+  const bridge = createMcpBridge({ config });
+  async function forward(line) {
+    const outcome = await bridge.forward(line);
+    switch (outcome.kind) {
+      case "accepted":
+        return;
+      case "response":
+        if (outcome.text) process3.stdout.write(`${outcome.text}
+`);
+        return;
+      case "unauthorized":
+        if (outcome.text) process3.stdout.write(`${outcome.text}
+`);
+        console.error(`Access to "${env}" was revoked or has expired. ${loginHint}`);
+        process3.exitCode = 1;
+        process3.stdin.destroy();
+        return;
+      case "unreachable":
+        console.error(`MCP request failed: ${outcome.message}`);
+        return;
+    }
+  }
+  let buffer = "";
+  const pending = [];
+  process3.stdin.setEncoding("utf8");
+  for await (const chunk of process3.stdin) {
+    buffer += chunk;
+    let newline = buffer.indexOf("\n");
+    while (newline !== -1) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      if (line) {
+        pending.push(forward(line));
+      }
+      newline = buffer.indexOf("\n");
+    }
+  }
+  await Promise.all(pending);
+}
+// src/commands/mutate.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+var defaults3 = {
+  client: authenticatedToolClient,
+  write: (text2) => process.stdout.write(`${text2}
+`),
+  id: randomUUID3
+};
+var GLOBAL_OPTIONS2 = ["env", "local", "json"];
+var USAGE2 = {
+  "voices sync": "voices sync --account ACCOUNT [--json]",
+  "profile update": "profile update --name TEXT [--json]",
+  "space update": "space update --space ACCOUNT/SPACE --name TEXT [--json]",
+  "asset update": "asset update --space ACCOUNT/SPACE --asset ID [--name TEXT] [--note TEXT|null] [--traits TEXT|null] [--tags JSON] [--starred true|false] [--position JSON] [--recipe JSON] [--json]",
+  "asset delete": "asset delete --space ACCOUNT/SPACE --asset ID [--json]",
+  describe: "describe --space ACCOUNT/SPACE --asset ID [--request-id ID] [--json]",
+  link: "link --space ACCOUNT/SPACE --from ASSET --to ASSET [--label TEXT] [--json]",
+  unlink: "unlink --space ACCOUNT/SPACE (--link ID | --from ASSET --to ASSET [--label TEXT]) [--json]"
+};
+function mutationCommandUsage(command) {
+  return `Usage: makefx ${USAGE2[command]}`;
+}
+function required3(parsed, name, command) {
+  const value = parsed.options[name];
+  if (!value || value === "true") throw new CliUsageError(`${command} requires --${name} <value>.`);
+  return value;
+}
+function optional3(parsed, name) {
+  const value = parsed.options[name];
+  if (value === "true") throw new CliUsageError(`--${name} requires a value.`);
+  return value;
+}
+function rejectUnexpected3(parsed, command, options) {
+  if (parsed.positionals.length > 0) {
+    throw new CliUsageError(
+      `${command} does not accept "${parsed.positionals[0]}". ${mutationCommandUsage(command)}`
+    );
+  }
+  const allowed = /* @__PURE__ */ new Set([...GLOBAL_OPTIONS2, ...options]);
+  const unexpected = Object.keys(parsed.options).find((option3) => !allowed.has(option3));
+  if (unexpected) {
+    throw new CliUsageError(`Unknown option --${unexpected}. ${mutationCommandUsage(command)}`);
+  }
+}
+function jsonOption(parsed, name) {
+  const value = optional3(parsed, name);
+  if (value === void 0) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new CliUsageError(`--${name} must be valid JSON.`);
+  }
+}
+function nullableText(parsed, name) {
+  const value = optional3(parsed, name);
+  return value === "null" ? null : value;
+}
+function booleanOption(parsed, name) {
+  const value = parsed.options[name];
+  if (value === void 0) return void 0;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  throw new CliUsageError(`--${name} must be true or false.`);
+}
+function objectOption(parsed, name) {
+  const value = jsonOption(parsed, name);
+  if (value === void 0) return void 0;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new CliUsageError(`--${name} must be a JSON object.`);
+  }
+  return value;
+}
+function tagsOption2(parsed) {
+  const value = jsonOption(parsed, "tags");
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || !value.every((tag) => typeof tag === "string")) {
+    throw new CliUsageError("--tags must be a JSON array of strings.");
+  }
+  return value;
+}
+function mutationToolCall(command, parsed, requestId) {
+  switch (command) {
+    case "voices sync":
+      rejectUnexpected3(parsed, command, ["account"]);
+      return { name: "sync_voices", args: { account_id: required3(parsed, "account", command) } };
+    case "profile update": {
+      rejectUnexpected3(parsed, command, ["name"]);
+      const name = required3(parsed, "name", command);
+      if (!name.trim()) throw new CliUsageError("profile update requires a non-empty --name.");
+      return { name: "update_profile", args: { name } };
+    }
+    case "space update": {
+      rejectUnexpected3(parsed, command, ["space", "name"]);
+      const name = required3(parsed, "name", command);
+      if (!name.trim()) throw new CliUsageError("space update requires a non-empty --name.");
+      return { name: "update_space", args: { space_id: required3(parsed, "space", command), name } };
+    }
+    case "asset update": {
+      rejectUnexpected3(parsed, command, [
+        "space",
+        "asset",
+        "name",
+        "note",
+        "traits",
+        "tags",
+        "starred",
+        "position",
+        "recipe"
+      ]);
+      const name = optional3(parsed, "name");
+      const note = nullableText(parsed, "note");
+      const traits = nullableText(parsed, "traits");
+      const tags = tagsOption2(parsed);
+      const starred = booleanOption(parsed, "starred");
+      const position = objectOption(parsed, "position");
+      const recipe = objectOption(parsed, "recipe");
+      return {
+        name: "update_asset",
+        args: {
+          space_id: required3(parsed, "space", command),
+          asset_id: required3(parsed, "asset", command),
+          ...name !== void 0 ? { name } : {},
+          ...note !== void 0 ? { note } : {},
+          ...traits !== void 0 ? { traits } : {},
+          ...tags !== void 0 ? { tags } : {},
+          ...starred !== void 0 ? { starred } : {},
+          ...position !== void 0 ? { position } : {},
+          ...recipe !== void 0 ? { recipe } : {}
+        }
+      };
+    }
+    case "asset delete":
+      rejectUnexpected3(parsed, command, ["space", "asset"]);
+      return {
+        name: "delete_asset",
+        args: {
+          space_id: required3(parsed, "space", command),
+          asset_id: required3(parsed, "asset", command)
+        }
+      };
+    case "describe":
+      rejectUnexpected3(parsed, command, ["space", "asset", "request-id"]);
+      const describeRequestId = optional3(parsed, "request-id") ?? requestId;
+      if (!describeRequestId) throw new CliUsageError("describe requires a non-empty request id.");
+      return {
+        name: "describe_asset",
+        args: {
+          space_id: required3(parsed, "space", command),
+          asset_id: required3(parsed, "asset", command),
+          request_id: describeRequestId
+        }
+      };
+    case "link": {
+      rejectUnexpected3(parsed, command, ["space", "from", "to", "label"]);
+      const label = optional3(parsed, "label");
+      return {
+        name: "link_assets",
+        args: {
+          space_id: required3(parsed, "space", command),
+          from_asset_id: required3(parsed, "from", command),
+          to_asset_id: required3(parsed, "to", command),
+          ...label !== void 0 ? { label } : {}
+        }
+      };
+    }
+    case "unlink": {
+      rejectUnexpected3(parsed, command, ["space", "link", "from", "to", "label"]);
+      const linkId = optional3(parsed, "link");
+      const from = optional3(parsed, "from");
+      const to = optional3(parsed, "to");
+      const label = optional3(parsed, "label");
+      if (linkId && (from !== void 0 || to !== void 0 || label !== void 0)) {
+        throw new CliUsageError(
+          `unlink accepts --link or --from/--to, not both. ${mutationCommandUsage(command)}`
+        );
+      }
+      if (!linkId && (!from || !to)) {
+        throw new CliUsageError(
+          `unlink requires --link or both --from and --to. ${mutationCommandUsage(command)}`
+        );
+      }
+      return {
+        name: "unlink_assets",
+        args: {
+          space_id: required3(parsed, "space", command),
+          ...linkId ? { link_id: linkId } : {
+            from_asset_id: from,
+            to_asset_id: to,
+            ...label !== void 0 ? { label } : {}
+          }
+        }
+      };
+    }
+  }
+}
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function humanOutput(command, result, args) {
+  if (command === "voices sync") {
+    return `${String(result.account_id)} \xB7 ${String(result.active_voice_count)} active voices \xB7 synced ${new Date(Number(result.synced_at)).toISOString()}`;
+  }
+  if (command === "profile update") {
+    const user = record2(result.user) ?? {};
+    return [user.id, user.email, user.name].filter((value) => typeof value === "string" && value.length > 0).join(" \xB7 ");
+  }
+  if (command === "space update") {
+    const space = record2(result.space) ?? {};
+    return [space.space_id, space.name, space.is_public === true ? "public" : "private", space.web_url].filter((value) => typeof value === "string" && value.length > 0).join(" \xB7 ");
+  }
+  if (command === "asset update") {
+    const asset = record2(result.asset) ?? {};
+    return [asset.asset_id, asset.web_url].filter((value) => typeof value === "string").join(" ");
+  }
+  if (command === "asset delete") return `Deleted ${String(result.asset_id)}`;
+  if (command === "describe") {
+    return [result.asset_id, result.web_url].filter((value) => typeof value === "string").join(" ");
+  }
+  if (command === "link") {
+    const link4 = record2(result.link) ?? {};
+    return [link4.link_id, `${String(link4.from_asset_id)} -> ${String(link4.to_asset_id)}`].filter((value) => typeof value === "string").join(" ");
+  }
+  return typeof args.link_id === "string" ? `Unlinked ${args.link_id}` : `Unlinked ${String(args.from_asset_id)} -> ${String(args.to_asset_id)}`;
+}
+async function handleMutationCommand(command, parsed, dependencies = defaults3) {
+  const requestId = command === "describe" ? parsed.options["request-id"] ?? dependencies.id() : void 0;
+  const call = mutationToolCall(command, parsed, requestId);
+  const client = await dependencies.client(parsed);
+  const result = await client.call(call.name, call.args);
+  if (parsed.options.json === "true") {
+    dependencies.write(JSON.stringify(result, null, 2));
+    return;
+  }
+  dependencies.write(humanOutput(command, result, call.args));
+}
+// src/commands/purchase.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+// src/lib/billing.ts
+var BillingIdentityError = class extends Error {
+  path;
+  constructor(path2, message) {
+    super(message);
+    this.path = path2;
+  }
+};
+var EMAIL_PATTERN = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/;
+function object(value, path2, fields) {
+  if (!isRecord(value)) throw new BillingIdentityError(path2, "must be a JSON object.");
+  const unknown = Object.keys(value).find((key) => !fields.includes(key));
+  if (unknown !== void 0) {
+    throw new BillingIdentityError(path2 ? `${path2}.${unknown}` : unknown, "is not a billing identity field.");
+  }
+  return value;
+}
+function text(record6, key, path2, field) {
+  const name = path2 ? `${path2}.${key}` : key;
+  const value = record6[key];
+  if (value === void 0 && field.optional) return void 0;
+  if (typeof value !== "string") throw new BillingIdentityError(name, "must be a string.");
+  const min = field.min ?? 0;
+  if (value.length < min) throw new BillingIdentityError(name, "must not be empty.");
+  if (value.length > field.max) {
+    throw new BillingIdentityError(name, `must be at most ${field.max} characters.`);
+  }
+  if (field.pattern && !field.pattern.test(value)) {
+    throw new BillingIdentityError(name, `must be ${field.hint}.`);
+  }
+  return value;
+}
+function parseBillingIdentity(value) {
+  const root = object(value, "", ["name", "email", "address", "tax_id"]);
+  const address = object(root.address, "address", ["line1", "line2", "city", "postal_code", "state", "country"]);
+  const identity = {
+    name: text(root, "name", "", { min: 1, max: 200 }),
+    email: text(root, "email", "", { max: 254, pattern: EMAIL_PATTERN, hint: "an email address" }),
+    address: {
+      line1: text(address, "line1", "address", { min: 1, max: 200 }),
+      city: text(address, "city", "address", { min: 1, max: 100 }),
+      postal_code: text(address, "postal_code", "address", { min: 1, max: 30 }),
+      country: text(address, "country", "address", {
+        max: 2,
+        pattern: /^[A-Z]{2}$/,
+        hint: "a two-letter uppercase country code"
+      })
+    }
+  };
+  const line2 = text(address, "line2", "address", { max: 200, optional: true });
+  if (line2 !== void 0) identity.address.line2 = line2;
+  const state = text(address, "state", "address", { max: 100, optional: true });
+  if (state !== void 0) identity.address.state = state;
+  if (root.tax_id !== void 0) {
+    const taxId = object(root.tax_id, "tax_id", ["type", "value"]);
+    if (taxId.type !== "eu_vat") throw new BillingIdentityError("tax_id.type", "must be eu_vat.");
+    identity.tax_id = { type: "eu_vat", value: text(taxId, "value", "tax_id", { min: 1, max: 40 }) };
+  }
+  return identity;
+}
+// src/commands/purchase.ts
+var defaults4 = {
+  client: authenticatedToolClient,
+  read: (path2) => readFile2(path2, "utf8"),
+  write: (text2) => process.stdout.write(`${text2}
+`)
+};
+var USAGE3 = {
+  "purchase create": "purchase create --account ACCOUNT --product eur20|eur100 --request-id ID [--billing JSON|@FILE] [--json]",
+  "purchase get": "purchase get --purchase ID [--json]"
+};
+function purchaseCommandUsage(command) {
+  return `Usage: makefx ${USAGE3[command]}`;
+}
+function option(parsed, name) {
+  const value = parsed.options[name];
+  if (value === "true") throw new CliUsageError(`--${name} requires a value.`);
+  return value;
+}
+function required4(parsed, name, command) {
+  const value = option(parsed, name);
+  if (!value) throw new CliUsageError(`${command} requires --${name} <value>.`);
+  return value;
+}
+function rejectUnexpected4(parsed, command, allowed) {
+  if (parsed.positionals.length > 0) {
+    throw new CliUsageError(
+      `${command} does not accept "${parsed.positionals[0]}". ${purchaseCommandUsage(command)}`
+    );
+  }
+  const options = /* @__PURE__ */ new Set(["env", "local", "json", ...allowed]);
+  const unexpected = Object.keys(parsed.options).find((name) => !options.has(name));
+  if (unexpected) {
+    throw new CliUsageError(`Unknown option --${unexpected}. ${purchaseCommandUsage(command)}`);
+  }
+  for (const flag of ["local", "json"]) {
+    const value = parsed.options[flag];
+    if (value !== void 0 && value !== "true") {
+      throw new CliUsageError(`--${flag} does not accept a value. ${purchaseCommandUsage(command)}`);
+    }
+  }
+  option(parsed, "env");
+}
+function billingIdentity(value) {
+  try {
+    return parseBillingIdentity(value);
+  } catch (error) {
+    if (!(error instanceof BillingIdentityError)) throw error;
+    throw new CliUsageError(`--billing${error.path ? `.${error.path}` : ""} ${error.message}`);
+  }
+}
+async function parseBilling(source, read) {
+  let text2 = source;
+  if (source.startsWith("@")) {
+    if (source.length === 1) throw new CliUsageError("--billing @FILE requires a file path.");
+    text2 = await read(resolve2(source.slice(1)));
+  }
+  let value;
+  try {
+    value = JSON.parse(text2);
+  } catch {
+    throw new CliUsageError("--billing must be valid JSON or @FILE containing JSON.");
+  }
+  return billingIdentity(value);
+}
+async function purchaseToolCall(command, parsed, read = defaults4.read) {
+  if (command === "purchase get") {
+    rejectUnexpected4(parsed, command, ["purchase"]);
+    return { name: "get_credit_purchase", args: { purchase_id: required4(parsed, "purchase", command) } };
+  }
+  rejectUnexpected4(parsed, command, ["account", "product", "request-id", "billing"]);
+  const product = required4(parsed, "product", command);
+  if (product !== "eur20" && product !== "eur100") {
+    throw new CliUsageError("--product must be eur20 or eur100.");
+  }
+  const account = required4(parsed, "account", command);
+  const requestId = required4(parsed, "request-id", command);
+  if (account.length > 64) throw new CliUsageError("--account must be at most 64 characters.");
+  if (requestId.length > 64) throw new CliUsageError("--request-id must be at most 64 characters.");
+  const source = option(parsed, "billing");
+  const billing = source === void 0 ? void 0 : await parseBilling(source, read);
+  return {
+    name: "create_credit_purchase",
+    args: {
+      account_id: account,
+      product,
+      request_id: requestId,
+      ...billing ? { billing } : {}
+    }
+  };
+}
+function humanOutput2(command, result) {
+  const amounts = typeof result.total_amount === "number" && typeof result.currency === "string" ? `${(result.total_amount / 100).toFixed(2)} ${result.currency.toUpperCase()}` : void 0;
+  return [
+    result.purchase_id,
+    result.status,
+    amounts,
+    command === "purchase create" ? result.payment_url : result.invoice_url
+  ].filter((value) => typeof value === "string" && value.length > 0).join(" \xB7 ");
+}
+async function handlePurchaseCommand(command, parsed, dependencies = defaults4) {
+  const call = await purchaseToolCall(command, parsed, dependencies.read);
+  const client = await dependencies.client(parsed);
+  const result = await client.call(call.name, call.args);
+  dependencies.write(
+    parsed.options.json === "true" ? JSON.stringify(result, null, 2) : humanOutput2(command, result)
+  );
+}
+// src/commands/read.ts
+var defaults5 = {
+  client: authenticatedToolClient,
+  write: (text2) => process.stdout.write(`${text2}
+`)
+};
+var GLOBAL_OPTIONS3 = ["env", "local", "json"];
+var USAGE4 = {
+  account: "account [--account ID] [--json]",
+  spaces: "spaces [--account ID] [--query TEXT] [--limit 1..100] [--json]",
+  "space create": "space create --name NAME [--account ID] [--id ID] [--json]",
+  "space get": "space get --space ACCOUNT/SPACE [--starred-only] [--json]",
+  "space delete": "space delete --space ACCOUNT/SPACE [--json]",
+  models: "models [--space ACCOUNT/SPACE] [--kind image|video|audio] [--family provider|internal|browser] [--json]",
+  "profile get": "profile get [--json]",
+  health: "health [--json]",
+  estimate: "estimate --kind KIND --model MODEL [--space ACCOUNT/SPACE] [--prompt TEXT] [--ref ASSET:SLOT]... [--param NAME=VALUE]... [--count 1..8] [--from-asset ASSET] [--recipe-mode current|exact] [--json]",
+  "asset get": "asset get --space ACCOUNT/SPACE --asset ID [--wait-seconds 0..60] [--json]"
+};
+function commandUsage(command) {
+  return `Usage: makefx ${USAGE4[command]}`;
+}
+function required5(parsed, name, command) {
+  const value = parsed.options[name];
+  if (!value || value === "true") throw new CliUsageError(`${command} requires --${name} <value>.`);
+  return value;
+}
+function rejectUnexpected5(parsed, command, options) {
+  if (parsed.positionals.length > 0) {
+    throw new CliUsageError(
+      `${command} does not accept "${parsed.positionals[0]}". ${commandUsage(command)}`
+    );
+  }
+  const allowed = /* @__PURE__ */ new Set([...GLOBAL_OPTIONS3, ...options]);
+  const unexpected = Object.keys(parsed.options).find((option3) => !allowed.has(option3));
+  if (unexpected) throw new CliUsageError(`Unknown option --${unexpected}. ${commandUsage(command)}`);
+}
+function optional4(parsed, name) {
+  const value = parsed.options[name];
+  if (value === "true") throw new CliUsageError(`--${name} requires a value.`);
+  return value;
+}
+function integerOption(parsed, name, min, max) {
+  const value = optional4(parsed, name);
+  if (value === void 0) return void 0;
+  const number = Number(value);
+  if (!Number.isSafeInteger(number) || number < min || number > max) {
+    throw new CliUsageError(`--${name} must be an integer from ${min} to ${max}.`);
+  }
+  return number;
+}
+function pair2(value) {
+  const at = value.lastIndexOf(":");
+  if (at <= 0 || at === value.length - 1) throw new CliUsageError("--ref must be written as asset:slot.");
+  return { asset_id: value.slice(0, at), slot: value.slice(at + 1) };
+}
+function scalar2(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (/^-?(?:\d+\.?\d*|\.\d+)$/.test(value)) return Number(value);
+  if (value.startsWith("[") || value.startsWith("{")) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      throw new CliUsageError("--param arrays and objects must be valid JSON.");
+    }
+  }
+  return value;
+}
+function parameter2(value) {
+  const at = value.indexOf("=");
+  if (at <= 0) throw new CliUsageError("--param must be written as name=value.");
+  return [value.slice(0, at), scalar2(value.slice(at + 1))];
+}
+function mediaKind(parsed, command) {
+  const kind = required5(parsed, "kind", command);
+  if (!["image", "video", "audio"].includes(kind)) {
+    throw new CliUsageError("--kind must be image, video, or audio.");
+  }
+  return kind;
+}
+function dataToolCall(command, parsed) {
+  switch (command) {
+    case "account": {
+      rejectUnexpected5(parsed, command, ["account"]);
+      const account = optional4(parsed, "account");
+      return { name: "get_account", args: account ? { account_id: account } : {} };
+    }
+    case "spaces": {
+      rejectUnexpected5(parsed, command, ["account", "query", "limit"]);
+      const account = optional4(parsed, "account");
+      const query = optional4(parsed, "query");
+      const limit = integerOption(parsed, "limit", 1, 100);
+      return {
+        name: "list_spaces",
+        args: {
+          ...account ? { account_id: account } : {},
+          ...query ? { query } : {},
+          ...limit ? { limit } : {}
+        }
+      };
+    }
+    case "space create": {
+      rejectUnexpected5(parsed, command, ["name", "account", "id"]);
+      const account = optional4(parsed, "account");
+      const id = optional4(parsed, "id");
+      return {
+        name: "create_space",
+        args: {
+          name: required5(parsed, "name", command),
+          ...account ? { account_id: account } : {},
+          ...id ? { space_id: id } : {}
+        }
+      };
+    }
+    case "space get":
+      rejectUnexpected5(parsed, command, ["space", "starred-only"]);
+      return {
+        name: "get_space",
+        args: {
+          space_id: required5(parsed, "space", command),
+          starred_only: parsed.options["starred-only"] === "true"
+        }
+      };
+    case "space delete":
+      rejectUnexpected5(parsed, command, ["space"]);
+      return { name: "delete_space", args: { space_id: required5(parsed, "space", command) } };
+    case "models": {
+      rejectUnexpected5(parsed, command, ["space", "kind", "family"]);
+      const space = optional4(parsed, "space");
+      const kind = optional4(parsed, "kind");
+      const family = optional4(parsed, "family");
+      if (kind && !["image", "video", "audio"].includes(kind)) {
+        throw new CliUsageError("--kind must be image, video, or audio.");
+      }
+      if (family && !["provider", "internal", "browser"].includes(family)) {
+        throw new CliUsageError("--family must be provider, internal, or browser.");
+      }
+      return {
+        name: "list_models",
+        args: {
+          ...space ? { space_id: space } : {},
+          ...kind ? { kind } : {},
+          ...family ? { family } : {}
+        }
+      };
+    }
+    case "profile get":
+      rejectUnexpected5(parsed, command, []);
+      return { name: "get_profile", args: {} };
+    case "health":
+      rejectUnexpected5(parsed, command, []);
+      return { name: "health_check", args: {} };
+    case "estimate": {
+      rejectUnexpected5(parsed, command, [
+        "space",
+        "kind",
+        "model",
+        "prompt",
+        "ref",
+        "param",
+        "count",
+        "from-asset",
+        "recipe-mode"
+      ]);
+      const space = optional4(parsed, "space");
+      const count = integerOption(parsed, "count", 1, 8);
+      const recipeMode = parsed.options["recipe-mode"];
+      if (recipeMode !== void 0 && recipeMode !== "current" && recipeMode !== "exact") {
+        throw new CliUsageError("--recipe-mode must be current or exact.");
+      }
+      const fromAssetId = parsed.options["from-asset"];
+      if (recipeMode === "exact" && (!fromAssetId || fromAssetId === "true")) {
+        throw new CliUsageError("--recipe-mode exact requires --from-asset <asset>.");
+      }
+      return {
+        name: "estimate_credits",
+        args: {
+          ...space ? { space_id: space } : {},
+          kind: mediaKind(parsed, command),
+          model: required5(parsed, "model", command),
+          prompt: optional4(parsed, "prompt") ?? "",
+          references: (parsed.values.ref ?? []).map(pair2),
+          params: Object.fromEntries((parsed.values.param ?? []).map(parameter2)),
+          count: count ?? 1,
+          ...recipeMode === void 0 ? {} : { recipe_mode: recipeMode },
+          ...fromAssetId && fromAssetId !== "true" ? { from_asset_id: fromAssetId } : {}
+        }
+      };
+    }
+    case "asset get":
+      rejectUnexpected5(parsed, command, ["space", "asset", "wait-seconds"]);
+      return {
+        name: "get_asset",
+        args: {
+          space_id: required5(parsed, "space", command),
+          asset_id: required5(parsed, "asset", command),
+          wait_seconds: integerOption(parsed, "wait-seconds", 0, 60) ?? 0
+        }
+      };
+  }
+}
+function record3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function humanOutput3(command, result) {
+  if (command === "account") {
+    const topup = typeof result.topup_url === "string" ? [`Top up: ${result.topup_url}`] : [];
+    return [
+      `${String(result.account_id)} ${String(result.balance_credits)} credits (${String(result.held_credits)} held)`,
+      ...topup
+    ];
+  }
+  if (command === "spaces") {
+    const spaces = Array.isArray(result.spaces) ? result.spaces : [];
+    if (spaces.length === 0) return ["No spaces."];
+    return spaces.map((value) => {
+      const space = record3(value) ?? {};
+      return [space.space_id, space.web_url].filter((item) => typeof item === "string").join(" ");
+    });
+  }
+  if (command === "models") {
+    const models = Array.isArray(result.models) ? result.models : [];
+    return models.map((value) => record3(value) ?? {}).filter((model) => model.hidden !== true).map(
+      (model) => [model.label, model.provider_model, model.provider, model.provider_model_kind, model.id].filter((item) => typeof item === "string").join(" \xB7 ")
+    );
+  }
+  if (command === "profile get") {
+    return [
+      [result.id, result.email, result.name].filter((item) => typeof item === "string" && item.length > 0).join(" \xB7 ")
+    ];
+  }
+  if (command === "health") {
+    return [
+      [result.status, result.environment].filter((item) => typeof item === "string" && item.length > 0).join(" \xB7 ")
+    ];
+  }
+  if (command === "estimate") {
+    const topup = typeof result.topup_url === "string" ? [`Top up: ${result.topup_url}`] : [];
+    return [`${String(result.credits)} credits (${String(result.balance_after_credits)} after)`, ...topup];
+  }
+  if (command === "space create") {
+    const space = record3(result.space) ?? {};
+    return [[space.space_id, space.web_url].filter((item) => typeof item === "string").join(" ")];
+  }
+  if (command === "space get") {
+    const space = record3(result.space) ?? {};
+    const assets = Array.isArray(result.assets) ? result.assets.length : 0;
+    const links = Array.isArray(result.links) ? result.links.length : 0;
+    return [
+      [space.space_id, result.web_url].filter((item) => typeof item === "string").join(" "),
+      `${assets} assets, ${links} links`
+    ];
+  }
+  if (command === "space delete") return [`Deleted ${String(result.space_id)} ${String(result.web_url)}`];
+  const asset = record3(result.asset) ?? {};
+  return [
+    [asset.asset_id, asset.status, result.web_url].filter((item) => typeof item === "string").join(" ")
+  ];
+}
+async function handleDataCommand(command, parsed, dependencies = defaults5) {
+  const call = dataToolCall(command, parsed);
+  const client = await dependencies.client(parsed);
+  const result = await client.call(call.name, call.args);
+  if (parsed.options.json === "true") {
+    dependencies.write(JSON.stringify(result, null, 2));
+    return;
+  }
+  for (const line of humanOutput3(command, result)) dependencies.write(line);
+}
+// src/commands/transfer.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { link as link2, lstat as lstat2, open as open3, unlink as unlink2 } from "node:fs/promises";
+import { basename, extname, resolve as resolve3 } from "node:path";
+import { Readable, Transform } from "node:stream";
+import { finished, pipeline } from "node:stream/promises";
+var defaults6 = {
+  client: authenticatedToolClient,
+  fetch,
+  write: (text2) => process.stdout.write(`${text2}
+`),
+  id: randomUUID4
+};
+var MIME_BY_EXTENSION = {
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".png": "image/png",
+  ".wav": "audio/wav"
+};
+var EXTENSION_BY_MIME = {
+  "audio/mpeg": ".mp3",
+  "audio/wav": ".wav",
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "video/mp4": ".mp4"
+};
+var GLOBAL_OPTIONS4 = ["env", "local", "json"];
+var USAGE5 = {
+  upload: "upload --space ACCOUNT/SPACE --kind image|video|audio --file PATH [--mime TYPE] [--name TEXT] [--provider NAME] [--model ORIGIN] [--prompt TEXT] [--param NAME=VALUE]... [--ref ASSET:SLOT]... [--external-run-id ID] [--position JSON] [--tags JSON] [--request-id ID] [--json]",
+  download: "download ASSET --space ACCOUNT/SPACE [--out PATH] [--json]"
+};
+function transferCommandUsage(command) {
+  return `Usage: makefx ${USAGE5[command]}`;
+}
+function required6(parsed, name, command) {
+  const value = parsed.options[name];
+  if (!value || value === "true") throw new CliUsageError(`${command} requires --${name} <value>.`);
+  return value;
+}
+function optional5(parsed, name) {
+  const value = parsed.options[name];
+  if (value === "true") throw new CliUsageError(`--${name} requires a value.`);
+  return value;
+}
+function rejectUnexpected6(parsed, command, options) {
+  const allowed = /* @__PURE__ */ new Set([...GLOBAL_OPTIONS4, ...options]);
+  const unexpected = Object.keys(parsed.options).find((option3) => !allowed.has(option3));
+  if (unexpected) throw new CliUsageError(`Unknown option --${unexpected}. ${transferCommandUsage(command)}`);
+}
+function scalar3(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (/^-?(?:\d+\.?\d*|\.\d+)$/.test(value)) return Number(value);
+  if (value.startsWith("[") || value.startsWith("{")) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      throw new CliUsageError("--param arrays and objects must be valid JSON.");
+    }
+  }
+  return value;
+}
+function parameter3(value) {
+  const at = value.indexOf("=");
+  if (at <= 0) throw new CliUsageError("--param must be written as name=value.");
+  return [value.slice(0, at), scalar3(value.slice(at + 1))];
+}
+function objectOption2(parsed, name) {
+  const value = optional5(parsed, name);
+  if (value === void 0) return void 0;
+  try {
+    const parsedValue = JSON.parse(value);
+    if (parsedValue === null || typeof parsedValue !== "object" || Array.isArray(parsedValue))
+      throw new Error();
+    return parsedValue;
+  } catch {
+    throw new CliUsageError(`--${name} must be a JSON object.`);
+  }
+}
+function tagsOption3(parsed) {
+  const value = optional5(parsed, "tags");
+  if (value === void 0) return void 0;
+  try {
+    const tags = JSON.parse(value);
+    if (!Array.isArray(tags) || !tags.every((tag) => typeof tag === "string")) throw new Error();
+    return tags;
+  } catch {
+    throw new CliUsageError("--tags must be a JSON array of strings.");
+  }
+}
+function mediaKind2(parsed) {
+  const kind = required6(parsed, "kind", "upload");
+  if (!["image", "video", "audio"].includes(kind)) {
+    throw new CliUsageError("--kind must be image, video, or audio.");
+  }
+  return kind;
+}
+function uploadMime(parsed, path2) {
+  const explicit = optional5(parsed, "mime");
+  if (explicit) return explicit;
+  const inferred = MIME_BY_EXTENSION[extname(path2).toLowerCase()];
+  if (!inferred) throw new CliUsageError("Cannot infer media type from --file; pass --mime <type>.");
+  return inferred;
+}
+function declaredRecipe(parsed) {
+  const recipeOptions = ["provider", "model", "prompt", "external-run-id"];
+  const hasRecipe = recipeOptions.some((name) => parsed.options[name] !== void 0) || (parsed.values.param?.length ?? 0) > 0 || (parsed.values.ref?.length ?? 0) > 0;
+  if (!hasRecipe) return void 0;
+  const provider = optional5(parsed, "provider") ?? "external";
+  if (provider !== "external") throw new CliUsageError("--provider must be external.");
+  const model = required6(parsed, "model", "upload");
+  const references = (parsed.values.ref ?? []).map((value, order) => {
+    const at = value.lastIndexOf(":");
+    if (at <= 0 || at === value.length - 1) {
+      throw new CliUsageError("--ref must be written as asset:slot.");
+    }
+    return { asset_id: value.slice(0, at), slot: value.slice(at + 1), order };
+  });
+  const externalRunId = optional5(parsed, "external-run-id");
+  return {
+    provider: "external",
+    model,
+    prompt: optional5(parsed, "prompt") ?? "",
+    params: Object.fromEntries((parsed.values.param ?? []).map(parameter3)),
+    references,
+    ...externalRunId !== void 0 ? { external_run_id: externalRunId } : {}
+  };
+}
+function uploadToolArguments(parsed, file) {
+  rejectUnexpected6(parsed, "upload", [
+    "space",
+    "kind",
+    "file",
+    "mime",
+    "name",
+    "provider",
+    "model",
+    "prompt",
+    "param",
+    "ref",
+    "external-run-id",
+    "position",
+    "tags",
+    "request-id"
+  ]);
+  if (parsed.positionals.length > 0) {
+    throw new CliUsageError(
+      `upload does not accept "${parsed.positionals[0]}". ${transferCommandUsage("upload")}`
+    );
+  }
+  const name = optional5(parsed, "name");
+  const recipe = declaredRecipe(parsed);
+  const position = objectOption2(parsed, "position");
+  const tags = tagsOption3(parsed);
+  const requestId = optional5(parsed, "request-id");
+  return {
+    space_id: required6(parsed, "space", "upload"),
+    kind: mediaKind2(parsed),
+    filename: basename(file.path),
+    mime: uploadMime(parsed, file.path),
+    size_bytes: file.size,
+    ...name !== void 0 ? { name } : {},
+    ...recipe !== void 0 ? { recipe } : {},
+    ...position !== void 0 ? { position } : {},
+    ...tags !== void 0 ? { tags } : {},
+    ...requestId !== void 0 ? { request_id: requestId } : {}
+  };
+}
+function record4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function signedUpload(result) {
+  const headers = record4(result.headers);
+  if (result.method !== "PUT" || typeof result.upload_url !== "string" || !headers || !Object.values(headers).every((value) => typeof value === "string")) {
+    throw new Error("upload_asset returned an unusable signed upload.");
+  }
+  return { url: result.upload_url, headers };
+}
+async function uploadFile(handle, size, signed, fetchImpl) {
+  const source = handle.createReadStream();
+  let bytes = 0;
+  const counted = new Transform({
+    transform(chunk, _encoding, callback) {
+      bytes += chunk.byteLength;
+      callback(null, chunk);
+    }
+  });
+  source.once("error", (error) => counted.destroy(error));
+  source.pipe(counted);
+  try {
+    const request = {
+      method: "PUT",
+      headers: signed.headers,
+      body: counted,
+      duplex: "half"
+    };
+    const response = await fetchImpl(signed.url, request);
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => void 0);
+      throw new Error(`Upload failed with HTTP ${response.status}.`);
+    }
+    await finished(source);
+    if (bytes !== size) throw new Error(`Upload ended after ${bytes} of ${size} bytes.`);
+    await response.body?.cancel().catch(() => void 0);
+  } catch (error) {
+    source.destroy();
+    counted.destroy();
+    throw error;
+  }
+}
+async function destinationAvailable2(path2) {
+  try {
+    await lstat2(path2);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  throw new Error(`Destination already exists: ${path2}`);
+}
+function expectedLength(response, asset) {
+  const header = response.headers.get("content-length");
+  if (header !== null) {
+    const length = Number(header);
+    if (!Number.isSafeInteger(length) || length < 0)
+      throw new Error("Download returned an invalid Content-Length.");
+    return length;
+  }
+  const media = record4(asset.media);
+  return typeof media?.size_bytes === "number" ? media.size_bytes : void 0;
+}
+async function downloadFile(url, destination, asset, fetchImpl, id) {
+  await destinationAvailable2(destination);
+  const temporary = `${destination}.makefx-${id()}.tmp`;
+  let published = false;
+  try {
+    const response = await fetchImpl(url);
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => void 0);
+      throw new Error(`Download failed with HTTP ${response.status}.`);
+    }
+    if (!response.body) throw new Error("Download returned no media body.");
+    const expected = expectedLength(response, asset);
+    let bytes = 0;
+    const counted = new Transform({
+      transform(chunk, _encoding, callback) {
+        bytes += chunk.byteLength;
+        callback(null, chunk);
+      }
+    });
+    await pipeline(Readable.from(response.body), counted, createWriteStream(temporary, { flags: "wx" }));
+    if (expected !== void 0 && bytes !== expected) {
+      throw new Error(`Download ended after ${bytes} of ${expected} bytes.`);
+    }
+    await link2(temporary, destination);
+    published = true;
+    await unlink2(temporary);
+  } finally {
+    if (!published) await unlink2(temporary).catch(() => void 0);
+  }
+}
+function downloadDestination(parsed, asset) {
+  const out = optional5(parsed, "out");
+  if (out) return resolve3(out);
+  const assetId = typeof asset.asset_id === "string" ? asset.asset_id : parsed.positionals[0];
+  const media = record4(asset.media);
+  const extension = typeof media?.mime === "string" ? EXTENSION_BY_MIME[media.mime] ?? "" : "";
+  return resolve3(`${assetId}${extension}`);
+}
+async function handleTransferCommand(command, parsed, dependencies = defaults6) {
+  if (command === "upload") {
+    const path2 = resolve3(required6(parsed, "file", command));
+    const handle = await open3(path2, "r");
+    try {
+      const stat2 = await handle.stat();
+      if (!stat2.isFile()) throw new Error(`Not a regular file: ${path2}`);
+      const args = uploadToolArguments(parsed, { path: path2, size: stat2.size });
+      const client2 = await dependencies.client(parsed);
+      const result2 = await client2.call("upload_asset", args);
+      await uploadFile(handle, stat2.size, signedUpload(result2), dependencies.fetch);
+      dependencies.write(
+        parsed.options.json === "true" ? JSON.stringify(result2, null, 2) : [result2.asset_id, result2.web_url].filter((value) => typeof value === "string").join(" ")
+      );
+    } finally {
+      await handle.close().catch(() => void 0);
+    }
+    return;
+  }
+  rejectUnexpected6(parsed, command, ["space", "out"]);
+  if (parsed.positionals.length !== 1) {
+    throw new CliUsageError(`download requires one asset id. ${transferCommandUsage(command)}`);
+  }
+  const client = await dependencies.client(parsed);
+  const result = await client.call("get_asset", {
+    space_id: required6(parsed, "space", command),
+    asset_id: parsed.positionals[0],
+    wait_seconds: 0
+  });
+  const asset = record4(result.asset);
+  if (!asset || asset.status !== "ready" || typeof asset.media_url !== "string") {
+    throw new Error(`Asset ${parsed.positionals[0]} is not ready for download.`);
+  }
+  const destination = downloadDestination(parsed, asset);
+  await downloadFile(asset.media_url, destination, asset, dependencies.fetch, dependencies.id);
+  dependencies.write(
+    parsed.options.json === "true" ? JSON.stringify(result, null, 2) : [asset.asset_id, result.web_url ?? asset.web_url, destination].filter((value) => typeof value === "string").join(" ")
+  );
+}
+// src/lib/command-error.ts
+function reportCommandError(error, json2, output) {
+  if (error instanceof ToolCallError) {
+    if (json2) {
+      output.stdout(
+        `${JSON.stringify(error.jsonOutput === void 0 ? error.structuredContent : error.jsonOutput)}
+`
+      );
+    }
+    output.stderr(`${error.code}: ${error.message}
+`);
+    const topupUrl = error.details?.topup_url;
+    if (typeof topupUrl === "string") output.stderr(`Top up: ${topupUrl}
+`);
+    return 1;
+  }
+  if (error instanceof CliUsageError) {
+    output.stderr(`Error: ${error.message}
+`);
+    return 2;
+  }
+  output.stderr(`Error: ${error instanceof Error ? error.message : "Unexpected error occurred"}
+`);
+  return 1;
+}
+// src/lib/utils.ts
+function parseArgs(argv) {
+  const options = {};
+  const values = {};
+  const positionals = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token.startsWith("-") && !token.startsWith("--")) {
+      const key2 = token.slice(1);
+      const next2 = argv[i + 1];
+      if (next2 && !next2.startsWith("-")) {
+        options[key2] = next2;
+        (values[key2] ??= []).push(next2);
+        i += 1;
+      } else {
+        options[key2] = "true";
+        (values[key2] ??= []).push("true");
+      }
+      continue;
+    }
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+    const eqIndex = token.indexOf("=");
+    if (eqIndex !== -1) {
+      const key2 = token.slice(2, eqIndex);
+      const value = token.slice(eqIndex + 1);
+      options[key2] = value;
+      (values[key2] ??= []).push(value);
+      continue;
+    }
+    const key = token.slice(2);
+    const next = argv[i + 1];
+    if (next && !next.startsWith("--")) {
+      options[key] = next;
+      (values[key] ??= []).push(next);
+      i += 1;
+    } else {
+      options[key] = "true";
+      (values[key] ??= []).push("true");
+    }
+  }
+  return { options, values, positionals };
+}
+// src/commands/audio.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { link as link3, lstat as lstat3, open as open4, readFile as readFile3, unlink as unlink3 } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+var USAGE6 = {
+  "audio align": "audio align ASSET --space ACCOUNT/SPACE [TEXT | --input PATH] [--request-id ID] [--wait] [--json]",
+  "audio timings": "audio timings ASSET --space ACCOUNT/SPACE [--out PATH] [--json]"
+};
+var defaults7 = {
+  client: authenticatedToolClient,
+  write: (text2) => process.stdout.write(`${text2}
+`),
+  id: randomUUID5
+};
+function audioCommandUsage(command) {
+  return `Usage: makefx ${USAGE6[command]}`;
+}
+function option2(parsed, name) {
+  const value = parsed.options[name];
+  if (value === "true") throw new CliUsageError(`--${name} requires a value.`);
+  return value;
+}
+function required7(parsed, name, command) {
+  const value = option2(parsed, name);
+  if (!value) throw new CliUsageError(`${command} requires --${name} <value>.`);
+  return value;
+}
+function rejectOptions(parsed, command, allowed) {
+  const options = /* @__PURE__ */ new Set(["env", "local", "json", "help", ...allowed]);
+  const unexpected = Object.keys(parsed.options).find((name) => !options.has(name));
+  if (unexpected) throw new CliUsageError(`Unknown option --${unexpected}. ${audioCommandUsage(command)}`);
+}
+async function destinationAvailable3(path2) {
+  try {
+    await lstat3(path2);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  throw new Error(`Destination already exists: ${path2}`);
+}
+async function publishJson2(path2, value, id) {
+  await destinationAvailable3(path2);
+  const temporary = `${path2}.makefx-${id()}.tmp`;
+  let published = false;
+  try {
+    const handle = await open4(temporary, "wx");
+    try {
+      await handle.writeFile(`${JSON.stringify(value, null, 2)}
+`, "utf8");
+    } finally {
+      await handle.close();
+    }
+    await link3(temporary, path2);
+    published = true;
+    await unlink3(temporary);
+  } finally {
+    if (!published) await unlink3(temporary).catch(() => void 0);
+  }
+}
+function record5(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+async function alignmentText(parsed) {
+  const path2 = option2(parsed, "input");
+  const inline = parsed.positionals[1];
+  if (path2 && inline !== void 0) throw new CliUsageError("Use inline text or --input, not both.");
+  if (parsed.positionals.length > 2) throw new CliUsageError(audioCommandUsage("audio align"));
+  if (!path2) return inline;
+  const value = await readFile3(resolve4(path2), "utf8");
+  if (Array.from(value).length > 675e3) throw new Error("Alignment input exceeds 675,000 characters.");
+  return value;
+}
+async function handleAudioCommand(command, parsed, dependencies = defaults7) {
+  if (parsed.positionals.length < 1) throw new CliUsageError(audioCommandUsage(command));
+  const asset = parsed.positionals[0];
+  if (!asset) throw new CliUsageError(audioCommandUsage(command));
+  const space = required7(parsed, "space", command);
+  const client = await dependencies.client(parsed);
+  if (command === "audio align") {
+    rejectOptions(parsed, command, ["space", "input", "request-id", "wait"]);
+    const text2 = await alignmentText(parsed);
+    let result2 = await client.call("align_audio", {
+      space_id: space,
+      asset_id: asset,
+      request_id: option2(parsed, "request-id") ?? dependencies.id(),
+      ...text2 === void 0 ? {} : { text: text2 }
+    });
+    const admitted = record5(result2.alignment_job);
+    if (parsed.options.wait === "true" && typeof admitted?.alignment_job_id === "string") {
+      while (admitted.status === "queued" || admitted.status === "running") {
+        result2 = await client.call("get_audio_word_timings", {
+          space_id: space,
+          asset_id: asset,
+          alignment_job_id: admitted.alignment_job_id,
+          wait_seconds: 60
+        });
+        const current = record5(result2.alignment_job);
+        if (!current || current.status === "completed" || current.status === "failed") break;
+        admitted.status = current.status;
+      }
+    }
+    if (parsed.options.json === "true") {
+      dependencies.write(JSON.stringify(result2, null, 2));
+      return;
+    }
+    const job = record5(result2.alignment_job) ?? admitted ?? {};
+    const credits = job.charged_credits ?? job.estimated_credits;
+    dependencies.write(
+      [
+        typeof job.alignment_job_id === "string" ? `Alignment ${job.alignment_job_id}` : void 0,
+        typeof job.status === "string" ? job.status : void 0,
+        typeof credits === "number" ? `${credits} credits` : void 0,
+        typeof result2.web_url === "string" ? result2.web_url : void 0
+      ].filter((value) => value !== void 0).join(" \xB7 ")
+    );
+    return;
+  }
+  rejectOptions(parsed, command, ["space", "out"]);
+  if (parsed.positionals.length !== 1) throw new CliUsageError(audioCommandUsage(command));
+  const result = await client.call("get_audio_word_timings", {
+    space_id: space,
+    asset_id: asset,
+    wait_seconds: 0
+  });
+  if (!result.word_timings) throw new Error("No word timings are available.");
+  const out = option2(parsed, "out");
+  if (out) {
+    const destination = resolve4(out);
+    await publishJson2(destination, result.word_timings, dependencies.id);
+    dependencies.write(parsed.options.json === "true" ? JSON.stringify(result, null, 2) : destination);
+  } else {
+    dependencies.write(JSON.stringify(result.word_timings, null, 2));
+  }
+}
+// src/lib/space-id.ts
+var LOCAL_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var LOCAL_ID_MAX_LENGTH = 63;
+function isLocalId(value) {
+  return value.length <= LOCAL_ID_MAX_LENGTH && LOCAL_ID_PATTERN.test(value);
+}
+function parseCanonicalSpaceId(value) {
+  const slash = value.indexOf("/");
+  if (slash < 1 || slash !== value.lastIndexOf("/")) return null;
+  const accountId = value.slice(0, slash);
+  const spaceId2 = value.slice(slash + 1);
+  return isLocalId(accountId) && isLocalId(spaceId2) ? { accountId, spaceId: spaceId2 } : null;
+}
+// src/commands/space-visibility.ts
+var SPACE_UPDATE_PATH = "/api/spaces/:accountId/:spaceId";
+var defaults8 = {
+  authenticate: authenticatedConfig,
+  fetch,
+  write: (text2) => process.stdout.write(`${text2}
+`)
+};
+function spaceVisibilityUsage(command) {
+  return `Usage: makefx ${command} --space ACCOUNT/SPACE [--json]`;
+}
+function spaceId(parsed, command) {
+  if (parsed.positionals.length > 0) {
+    throw new CliUsageError(
+      `${command} does not accept "${parsed.positionals[0]}". ${spaceVisibilityUsage(command)}`
+    );
+  }
+  const allowed = /* @__PURE__ */ new Set(["env", "local", "json", "space"]);
+  const unexpected = Object.keys(parsed.options).find((option3) => !allowed.has(option3));
+  if (unexpected) {
+    throw new CliUsageError(`Unknown option --${unexpected}. ${spaceVisibilityUsage(command)}`);
+  }
+  const value = parsed.options.space;
+  if (!value || value === "true") throw new CliUsageError(`${command} requires --space <value>.`);
+  if (!parseCanonicalSpaceId(value)) {
+    throw new CliUsageError(`${command} requires --space ACCOUNT/SPACE.`);
+  }
+  return value;
+}
+function routePath(accountId, spaceId2) {
+  return SPACE_UPDATE_PATH.replace(":accountId", encodeURIComponent(accountId)).replace(":spaceId", encodeURIComponent(spaceId2));
+}
+async function responseError(response, messageOverride) {
+  const payload = await response.json().catch(() => void 0);
+  const value = payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
+  const code = typeof value?.error === "string" ? value.error : `http_${response.status}`;
+  const message = messageOverride ?? (typeof value?.error_description === "string" ? value.error_description : typeof value?.error === "string" ? value.error : `Space visibility update failed (${response.status}).`);
+  return new ToolCallError(
+    {
+      code,
+      message,
+      retryable: typeof value?.retryable === "boolean" ? value.retryable : response.status === 429 || response.status >= 500,
+      details: { http_status: response.status }
+    },
+    message,
+    payload
+  );
+}
+async function setSpaceVisibility(config, canonicalId, isPublic, fetchImpl = fetch) {
+  const parsed = parseCanonicalSpaceId(canonicalId);
+  if (!parsed) throw new CliUsageError("--space must be ACCOUNT/SPACE.");
+  const response = await fetchImpl(new URL(routePath(parsed.accountId, parsed.spaceId), config.baseUrl), {
+    method: "PATCH",
+    headers: {
+      Authorization: `Bearer ${config.token.accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ is_public: isPublic })
+  });
+  if (!response.ok) {
+    throw await responseError(
+      response,
+      response.status === 401 ? "The stored login was rejected. Sign in again." : void 0
+    );
+  }
+  return spaceUpdateResponse(await response.json());
+}
+function spaceUpdateResponse(payload) {
+  const space = isRecord(payload) ? payload.space : void 0;
+  if (!isRecord(space) || typeof space.space_id !== "string" || typeof space.is_public !== "boolean" || typeof space.web_url !== "string") {
+    throw new Error("The space update response was not a space.");
+  }
+  return { space: { ...space, space_id: space.space_id, is_public: space.is_public, web_url: space.web_url } };
+}
+async function handleSpaceVisibilityCommand(command, parsed, dependencies = defaults8) {
+  const canonicalId = spaceId(parsed, command);
+  const config = await dependencies.authenticate(parsed);
+  const result = await setSpaceVisibility(
+    config,
+    canonicalId,
+    command === "space publish",
+    dependencies.fetch
+  );
+  if (parsed.options.json === "true") {
+    dependencies.write(JSON.stringify(result, null, 2));
+    return;
+  }
+  dependencies.write(
+    `${result.space.space_id} \xB7 ${result.space.is_public ? "public" : "private"} \xB7 ${result.space.web_url}`
+  );
+}
+// src/index.ts
+async function main() {
+  const [, , command, ...args] = process4.argv;
+  try {
+    if (!command || command === "--help") {
+      printHelp();
+      return;
+    }
+    if (command === "--version" || command === "version") {
+      console.log(CLI_VERSION);
+      return;
+    }
+    if (command === "help") {
+      const [topic, nested] = args;
+      if (topic) printTopicHelp(topic, nested);
+      else printHelp();
+      return;
+    }
+    const parsed = parseArgs(args);
+    await dispatchCommand(command, parsed);
+  } catch (error) {
+    const parsed = parseArgs(args);
+    process4.exitCode = reportCommandError(error, parsed.options.json === "true", {
+      stdout: (text2) => process4.stdout.write(text2),
+      stderr: (text2) => process4.stderr.write(text2)
+    });
+  }
+}
+function printHelp() {
+  console.log(`
+${SERVICE_NAME} CLI ${CLI_VERSION}
+Usage: makefx <command> [options]
+Commands:
+  login [--env ENV]             Sign in through the browser
+  logout [--env ENV]            Revoke and remove stored credentials
+  mcp [--env ENV]               Relay stdio JSON-RPC to /mcp
+  account [--account ID]        Show balance and active holds
+  purchase create --account ID --product PRODUCT --request-id ID
+                                Prepare a credit purchase without charging a card
+  purchase get --purchase ID    Read credit purchase status
+  profile get                   Show the signed-in profile
+  profile update --name NAME    Change the signed-in display name
+  health                        Check service reachability and environment
+  spaces [--account ID] [--query TEXT] [--limit N]
+                                List available spaces
+  space create --name NAME [--account ID] [--id ID]
+                                Create a space in an account you can edit
+  space get --space S [--starred-only]
+                                Read every asset, link, and recipe in a space
+  space update --space S --name TEXT
+                                Rename a space; every address it has worn keeps working
+  space publish --space S       Publish a read-only snapshot (account owner only)
+  space unpublish --space S     Withdraw the public snapshot (account owner only)
+  space delete --space S        Soft-delete a space (account owner only)
+  voices sync --account ACCOUNT Refresh the account's ElevenLabs voices
+  models [--space S] [--kind K] [--family F]
+                                List the model catalog for the payer
+  estimate --kind K --model M [--from-asset A] [--recipe-mode current|exact]
+                                Quote creation or replay before spending credits
+  create --space S --kind K --model M
+                                Validate the payer catalog, then create assets
+  upload --space S --kind K --file PATH
+                                Stream a local file through a signed URL
+  download ASSET --space S      Stream ready media to a new local file
+  asset get --space S --asset A Read an asset and refresh its URLs
+  asset update --space S --asset A
+                                Update asset metadata
+  asset delete --space S --asset A
+                                Soft-delete an asset
+  describe --space S --asset A  Describe reusable visual traits
+  audio align ASSET --space S   Align or re-align unchanged ready audio
+  audio timings ASSET --space S Read or save current canonical timings
+  link --space S --from A --to B
+                                Link two assets on the canvas
+  unlink --space S (--link L | --from A --to B)
+                                Remove a canvas link
+  export --space S [--out PATH] Export a space document via export_space
+  open SPACE                    Print and open a canonical space URL
+  open ASSET --space S          Print and open a canonical asset URL
+Common options:
+  --env production|stage|local  Select credentials and endpoint (default: production)
+  --local                       Shortcut for --env local
+  --json                        Print unchanged structured tool output where supported
+  --help                        Show command help without authenticating
+  --version                     Print the installed CLI version
+Open control:
+  --no-open                     Print the URL without launching a browser
+  MAKEFX_NO_OPEN=1              Environment equivalent for scripts
+Exit codes:
+  0 success; 1 tool, network, or file error; 2 invalid command usage
+Examples:
+  makefx login --env production
+  makefx create --space alv/flight --kind image --model image/frame \\
+    --ref as_video:source --param t=last --wait
+  makefx upload --space alv/flight --kind image --file ./frame.png \\
+    --param source=camera --ref as_board:reference
+  makefx export --space alv/flight --out ./flight.json
+Run makefx <command> --help, makefx space help, makefx asset help, makefx audio help, or makefx voices help for exact arguments.
+`);
+}
+function helpForCommand(command) {
+  const staticUsage = {
+    login: "Usage: makefx login [--env production|stage|local] [--local]",
+    logout: "Usage: makefx logout [--env production|stage|local] [--local]",
+    mcp: "Usage: makefx mcp [--env production|stage|local] [--local]",
+    create: "Usage: makefx create --space ACCOUNT/SPACE --kind image|video|audio --model MODEL [--prompt TEXT] [--ref ASSET:SLOT]... [--param NAME=VALUE]... [--count 1..8] [--name TEXT] [--seed INTEGER] [--position JSON] [--tags JSON] [--note TEXT] [--from-asset ASSET] [--recipe-mode current|exact] [--request-id ID] [--wait] [--json]\nRepeated --ref values preserve left-to-right order as reference order 0, 1, and so on. Reads the live catalog for the paying Space before calling create_asset.",
+    export: `Usage: makefx ${CONVENIENCE_USAGE.export}`,
+    open: `Usage: makefx ${CONVENIENCE_USAGE.open}
+Prints web_url before opening. Set MAKEFX_NO_OPEN=1 for scripts.`
+  };
+  if (command in staticUsage) return staticUsage[command];
+  if (command === "upload" || command === "download") return transferCommandUsage(command);
+  if (command === "purchase create" || command === "purchase get") {
+    return purchaseCommandUsage(command);
+  }
+  if (command === "audio align" || command === "audio timings") return audioCommandUsage(command);
+  if (command === "space publish" || command === "space unpublish") {
+    return spaceVisibilityUsage(command);
+  }
+  if (["describe", "link", "unlink", "asset update", "asset delete", "profile update"].includes(command)) {
+    return mutationCommandUsage(command);
+  }
+  if ([
+    "account",
+    "spaces",
+    "space create",
+    "space get",
+    "space update",
+    "space delete",
+    "models",
+    "estimate",
+    "asset get",
+    "profile get",
+    "health"
+  ].includes(command)) {
+    return commandUsage(command);
+  }
+  throw new CliUsageError(`Unknown help topic: ${command}`);
+}
+function printTopicHelp(topic, nested) {
+  if (topic === "voices") {
+    if (nested && nested !== "sync") throw new CliUsageError(`Unknown voices command: ${nested}`);
+    console.log(mutationCommandUsage("voices sync"));
+    return;
+  }
+  if (topic === "audio") {
+    if (nested === "align" || nested === "timings") console.log(audioCommandUsage(`audio ${nested}`));
+    else if (nested) throw new CliUsageError(`Unknown audio command: ${nested}`);
+    else console.log([audioCommandUsage("audio align"), audioCommandUsage("audio timings")].join("\n"));
+    return;
+  }
+  if (topic === "space" || topic === "asset" || topic === "purchase" || topic === "profile") {
+    if (nested) console.log(helpForCommand(`${topic} ${nested}`));
+    else printNestedHelp(topic);
+    return;
+  }
+  console.log(helpForCommand(topic));
+}
+async function dispatchCommand(command, parsed) {
+  if (parsed.options.help === "true" && command !== "space" && command !== "asset" && command !== "audio" && command !== "voices" && command !== "purchase" && command !== "profile") {
+    console.log(helpForCommand(command));
+    return;
+  }
+  switch (command) {
+    case "login":
+      await handleLogin(parsed);
+      break;
+    case "logout":
+      await handleLogout(parsed);
+      break;
+    case "mcp":
+      await handleMcp(parsed);
+      break;
+    case "create":
+      await handleCreate(parsed);
+      break;
+    case "export":
+      await handleExport(parsed);
+      break;
+    case "open":
+      await handleOpen(parsed);
+      break;
+    case "upload":
+    case "download":
+      await handleTransferCommand(command, parsed);
+      break;
+    case "describe":
+    case "link":
+    case "unlink":
+      await handleMutationCommand(command, parsed);
+      break;
+    case "voices": {
+      const [subcommand, ...positionals] = parsed.positionals;
+      if (!subcommand || subcommand === "help") {
+        console.log(mutationCommandUsage("voices sync"));
+        break;
+      }
+      if (subcommand !== "sync") throw new CliUsageError(`Unknown voices command: ${subcommand}`);
+      if (parsed.options.help === "true") {
+        console.log(mutationCommandUsage("voices sync"));
+        break;
+      }
+      await handleMutationCommand("voices sync", { ...parsed, positionals });
+      break;
+    }
+    case "audio": {
+      const [subcommand, ...positionals] = parsed.positionals;
+      if (!subcommand || subcommand === "help") {
+        console.log([audioCommandUsage("audio align"), audioCommandUsage("audio timings")].join("\n"));
+        break;
+      }
+      const nested = `audio ${subcommand}`;
+      if (nested !== "audio align" && nested !== "audio timings") {
+        throw new CliUsageError(`Unknown audio command: ${subcommand}`);
+      }
+      if (parsed.options.help === "true") {
+        console.log(audioCommandUsage(nested));
+        break;
+      }
+      await handleAudioCommand(nested, { ...parsed, positionals });
+      break;
+    }
+    case "account":
+    case "spaces":
+    case "models":
+    case "estimate":
+    case "health":
+      await handleDataCommand(command, parsed);
+      break;
+    case "purchase":
+    case "profile": {
+      const [subcommand, ...positionals] = parsed.positionals;
+      if (!subcommand || subcommand === "help") {
+        printNestedHelp(command);
+        break;
+      }
+      const nested = `${command} ${subcommand}`;
+      const allowed = command === "purchase" ? ["purchase create", "purchase get"] : ["profile get", "profile update"];
+      if (!allowed.includes(nested)) {
+        throw new CliUsageError(`Unknown ${command} command: ${subcommand}`);
+      }
+      if (parsed.options.help === "true") {
+        console.log(helpForCommand(nested));
+        break;
+      }
+      const nestedParsed = { ...parsed, positionals };
+      if (nested === "purchase create" || nested === "purchase get") {
+        await handlePurchaseCommand(nested, nestedParsed);
+      } else if (nested === "profile update") {
+        await handleMutationCommand(nested, nestedParsed);
+      } else {
+        await handleDataCommand(nested, nestedParsed);
+      }
+      break;
+    }
+    case "space":
+    case "asset": {
+      const [subcommand, ...positionals] = parsed.positionals;
+      if (!subcommand || subcommand === "help") {
+        printNestedHelp(command);
+        break;
+      }
+      const nested = `${command} ${subcommand}`;
+      if (![
+        "space create",
+        "space get",
+        "space update",
+        "space publish",
+        "space unpublish",
+        "space delete",
+        "asset get",
+        "asset update",
+        "asset delete"
+      ].includes(nested)) {
+        throw new CliUsageError(`Unknown ${command} command: ${subcommand}`);
+      }
+      if (parsed.options.help === "true") {
+        console.log(helpForCommand(nested));
+        break;
+      }
+      const nestedParsed = { ...parsed, positionals };
+      if (nested === "space publish" || nested === "space unpublish") {
+        await handleSpaceVisibilityCommand(nested, nestedParsed);
+      } else if (nested === "space update" || nested === "asset update" || nested === "asset delete") {
+        await handleMutationCommand(nested, nestedParsed);
+      } else {
+        await handleDataCommand(nested, nestedParsed);
+      }
+      break;
+    }
+    default:
+      throw new CliUsageError(`Unknown command: ${command}`);
+  }
+}
+function printNestedHelp(command) {
+  if (command === "purchase") {
+    console.log([purchaseCommandUsage("purchase create"), purchaseCommandUsage("purchase get")].join("\n"));
+    return;
+  }
+  if (command === "profile") {
+    console.log([commandUsage("profile get"), mutationCommandUsage("profile update")].join("\n"));
+    return;
+  }
+  const commands = command === "space" ? ["space create", "space get", "space delete"] : ["asset get"];
+  const usage2 = commands.map(commandUsage);
+  if (command === "space") {
+    usage2.push(
+      mutationCommandUsage("space update"),
+      spaceVisibilityUsage("space publish"),
+      spaceVisibilityUsage("space unpublish")
+    );
+  }
+  if (command === "asset") {
+    usage2.push(mutationCommandUsage("asset update"), mutationCommandUsage("asset delete"));
+  }
+  console.log(usage2.join("\n"));
+}
+void main();