@playtagon/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1599 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command10 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+import * as readline from "readline";
+import ora from "ora";
+
+// src/lib/auth.ts
+import { createClient } from "@supabase/supabase-js";
+
+// src/lib/config.ts
+import Conf from "conf";
+var DEFAULT_SUPABASE_URL = process.env.PLAYTAGON_SUPABASE_URL || "https://yutpzwvdpktvblylglwz.supabase.co";
+var DEFAULT_SUPABASE_ANON_KEY = process.env.PLAYTAGON_SUPABASE_ANON_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Inl1dHB6d3ZkcGt0dmJseWxnbHd6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzU4MjMwNjcsImV4cCI6MjA1MTM5OTA2N30.xyNgJxBLPG3W27Lv6oCctRz-DJLy0jxiHCm7W1yQ4j0";
+var configStore = new Conf({
+  projectName: "playtagon",
+  configFileMode: 384,
+  defaults: {
+    supabaseUrl: DEFAULT_SUPABASE_URL,
+    supabaseAnonKey: DEFAULT_SUPABASE_ANON_KEY
+  }
+});
+var credentialsStore = new Conf({
+  projectName: "playtagon",
+  configName: "credentials",
+  configFileMode: 384
+});
+var config = {
+  get supabaseUrl() {
+    return configStore.get("supabaseUrl") || DEFAULT_SUPABASE_URL;
+  },
+  get supabaseAnonKey() {
+    return configStore.get("supabaseAnonKey") || DEFAULT_SUPABASE_ANON_KEY;
+  },
+  get defaultStudio() {
+    return configStore.get("defaultStudio");
+  },
+  set defaultStudio(value) {
+    if (value) {
+      configStore.set("defaultStudio", value);
+    } else {
+      configStore.delete("defaultStudio");
+    }
+  },
+  get defaultGame() {
+    return configStore.get("defaultGame");
+  },
+  set defaultGame(value) {
+    if (value) {
+      configStore.set("defaultGame", value);
+    } else {
+      configStore.delete("defaultGame");
+    }
+  },
+  // Get full config
+  getAll() {
+    return configStore.store;
+  },
+  // Get config file path
+  get path() {
+    return configStore.path;
+  }
+};
+var credentials = {
+  get accessToken() {
+    return credentialsStore.get("accessToken");
+  },
+  get refreshToken() {
+    return credentialsStore.get("refreshToken");
+  },
+  get expiresAt() {
+    return credentialsStore.get("expiresAt");
+  },
+  get userId() {
+    return credentialsStore.get("userId");
+  },
+  get email() {
+    return credentialsStore.get("email");
+  },
+  isLoggedIn() {
+    return !!credentialsStore.get("accessToken");
+  },
+  isExpired() {
+    const expiresAt = credentialsStore.get("expiresAt");
+    if (!expiresAt) return true;
+    return Date.now() > expiresAt - 5 * 60 * 1e3;
+  },
+  save(creds) {
+    if (creds.accessToken) credentialsStore.set("accessToken", creds.accessToken);
+    if (creds.refreshToken) credentialsStore.set("refreshToken", creds.refreshToken);
+    if (creds.expiresAt) credentialsStore.set("expiresAt", creds.expiresAt);
+    if (creds.userId) credentialsStore.set("userId", creds.userId);
+    if (creds.email) credentialsStore.set("email", creds.email);
+  },
+  clear() {
+    credentialsStore.clear();
+  },
+  // Get credentials file path
+  get path() {
+    return credentialsStore.path;
+  }
+};
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (message) => {
+    console.log(chalk.blue("info"), message);
+  },
+  success: (message) => {
+    console.log(chalk.green("success"), message);
+  },
+  warn: (message) => {
+    console.log(chalk.yellow("warn"), message);
+  },
+  error: (message) => {
+    console.log(chalk.red("error"), message);
+  },
+  debug: (message) => {
+    if (process.env.DEBUG) {
+      console.log(chalk.gray("debug"), message);
+    }
+  },
+  // Styled output for specific contexts
+  file: (filename) => chalk.cyan(filename),
+  value: (val) => chalk.yellow(val),
+  command: (cmd) => chalk.bold.white(cmd),
+  url: (url) => chalk.underline.blue(url),
+  // Section headers
+  header: (title) => {
+    console.log();
+    console.log(chalk.bold.white(title));
+    console.log(chalk.gray("\u2500".repeat(title.length)));
+  },
+  // List item
+  item: (label, value) => {
+    console.log(`  ${chalk.gray(label + ":")} ${value}`);
+  },
+  // Validation result formatting
+  validationError: (message, detail) => {
+    console.log(`  ${chalk.red("\u2717")} ${message}`);
+    if (detail) {
+      console.log(`    ${chalk.gray(detail)}`);
+    }
+  },
+  validationSuccess: (message) => {
+    console.log(`  ${chalk.green("\u2713")} ${message}`);
+  },
+  validationWarn: (message) => {
+    console.log(`  ${chalk.yellow("!")} ${message}`);
+  }
+};
+
+// src/lib/auth.ts
+var supabaseClient = null;
+function getSupabaseClient() {
+  if (!supabaseClient) {
+    supabaseClient = createClient(config.supabaseUrl, config.supabaseAnonKey, {
+      auth: {
+        persistSession: false,
+        autoRefreshToken: false
+      }
+    });
+  }
+  return supabaseClient;
+}
+async function getAuthenticatedClient() {
+  const client = getSupabaseClient();
+  if (!credentials.isLoggedIn()) {
+    throw new Error("Not logged in. Run `playtagon login` first.");
+  }
+  if (credentials.isExpired() && credentials.refreshToken) {
+    logger.debug("Token expired, refreshing...");
+    await refreshSession();
+  }
+  const accessToken = credentials.accessToken;
+  if (!accessToken) {
+    throw new Error("No access token found. Run `playtagon login` first.");
+  }
+  await client.auth.setSession({
+    access_token: accessToken,
+    refresh_token: credentials.refreshToken || ""
+  });
+  return client;
+}
+async function refreshSession() {
+  const client = getSupabaseClient();
+  const refreshToken = credentials.refreshToken;
+  if (!refreshToken) {
+    throw new Error("No refresh token found. Run `playtagon login` first.");
+  }
+  const { data, error } = await client.auth.refreshSession({
+    refresh_token: refreshToken
+  });
+  if (error) {
+    credentials.clear();
+    throw new Error(`Failed to refresh session: ${error.message}`);
+  }
+  if (data.session) {
+    credentials.save({
+      accessToken: data.session.access_token,
+      refreshToken: data.session.refresh_token,
+      expiresAt: data.session.expires_at ? data.session.expires_at * 1e3 : Date.now() + 3600 * 1e3
+    });
+  }
+}
+async function loginWithEmail(email, password) {
+  const client = getSupabaseClient();
+  const { data, error } = await client.auth.signInWithPassword({
+    email,
+    password
+  });
+  if (error) {
+    throw new Error(`Login failed: ${error.message}`);
+  }
+  if (!data.session) {
+    throw new Error("Login failed: No session returned");
+  }
+  credentials.save({
+    accessToken: data.session.access_token,
+    refreshToken: data.session.refresh_token,
+    expiresAt: data.session.expires_at ? data.session.expires_at * 1e3 : Date.now() + 3600 * 1e3,
+    userId: data.user?.id,
+    email: data.user?.email
+  });
+}
+function logout() {
+  credentials.clear();
+}
+async function getCurrentUser() {
+  try {
+    const client = await getAuthenticatedClient();
+    const {
+      data: { user },
+      error
+    } = await client.auth.getUser();
+    if (error || !user) {
+      return null;
+    }
+    const { data: memberships } = await client.from("studio_members").select(`
+        studio:studios (
+          id,
+          name,
+          slug
+        )
+      `).eq("user_id", user.id);
+    const studios = memberships?.map((m) => m.studio).filter(Boolean) || [];
+    return {
+      id: user.id,
+      email: user.email || "",
+      studios
+    };
+  } catch {
+    return null;
+  }
+}
+function getAccessToken() {
+  return credentials.accessToken;
+}
+
+// src/commands/login.ts
+var loginCommand = new Command("login").description("Authenticate with Playtagon").option("-e, --email <email>", "Login with email").option("-b, --browser", "Open browser for OAuth login").action(async (options) => {
+  if (credentials.isLoggedIn()) {
+    const user = await getCurrentUser();
+    if (user) {
+      logger.info(`Already logged in as ${logger.value(user.email)}`);
+      logger.info(`Run ${logger.command("playtagon logout")} to sign out.`);
+      return;
+    }
+  }
+  if (options.browser) {
+    await browserLogin();
+  } else if (options.email) {
+    await emailLogin(options.email);
+  } else {
+    await promptEmailLogin();
+  }
+});
+async function promptEmailLogin() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const question = (prompt) => new Promise((resolve4) => {
+    rl.question(prompt, resolve4);
+  });
+  try {
+    const email = await question("Email: ");
+    const password = await questionHidden("Password: ", rl);
+    const spinner = ora("Logging in...").start();
+    try {
+      await loginWithEmail(email, password);
+      spinner.succeed("Logged in successfully!");
+      const user = await getCurrentUser();
+      if (user) {
+        logger.header("Account");
+        logger.item("Email", user.email);
+        if (user.studios.length > 0) {
+          logger.item(
+            "Studios",
+            user.studios.map((s) => s.name).join(", ")
+          );
+        }
+      }
+    } catch (error) {
+      spinner.fail("Login failed");
+      logger.error(error instanceof Error ? error.message : "Unknown error");
+      process.exit(1);
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function emailLogin(email) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const password = await questionHidden("Password: ", rl);
+    const spinner = ora("Logging in...").start();
+    try {
+      await loginWithEmail(email, password);
+      spinner.succeed("Logged in successfully!");
+      const user = await getCurrentUser();
+      if (user) {
+        logger.header("Account");
+        logger.item("Email", user.email);
+      }
+    } catch (error) {
+      spinner.fail("Login failed");
+      logger.error(error instanceof Error ? error.message : "Unknown error");
+      process.exit(1);
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function browserLogin() {
+  const client = getSupabaseClient();
+  logger.info("Opening browser for authentication...");
+  const { data, error } = await client.auth.signInWithOtp({
+    email: "",
+    // Will prompt
+    options: {
+      shouldCreateUser: false
+    }
+  });
+  if (error) {
+    logger.error(`Failed to initiate login: ${error.message}`);
+    logger.info("");
+    logger.info("Please use email login instead:");
+    logger.info(`  ${logger.command("playtagon login -e your@email.com")}`);
+    process.exit(1);
+  }
+  logger.info("Browser-based login is not yet implemented.");
+  logger.info("Please use email login:");
+  logger.info(`  ${logger.command("playtagon login")}`);
+}
+function questionHidden(prompt, rl) {
+  return new Promise((resolve4) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    stdout.write(prompt);
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    let password = "";
+    const onData = (char) => {
+      const c = char.toString("utf8");
+      switch (c) {
+        case "\n":
+        case "\r":
+        case "":
+          if (stdin.isTTY) {
+            stdin.setRawMode(wasRaw ?? false);
+          }
+          stdin.removeListener("data", onData);
+          stdout.write("\n");
+          resolve4(password);
+          break;
+        case "":
+          process.exit(1);
+          break;
+        case "\x7F":
+          password = password.slice(0, -1);
+          break;
+        default:
+          password += c;
+          break;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+var logoutCommand = new Command2("logout").description("Sign out of Playtagon").action(() => {
+  if (!credentials.isLoggedIn()) {
+    logger.info("Not currently logged in.");
+    return;
+  }
+  const email = credentials.email;
+  logout();
+  if (email) {
+    logger.success(`Logged out from ${logger.value(email)}`);
+  } else {
+    logger.success("Logged out successfully");
+  }
+});
+
+// src/commands/whoami.ts
+import { Command as Command3 } from "commander";
+import ora2 from "ora";
+var whoamiCommand = new Command3("whoami").description("Show current logged in user").action(async () => {
+  if (!credentials.isLoggedIn()) {
+    logger.info("Not logged in.");
+    logger.info(`Run ${logger.command("playtagon login")} to authenticate.`);
+    return;
+  }
+  const spinner = ora2("Fetching user info...").start();
+  try {
+    const user = await getCurrentUser();
+    if (!user) {
+      spinner.fail("Session expired");
+      logger.info(`Run ${logger.command("playtagon login")} to re-authenticate.`);
+      return;
+    }
+    spinner.stop();
+    logger.header("Current User");
+    logger.item("ID", user.id);
+    logger.item("Email", user.email);
+    if (user.studios.length > 0) {
+      console.log();
+      logger.header("Studios");
+      for (const studio of user.studios) {
+        console.log(`  ${studio.name} (${logger.value(studio.slug)})`);
+      }
+    } else {
+      console.log();
+      logger.warn("No studios found. Join or create a studio in the platform.");
+    }
+  } catch (error) {
+    spinner.fail("Failed to fetch user info");
+    logger.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/spine/index.ts
+import { Command as Command7 } from "commander";
+
+// src/commands/spine/validate.ts
+import { Command as Command4 } from "commander";
+import * as path3 from "path";
+import ora3 from "ora";
+
+// src/lib/spine-validator.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/utils/files.ts
+import * as fs from "fs";
+import * as path from "path";
+var SKELETON_EXTENSIONS = [".json", ".skel"];
+var ATLAS_EXTENSIONS = [".atlas"];
+var TEXTURE_EXTENSIONS = [".png", ".jpg", ".jpeg"];
+function discoverSpineFiles(directory) {
+  const absolutePath = path.resolve(directory);
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Directory not found: ${directory}`);
+  }
+  if (!fs.statSync(absolutePath).isDirectory()) {
+    throw new Error(`Not a directory: ${directory}`);
+  }
+  const files = fs.readdirSync(absolutePath);
+  const skeletons = [];
+  const atlases = [];
+  const textures = [];
+  for (const file of files) {
+    const ext = path.extname(file).toLowerCase();
+    const fullPath = path.join(absolutePath, file);
+    if (fs.statSync(fullPath).isDirectory()) continue;
+    if (SKELETON_EXTENSIONS.includes(ext)) {
+      if (ext === ".json") {
+        if (isSpineSkeletonJson(fullPath)) {
+          skeletons.push(fullPath);
+        }
+      } else {
+        skeletons.push(fullPath);
+      }
+    } else if (ATLAS_EXTENSIONS.includes(ext)) {
+      atlases.push(fullPath);
+    } else if (TEXTURE_EXTENSIONS.includes(ext)) {
+      textures.push(fullPath);
+    }
+  }
+  return { skeletons, atlases, textures };
+}
+function isSpineSkeletonJson(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const json = JSON.parse(content);
+    return json.skeleton && typeof json.skeleton.spine === "string";
+  } catch {
+    return false;
+  }
+}
+function matchSkeletonToAtlas(skeletonPath, atlases) {
+  const skeletonName = path.basename(skeletonPath, path.extname(skeletonPath));
+  const skeletonDir = path.dirname(skeletonPath);
+  for (const atlas of atlases) {
+    const atlasName = path.basename(atlas, ".atlas");
+    if (atlasName === skeletonName) {
+      return atlas;
+    }
+  }
+  const sameDirectoryAtlases = atlases.filter(
+    (a) => path.dirname(a) === skeletonDir
+  );
+  if (sameDirectoryAtlases.length === 1) {
+    return sameDirectoryAtlases[0];
+  }
+  return null;
+}
+function parseAtlasTextures(atlasPath) {
+  const content = fs.readFileSync(atlasPath, "utf-8");
+  const lines = content.split("\n");
+  const textures = [];
+  const atlasDir = path.dirname(atlasPath);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.endsWith(".png") || trimmed.endsWith(".jpg")) {
+      const texturePath = path.join(atlasDir, trimmed);
+      if (fs.existsSync(texturePath)) {
+        textures.push(texturePath);
+      }
+    }
+  }
+  return textures;
+}
+function getFileSize(filePath) {
+  return fs.statSync(filePath).size;
+}
+function getTotalSize(files) {
+  return files.reduce((total, file) => total + getFileSize(file), 0);
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function getBaseName(filePath) {
+  return path.basename(filePath);
+}
+
+// src/lib/spine-validator.ts
+var SPINE_VALIDATION_RULES = {
+  supportedVersions: ["4.0", "4.1", "4.2", "4.3"],
+  maxTextureSize: 4096,
+  // pixels per dimension
+  maxTotalSize: 50 * 1024 * 1024,
+  // 50MB
+  maxTextureCount: 8,
+  slugPattern: /^[a-z0-9-]+$/,
+  animationNamePattern: /^[a-zA-Z0-9_-]+$/
+};
+function validateDirectory(directory, batchMode = false) {
+  const discovered = discoverSpineFiles(directory);
+  const issues = [];
+  if (discovered.skeletons.length === 0) {
+    issues.push({
+      type: "error",
+      message: "No Spine skeleton files found",
+      detail: "Expected .json (Spine skeleton) or .skel files"
+    });
+    return {
+      assets: [],
+      sharedAtlas: null,
+      sharedTextures: [],
+      totalSize: 0,
+      issues,
+      isValid: false,
+      isBatchMode: false
+    };
+  }
+  const isBatchMode = batchMode || discovered.skeletons.length > 1;
+  if (isBatchMode && discovered.skeletons.length > 1) {
+    return validateBatch(discovered, issues);
+  } else {
+    return validateSingle(discovered, issues);
+  }
+}
+function validateSingle(discovered, issues) {
+  const skeletonPath = discovered.skeletons[0];
+  const skeleton = parseSkeletonFile(skeletonPath);
+  if (!skeleton) {
+    issues.push({
+      type: "error",
+      message: "Failed to parse skeleton file",
+      file: path2.basename(skeletonPath)
+    });
+    return {
+      assets: [],
+      sharedAtlas: null,
+      sharedTextures: [],
+      totalSize: 0,
+      issues,
+      isValid: false,
+      isBatchMode: false
+    };
+  }
+  const versionIssues = validateSpineVersion(skeleton);
+  issues.push(...versionIssues);
+  const atlasPath = matchSkeletonToAtlas(skeletonPath, discovered.atlases);
+  if (!atlasPath) {
+    if (discovered.atlases.length === 0) {
+      issues.push({
+        type: "error",
+        message: "No atlas file found",
+        detail: "Expected .atlas file"
+      });
+    } else {
+      issues.push({
+        type: "warning",
+        message: "Could not match skeleton to atlas",
+        detail: `Found atlases: ${discovered.atlases.map((a) => path2.basename(a)).join(", ")}`
+      });
+    }
+  }
+  let texturePaths = [];
+  if (atlasPath) {
+    texturePaths = parseAtlasTextures(atlasPath);
+    const textureIssues = validateTextures(texturePaths);
+    issues.push(...textureIssues);
+  }
+  const orphanTextures = discovered.textures.filter(
+    (t) => !texturePaths.includes(t)
+  );
+  if (orphanTextures.length > 0) {
+    issues.push({
+      type: "warning",
+      message: `${orphanTextures.length} texture(s) not referenced in atlas`,
+      detail: orphanTextures.map((t) => path2.basename(t)).join(", ")
+    });
+  }
+  const allFiles = [skeletonPath, atlasPath, ...texturePaths].filter(
+    Boolean
+  );
+  const totalSize = getTotalSize(allFiles);
+  if (totalSize > SPINE_VALIDATION_RULES.maxTotalSize) {
+    issues.push({
+      type: "error",
+      message: `Total size ${formatFileSize(totalSize)} exceeds ${formatFileSize(SPINE_VALIDATION_RULES.maxTotalSize)} limit`
+    });
+  }
+  const animationIssues = validateAnimationNames(skeleton.animations);
+  issues.push(...animationIssues);
+  const hasErrors = issues.some((i) => i.type === "error");
+  const asset = {
+    skeleton,
+    atlasPath,
+    texturePaths,
+    totalSize,
+    issues: issues.filter(
+      (i) => i.file === void 0 || i.file === path2.basename(skeletonPath)
+    ),
+    isValid: !hasErrors
+  };
+  return {
+    assets: [asset],
+    sharedAtlas: null,
+    sharedTextures: [],
+    totalSize,
+    issues,
+    isValid: !hasErrors,
+    isBatchMode: false
+  };
+}
+function validateBatch(discovered, issues) {
+  const assets = [];
+  let sharedAtlas = null;
+  let sharedTextures = [];
+  if (discovered.atlases.length === 1) {
+    sharedAtlas = discovered.atlases[0];
+    sharedTextures = parseAtlasTextures(sharedAtlas);
+    issues.push({
+      type: "info",
+      message: `Batch mode: ${discovered.skeletons.length} skeletons sharing 1 atlas`
+    });
+  } else if (discovered.atlases.length === 0) {
+    issues.push({
+      type: "error",
+      message: "No atlas file found for batch upload"
+    });
+  } else {
+    issues.push({
+      type: "warning",
+      message: `Multiple atlases found (${discovered.atlases.length}). Batch mode works best with shared atlas.`
+    });
+  }
+  for (const skeletonPath of discovered.skeletons) {
+    const skeleton = parseSkeletonFile(skeletonPath);
+    if (!skeleton) {
+      issues.push({
+        type: "error",
+        message: "Failed to parse skeleton file",
+        file: path2.basename(skeletonPath)
+      });
+      continue;
+    }
+    const versionIssues = validateSpineVersion(skeleton);
+    issues.push(...versionIssues);
+    const animationIssues = validateAnimationNames(skeleton.animations);
+    issues.push(...animationIssues);
+    const atlasPath = sharedAtlas || matchSkeletonToAtlas(skeletonPath, discovered.atlases);
+    const texturePaths = atlasPath ? parseAtlasTextures(atlasPath) : [];
+    const skeletonSize = getFileSize(skeletonPath);
+    assets.push({
+      skeleton,
+      atlasPath,
+      texturePaths,
+      totalSize: skeletonSize,
+      issues: [],
+      isValid: true
+    });
+  }
+  if (sharedTextures.length > 0) {
+    const textureIssues = validateTextures(sharedTextures);
+    issues.push(...textureIssues);
+  }
+  const skeletonSizes = assets.reduce((sum, a) => sum + a.totalSize, 0);
+  const atlasSize = sharedAtlas ? getFileSize(sharedAtlas) : 0;
+  const textureSize = getTotalSize(sharedTextures);
+  const totalSize = skeletonSizes + atlasSize + textureSize;
+  if (totalSize > SPINE_VALIDATION_RULES.maxTotalSize) {
+    issues.push({
+      type: "error",
+      message: `Total batch size ${formatFileSize(totalSize)} exceeds ${formatFileSize(SPINE_VALIDATION_RULES.maxTotalSize)} limit`
+    });
+  }
+  const hasErrors = issues.some((i) => i.type === "error");
+  return {
+    assets,
+    sharedAtlas,
+    sharedTextures,
+    totalSize,
+    issues,
+    isValid: !hasErrors,
+    isBatchMode: true
+  };
+}
+function parseSkeletonFile(filePath) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const json = JSON.parse(content);
+    if (!json.skeleton?.spine) {
+      return null;
+    }
+    const name = path2.basename(filePath, path2.extname(filePath));
+    const spineVersion = json.skeleton.spine;
+    const animations = json.animations ? Object.keys(json.animations) : [];
+    const skins = json.skins ? Array.isArray(json.skins) ? json.skins.map((s) => s.name || "default") : Object.keys(json.skins) : ["default"];
+    const hasEvents = !!json.events && Object.keys(json.events).length > 0;
+    const boneCount = json.bones ? json.bones.length : 0;
+    const slotCount = json.slots ? json.slots.length : 0;
+    return {
+      path: filePath,
+      name,
+      spineVersion,
+      animations,
+      skins,
+      hasEvents,
+      boneCount,
+      slotCount
+    };
+  } catch {
+    return null;
+  }
+}
+function validateSpineVersion(skeleton) {
+  const issues = [];
+  const version = skeleton.spineVersion;
+  const majorMinor = version.match(/^(\d+\.\d+)/)?.[1];
+  if (!majorMinor || !SPINE_VALIDATION_RULES.supportedVersions.includes(
+    majorMinor
+  )) {
+    issues.push({
+      type: "error",
+      message: `Unsupported Spine version: ${version}`,
+      file: path2.basename(skeleton.path),
+      detail: `Supported versions: ${SPINE_VALIDATION_RULES.supportedVersions.join(", ")}`
+    });
+  }
+  return issues;
+}
+function validateAnimationNames(animations) {
+  const issues = [];
+  for (const name of animations) {
+    if (!SPINE_VALIDATION_RULES.animationNamePattern.test(name)) {
+      issues.push({
+        type: "warning",
+        message: `Animation name "${name}" contains invalid characters`,
+        detail: "Recommended: a-z, A-Z, 0-9, _, -"
+      });
+    }
+  }
+  return issues;
+}
+function validateTextures(texturePaths) {
+  const issues = [];
+  if (texturePaths.length > SPINE_VALIDATION_RULES.maxTextureCount) {
+    issues.push({
+      type: "error",
+      message: `Too many textures: ${texturePaths.length}`,
+      detail: `Maximum allowed: ${SPINE_VALIDATION_RULES.maxTextureCount}`
+    });
+  }
+  for (const texturePath of texturePaths) {
+    if (!fs2.existsSync(texturePath)) {
+      issues.push({
+        type: "error",
+        message: `Texture file not found: ${path2.basename(texturePath)}`
+      });
+      continue;
+    }
+    const size = getFileSize(texturePath);
+    if (size > 20 * 1024 * 1024) {
+      issues.push({
+        type: "warning",
+        message: `Large texture file: ${path2.basename(texturePath)} (${formatFileSize(size)})`,
+        detail: "Consider optimizing texture size"
+      });
+    }
+  }
+  return issues;
+}
+function generateSlug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function validateSlug(slug) {
+  return SPINE_VALIDATION_RULES.slugPattern.test(slug);
+}
+var SPINE_EXPORT_PRESET = {
+  class: "export-json",
+  name: "Playtagon Platform",
+  output: "{projectDir}/exports/{skeletonName}",
+  extension: ".json",
+  format: "json",
+  nonessential: false,
+  cleanUp: true,
+  warnings: true,
+  packAtlas: true,
+  packSource: "attachments",
+  packTarget: "perskeleton",
+  packSettings: {
+    maxWidth: 4096,
+    maxHeight: 4096,
+    paddingX: 2,
+    paddingY: 2,
+    edgePadding: true,
+    duplicatePadding: true,
+    rotation: true,
+    stripWhitespaceX: true,
+    stripWhitespaceY: true,
+    pot: false,
+    filterMin: "Linear",
+    filterMag: "Linear",
+    premultiplyAlpha: true
+  }
+};
+
+// src/commands/spine/validate.ts
+var validateCommand = new Command4("validate").description("Validate Spine files before uploading").argument("<directory>", "Directory containing Spine files").option("--batch", "Enable batch mode for multiple skeletons sharing atlas").action(async (directory, options) => {
+  const absolutePath = path3.resolve(directory);
+  const spinner = ora3(`Validating ${logger.file(directory)}...`).start();
+  try {
+    const result = validateDirectory(absolutePath, options.batch);
+    spinner.stop();
+    printValidationResult(result, directory);
+    if (!result.isValid) {
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail("Validation failed");
+    logger.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+function printValidationResult(result, directory) {
+  console.log();
+  logger.header(`Validation: ${directory}`);
+  if (result.isBatchMode) {
+    console.log(`  Mode: ${logger.value("Batch")} (${result.assets.length} skeletons)`);
+    if (result.sharedAtlas) {
+      console.log(`  Shared Atlas: ${logger.file(path3.basename(result.sharedAtlas))}`);
+      console.log(`  Shared Textures: ${result.sharedTextures.length}`);
+    }
+  } else if (result.assets.length > 0) {
+    console.log(`  Mode: ${logger.value("Single")}`);
+  }
+  console.log(`  Total Size: ${logger.value(formatFileSize(result.totalSize))}`);
+  console.log();
+  for (const asset of result.assets) {
+    const statusIcon = asset.isValid ? "\u2713" : "\u2717";
+    const statusColor = asset.isValid ? "green" : "red";
+    console.log(
+      `  ${statusIcon} ${logger.file(asset.skeleton.name)}`
+    );
+    console.log(`    Spine: ${asset.skeleton.spineVersion}`);
+    console.log(`    Animations: ${asset.skeleton.animations.length}`);
+    console.log(`    Skins: ${asset.skeleton.skins.length}`);
+    if (asset.atlasPath) {
+      console.log(`    Atlas: ${path3.basename(asset.atlasPath)}`);
+      console.log(`    Textures: ${asset.texturePaths.length}`);
+    }
+  }
+  console.log();
+  const errors = result.issues.filter((i) => i.type === "error");
+  const warnings = result.issues.filter((i) => i.type === "warning");
+  const infos = result.issues.filter((i) => i.type === "info");
+  for (const info of infos) {
+    logger.info(info.message);
+  }
+  if (warnings.length > 0) {
+    console.log();
+    for (const warning of warnings) {
+      logger.validationWarn(
+        warning.file ? `${warning.file}: ${warning.message}` : warning.message
+      );
+      if (warning.detail) {
+        console.log(`    ${warning.detail}`);
+      }
+    }
+  }
+  if (errors.length > 0) {
+    console.log();
+    for (const error of errors) {
+      logger.validationError(
+        error.file ? `${error.file}: ${error.message}` : error.message,
+        error.detail
+      );
+    }
+  }
+  console.log();
+  if (result.isValid) {
+    logger.success("Validation passed! Ready for upload.");
+  } else {
+    logger.error(`Validation failed with ${errors.length} error(s).`);
+  }
+}
+
+// src/commands/spine/upload.ts
+import { Command as Command5 } from "commander";
+import * as fs3 from "fs";
+import * as path4 from "path";
+import ora4 from "ora";
+
+// src/lib/api.ts
+var API_BASE = config.supabaseUrl;
+async function uploadSpineAsset(formData) {
+  const token = getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run `playtagon login` first.");
+  }
+  const response = await fetch(`${API_BASE}/functions/v1/spine-upload`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`
+    },
+    body: formData
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage;
+    try {
+      const errorJson = JSON.parse(errorText);
+      errorMessage = errorJson.error || errorJson.message || errorText;
+    } catch {
+      errorMessage = errorText;
+    }
+    throw new Error(`Upload failed: ${errorMessage}`);
+  }
+  return response.json();
+}
+async function getStudios() {
+  const token = getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run `playtagon login` first.");
+  }
+  const response = await fetch(
+    `${API_BASE}/rest/v1/studio_members?select=studio:studios(id,name,slug)`,
+    {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        apikey: config.supabaseAnonKey
+      }
+    }
+  );
+  if (!response.ok) {
+    throw new Error("Failed to fetch studios");
+  }
+  const data = await response.json();
+  return data.map((m) => m.studio).filter(Boolean);
+}
+async function getGames(studioId) {
+  const token = getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run `playtagon login` first.");
+  }
+  const response = await fetch(
+    `${API_BASE}/rest/v1/games?studio_id=eq.${studioId}&select=id,name,slug`,
+    {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        apikey: config.supabaseAnonKey
+      }
+    }
+  );
+  if (!response.ok) {
+    throw new Error("Failed to fetch games");
+  }
+  return response.json();
+}
+async function resolveStudio(studioIdOrSlug) {
+  const token = getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run `playtagon login` first.");
+  }
+  const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    studioIdOrSlug
+  );
+  const query = isUuid ? `id=eq.${studioIdOrSlug}` : `slug=eq.${studioIdOrSlug}`;
+  const response = await fetch(
+    `${API_BASE}/rest/v1/studios?${query}&select=id,name,slug`,
+    {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        apikey: config.supabaseAnonKey
+      }
+    }
+  );
+  if (!response.ok) {
+    return null;
+  }
+  const data = await response.json();
+  return data[0] || null;
+}
+async function resolveGame(studioId, gameIdOrSlug) {
+  const token = getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run `playtagon login` first.");
+  }
+  const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    gameIdOrSlug
+  );
+  const idQuery = isUuid ? `id=eq.${gameIdOrSlug}` : `slug=eq.${gameIdOrSlug}`;
+  const response = await fetch(
+    `${API_BASE}/rest/v1/games?studio_id=eq.${studioId}&${idQuery}&select=id,name,slug`,
+    {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        apikey: config.supabaseAnonKey
+      }
+    }
+  );
+  if (!response.ok) {
+    return null;
+  }
+  const data = await response.json();
+  return data[0] || null;
+}
+
+// src/commands/spine/upload.ts
+var uploadCommand = new Command5("upload").description("Upload Spine files to Playtagon").argument("<directory>", "Directory containing Spine files").option("-s, --studio <studio>", "Studio ID or slug (uses default if set)").option("-g, --game <game>", "Game ID or slug (uses default if set)").option("-n, --name <name>", "Asset name (defaults to directory name)").option("--slug <slug>", "Custom slug for the asset").option("--batch", "Enable batch mode for multiple skeletons sharing atlas").option("--dry-run", "Validate only, do not upload").option("--description <text>", "Asset description").option("--tags <tags>", "Comma-separated tags").action(async (directory, options) => {
+  if (!credentials.isLoggedIn()) {
+    logger.error("Not logged in.");
+    logger.info(`Run ${logger.command("playtagon login")} first.`);
+    process.exit(1);
+  }
+  const studioOption = options.studio || config.defaultStudio;
+  const gameOption = options.game || config.defaultGame;
+  if (!studioOption) {
+    logger.error("Studio is required.");
+    logger.info(`Either provide ${logger.command("--studio <slug>")} or set a default:`);
+    logger.info(`  ${logger.command("playtagon config --studio <slug>")}`);
+    logger.info(`  ${logger.command("playtagon setup spine-integration --studio <slug>")}`);
+    process.exit(1);
+  }
+  const absolutePath = path4.resolve(directory);
+  const spinner = ora4("Validating files...").start();
+  let validation;
+  try {
+    validation = validateDirectory(absolutePath, options.batch);
+  } catch (error) {
+    spinner.fail("Validation failed");
+    logger.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+  if (!validation.isValid) {
+    spinner.fail("Validation failed");
+    printValidationErrors(validation);
+    process.exit(1);
+  }
+  spinner.succeed(`Validated ${validation.assets.length} asset(s)`);
+  spinner.start("Resolving studio...");
+  const studio = await resolveStudio(studioOption);
+  if (!studio) {
+    spinner.fail("Studio not found");
+    logger.error(`Studio "${studioOption}" not found or you don't have access.`);
+    process.exit(1);
+  }
+  spinner.succeed(`Studio: ${studio.name}`);
+  let game = null;
+  if (gameOption) {
+    spinner.start("Resolving game...");
+    game = await resolveGame(studio.id, gameOption);
+    if (!game) {
+      spinner.fail("Game not found");
+      logger.error(`Game "${gameOption}" not found in studio "${studio.name}".`);
+      process.exit(1);
+    }
+    spinner.succeed(`Game: ${game.name}`);
+  }
+  const assetName = options.name || path4.basename(absolutePath);
+  let slug = options.slug || generateSlug(assetName);
+  if (!validateSlug(slug)) {
+    logger.error(`Invalid slug: "${slug}". Use lowercase letters, numbers, and hyphens only.`);
+    process.exit(1);
+  }
+  console.log();
+  logger.header("Upload Summary");
+  logger.item("Directory", directory);
+  logger.item("Studio", studio.name);
+  if (game) logger.item("Game", game.name);
+  logger.item("Name", assetName);
+  logger.item("Slug", slug);
+  logger.item("Size", formatFileSize(validation.totalSize));
+  if (validation.isBatchMode) {
+    logger.item("Mode", "Batch");
+    logger.item("Skeletons", String(validation.assets.length));
+  }
+  if (options.dryRun) {
+    console.log();
+    logger.success("Dry run complete. No files were uploaded.");
+    return;
+  }
+  console.log();
+  spinner.start("Uploading...");
+  try {
+    const formData = await buildFormData(validation, {
+      studioId: studio.id,
+      gameId: game?.id,
+      name: assetName,
+      slug,
+      description: options.description,
+      tags: options.tags?.split(",").map((t) => t.trim()),
+      batchMode: validation.isBatchMode
+    });
+    const result = await uploadSpineAsset(formData);
+    if (result.success) {
+      spinner.succeed("Upload complete!");
+      console.log();
+      if (result.assets && result.assets.length > 1) {
+        logger.header("Uploaded Assets");
+        for (const asset of result.assets) {
+          console.log(`  ${logger.value(asset.name)} (${asset.slug})`);
+          console.log(`    ID: ${asset.id}`);
+          console.log(`    Status: ${asset.status}`);
+        }
+      } else if (result.asset) {
+        logger.header("Uploaded Asset");
+        logger.item("ID", result.asset.id);
+        logger.item("Name", result.asset.name);
+        logger.item("Slug", result.asset.slug);
+        logger.item("Status", result.asset.status);
+      }
+    } else {
+      spinner.fail("Upload failed");
+      logger.error(result.error || "Unknown error");
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail("Upload failed");
+    logger.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+async function buildFormData(validation, options) {
+  const formData = new FormData();
+  formData.append("studioId", options.studioId);
+  if (options.gameId) formData.append("gameId", options.gameId);
+  formData.append("name", options.name);
+  formData.append("slug", options.slug);
+  if (options.description) formData.append("description", options.description);
+  if (options.tags) formData.append("tags", JSON.stringify(options.tags));
+  if (options.batchMode) formData.append("batchMode", "true");
+  const filesAdded = /* @__PURE__ */ new Set();
+  for (const asset of validation.assets) {
+    const filePath = asset.skeleton.path;
+    if (!filesAdded.has(filePath)) {
+      const buffer = fs3.readFileSync(filePath);
+      const blob = new Blob([buffer]);
+      formData.append("files", blob, getBaseName(filePath));
+      filesAdded.add(filePath);
+    }
+  }
+  if (validation.sharedAtlas && !filesAdded.has(validation.sharedAtlas)) {
+    const buffer = fs3.readFileSync(validation.sharedAtlas);
+    const blob = new Blob([buffer]);
+    formData.append("files", blob, getBaseName(validation.sharedAtlas));
+    filesAdded.add(validation.sharedAtlas);
+  }
+  for (const texturePath of validation.sharedTextures) {
+    if (!filesAdded.has(texturePath)) {
+      const buffer = fs3.readFileSync(texturePath);
+      const blob = new Blob([buffer]);
+      formData.append("files", blob, getBaseName(texturePath));
+      filesAdded.add(texturePath);
+    }
+  }
+  for (const asset of validation.assets) {
+    if (asset.atlasPath && !filesAdded.has(asset.atlasPath)) {
+      const buffer = fs3.readFileSync(asset.atlasPath);
+      const blob = new Blob([buffer]);
+      formData.append("files", blob, getBaseName(asset.atlasPath));
+      filesAdded.add(asset.atlasPath);
+    }
+    for (const texturePath of asset.texturePaths) {
+      if (!filesAdded.has(texturePath)) {
+        const buffer = fs3.readFileSync(texturePath);
+        const blob = new Blob([buffer]);
+        formData.append("files", blob, getBaseName(texturePath));
+        filesAdded.add(texturePath);
+      }
+    }
+  }
+  return formData;
+}
+function printValidationErrors(validation) {
+  const errors = validation.issues.filter((i) => i.type === "error");
+  console.log();
+  for (const error of errors) {
+    logger.validationError(
+      error.file ? `${error.file}: ${error.message}` : error.message,
+      error.detail
+    );
+  }
+  console.log();
+  logger.info(`Run ${logger.command("playtagon spine validate <dir>")} for full report.`);
+}
+
+// src/commands/spine/preset.ts
+import { Command as Command6 } from "commander";
+var presetCommand = new Command6("preset").description("Output Spine export preset JSON for consistent exports").option("--pretty", "Pretty print JSON (default: true)", true).option("--compact", "Output compact JSON").action((options) => {
+  const pretty = !options.compact;
+  if (pretty) {
+    console.error(logger.info("Spine Export Preset for Playtagon Platform"));
+    console.error();
+    console.error("Usage:");
+    console.error("  playtagon spine preset > playtagon-export.json");
+    console.error("  Import this file into Spine Editor as an export preset.");
+    console.error();
+  }
+  const json = pretty ? JSON.stringify(SPINE_EXPORT_PRESET, null, 2) : JSON.stringify(SPINE_EXPORT_PRESET);
+  console.log(json);
+});
+
+// src/commands/spine/index.ts
+var spineCommand = new Command7("spine").description("Manage Spine animation assets").addCommand(validateCommand).addCommand(uploadCommand).addCommand(presetCommand);
+
+// src/commands/setup.ts
+import { Command as Command8 } from "commander";
+import * as fs4 from "fs";
+import * as path5 from "path";
+import * as os from "os";
+import ora5 from "ora";
+var PLAYTAGON_DIR = path5.join(os.homedir(), ".playtagon");
+var setupCommand = new Command8("setup").description("Set up integrations").addCommand(spineIntegrationCommand());
+function spineIntegrationCommand() {
+  return new Command8("spine-integration").description("Set up automatic Spine Editor to Platform upload").option("-s, --studio <studio>", "Default studio for uploads").option("-g, --game <game>", "Default game for uploads").option("--force", "Overwrite existing setup files").action(async (options) => {
+    if (!credentials.isLoggedIn()) {
+      logger.error("Not logged in.");
+      logger.info(`Run ${logger.command("playtagon login")} first.`);
+      process.exit(1);
+    }
+    const spinner = ora5("Checking authentication...").start();
+    const user = await getCurrentUser();
+    if (!user) {
+      spinner.fail("Session expired");
+      logger.info(`Run ${logger.command("playtagon login")} to re-authenticate.`);
+      process.exit(1);
+    }
+    spinner.succeed(`Logged in as ${user.email}`);
+    let studioSlug = options.studio;
+    if (!studioSlug) {
+      spinner.start("Fetching studios...");
+      const studios = await getStudios();
+      spinner.stop();
+      if (studios.length === 0) {
+        logger.error("No studios found. Join or create a studio first.");
+        process.exit(1);
+      }
+      if (studios.length === 1) {
+        studioSlug = studios[0].slug;
+        logger.info(`Using studio: ${logger.value(studios[0].name)}`);
+      } else {
+        logger.header("Available Studios");
+        studios.forEach((s, i) => {
+          console.log(`  ${i + 1}. ${s.name} (${logger.value(s.slug)})`);
+        });
+        console.log();
+        logger.info(`Specify studio with ${logger.command("--studio <slug>")}`);
+        logger.info(`Example: ${logger.command(`playtagon setup spine-integration --studio ${studios[0].slug}`)}`);
+        process.exit(1);
+      }
+    }
+    spinner.start("Creating setup files...");
+    if (!fs4.existsSync(PLAYTAGON_DIR)) {
+      fs4.mkdirSync(PLAYTAGON_DIR, { recursive: true, mode: 448 });
+    }
+    const scriptPaths = generatePostExportScripts(studioSlug, options.game, options.force);
+    const presetPath = generateExportPreset(scriptPaths.sh, options.force);
+    spinner.succeed("Setup complete!");
+    console.log();
+    logger.header("Setup Complete");
+    console.log();
+    logger.info("Files created:");
+    console.log(`  ${logger.file(scriptPaths.sh)}`);
+    if (process.platform === "win32") {
+      console.log(`  ${logger.file(scriptPaths.bat)}`);
+    }
+    console.log(`  ${logger.file(presetPath)}`);
+    console.log();
+    logger.header("Next Steps");
+    console.log();
+    console.log("  1. Open Spine Editor");
+    console.log("  2. Go to File \u2192 Export...");
+    console.log("  3. Click the gear icon (\u2699) next to the preset dropdown");
+    console.log('  4. Click "Import" and select:');
+    console.log(`     ${logger.file(presetPath)}`);
+    console.log('  5. The preset "Upload to Playtagon" will be available');
+    console.log();
+    console.log("  Now when you export with this preset, files automatically");
+    console.log("  upload to Playtagon Platform!");
+    console.log();
+    let gameSlug = options.game;
+    if (gameSlug) {
+      spinner.start("Verifying game...");
+      const studios = await getStudios();
+      const studio = studios.find((s) => s.slug === studioSlug);
+      if (studio) {
+        const games = await getGames(studio.id);
+        const game = games.find(
+          (g) => g.slug === gameSlug || g.id === gameSlug || g.name === gameSlug
+        );
+        if (!game) {
+          spinner.fail("Game not found");
+          logger.error(`Game "${gameSlug}" not found in studio "${studioSlug}".`);
+          if (games.length > 0) {
+            console.log();
+            logger.info("Available games:");
+            games.forEach((g) => {
+              console.log(`  ${logger.value(g.slug)} - ${g.name}`);
+            });
+          }
+          process.exit(1);
+        }
+        gameSlug = game.slug;
+        spinner.succeed(`Game: ${game.name}`);
+      }
+    }
+    config.defaultStudio = studioSlug;
+    if (gameSlug) {
+      config.defaultGame = gameSlug;
+    }
+    if (gameSlug) {
+      logger.info(`Uploads will go to: ${logger.value(studioSlug)} / ${logger.value(gameSlug)}`);
+    } else {
+      logger.info(`Uploads will go to studio: ${logger.value(studioSlug)}`);
+      logger.info(`Add ${logger.command("--game <slug>")} to also set default game.`);
+    }
+    console.log();
+    logger.info("Defaults saved. You can change them later with:");
+    logger.info(`  ${logger.command("playtagon config --studio <slug> --game <slug>")}`);
+  });
+}
+function generatePostExportScripts(studioSlug, gameSlug, force = false) {
+  const shPath = path5.join(PLAYTAGON_DIR, "upload.sh");
+  const batPath = path5.join(PLAYTAGON_DIR, "upload.bat");
+  let uploadCmd = `playtagon spine upload "$1" --studio ${studioSlug}`;
+  if (gameSlug) {
+    uploadCmd += ` --game ${gameSlug}`;
+  }
+  const shScript = `#!/bin/bash
+# Playtagon Spine Upload Script
+# Auto-generated by: playtagon setup spine-integration
+#
+# This script is called by Spine Editor after export.
+# It uploads the exported files to Playtagon Platform.
+
+set -e
+
+EXPORT_DIR="$1"
+
+if [ -z "$EXPORT_DIR" ]; then
+  echo "Error: No export directory provided"
+  exit 1
+fi
+
+echo "Uploading to Playtagon..."
+${uploadCmd}
+
+# macOS notification (optional)
+if command -v osascript &> /dev/null; then
+  osascript -e 'display notification "Spine export uploaded successfully" with title "Playtagon"' 2>/dev/null || true
+fi
+
+# Linux notification (optional)
+if command -v notify-send &> /dev/null; then
+  notify-send "Playtagon" "Spine export uploaded successfully" 2>/dev/null || true
+fi
+
+echo "Upload complete!"
+`;
+  let uploadCmdWin = `playtagon spine upload "%~1" --studio ${studioSlug}`;
+  if (gameSlug) {
+    uploadCmdWin += ` --game ${gameSlug}`;
+  }
+  const batScript = `@echo off
+REM Playtagon Spine Upload Script
+REM Auto-generated by: playtagon setup spine-integration
+REM
+REM This script is called by Spine Editor after export.
+REM It uploads the exported files to Playtagon Platform.
+
+set EXPORT_DIR=%~1
+
+if "%EXPORT_DIR%"=="" (
+  echo Error: No export directory provided
+  exit /b 1
+)
+
+echo Uploading to Playtagon...
+${uploadCmdWin}
+
+REM Windows notification (PowerShell)
+powershell -Command "& {Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show('Spine export uploaded successfully', 'Playtagon', 'OK', 'Information')}" 2>nul
+
+echo Upload complete!
+`;
+  if (!fs4.existsSync(shPath) || force) {
+    fs4.writeFileSync(shPath, shScript, { mode: 493 });
+  } else {
+    logger.warn(`${shPath} already exists. Use --force to overwrite.`);
+  }
+  if (!fs4.existsSync(batPath) || force) {
+    fs4.writeFileSync(batPath, batScript);
+  }
+  return { sh: shPath, bat: batPath };
+}
+function generateExportPreset(scriptPath, force = false) {
+  const presetPath = path5.join(PLAYTAGON_DIR, "playtagon-spine-preset.export.json");
+  const preset = {
+    ...SPINE_EXPORT_PRESET,
+    name: "Upload to Playtagon",
+    postScript: process.platform === "win32" ? `"${scriptPath.replace(".sh", ".bat")}" "{output}"` : `"${scriptPath}" "{output}"`
+  };
+  if (!fs4.existsSync(presetPath) || force) {
+    fs4.writeFileSync(presetPath, JSON.stringify(preset, null, 2));
+  } else {
+    logger.warn(`${presetPath} already exists. Use --force to overwrite.`);
+  }
+  return presetPath;
+}
+
+// src/commands/config.ts
+import { Command as Command9 } from "commander";
+import ora6 from "ora";
+var configCommand = new Command9("config").description("View or set CLI configuration").option("-s, --studio <studio>", "Set default studio").option("-g, --game <game>", "Set default game").option("--clear", "Clear all default settings").action(async (options) => {
+  if (options.clear) {
+    config.defaultStudio = void 0;
+    config.defaultGame = void 0;
+    logger.success("Default settings cleared.");
+    return;
+  }
+  if (options.studio) {
+    if (!credentials.isLoggedIn()) {
+      logger.error("Not logged in.");
+      logger.info(`Run ${logger.command("playtagon login")} first.`);
+      process.exit(1);
+    }
+    const spinner = ora6("Verifying studio...").start();
+    const studios = await getStudios();
+    const studio = studios.find(
+      (s) => s.slug === options.studio || s.id === options.studio || s.name === options.studio
+    );
+    if (!studio) {
+      spinner.fail("Studio not found");
+      logger.error(`Studio "${options.studio}" not found or you don't have access.`);
+      console.log();
+      logger.info("Available studios:");
+      studios.forEach((s) => {
+        console.log(`  ${logger.value(s.slug)} - ${s.name}`);
+      });
+      process.exit(1);
+    }
+    spinner.succeed(`Default studio set: ${studio.name} (${studio.slug})`);
+    config.defaultStudio = studio.slug;
+  }
+  if (options.game) {
+    if (!credentials.isLoggedIn()) {
+      logger.error("Not logged in.");
+      logger.info(`Run ${logger.command("playtagon login")} first.`);
+      process.exit(1);
+    }
+    const studioSlug = options.studio || config.defaultStudio;
+    if (!studioSlug) {
+      logger.error("Studio is required to set default game.");
+      logger.info(`Either provide ${logger.command("--studio <slug>")} or set a default studio first.`);
+      process.exit(1);
+    }
+    const spinner = ora6("Verifying game...").start();
+    const studios = await getStudios();
+    const studio = studios.find(
+      (s) => s.slug === studioSlug || s.id === studioSlug || s.name === studioSlug
+    );
+    if (!studio) {
+      spinner.fail("Studio not found");
+      process.exit(1);
+    }
+    const games = await getGames(studio.id);
+    const game = games.find(
+      (g) => g.slug === options.game || g.id === options.game || g.name === options.game
+    );
+    if (!game) {
+      spinner.fail("Game not found");
+      logger.error(`Game "${options.game}" not found in studio "${studio.name}".`);
+      console.log();
+      if (games.length > 0) {
+        logger.info("Available games:");
+        games.forEach((g) => {
+          console.log(`  ${logger.value(g.slug)} - ${g.name}`);
+        });
+      } else {
+        logger.info("No games in this studio yet.");
+      }
+      process.exit(1);
+    }
+    spinner.succeed(`Default game set: ${game.name} (${game.slug})`);
+    config.defaultGame = game.slug;
+  }
+  if (!options.studio && !options.game && !options.clear) {
+    logger.header("Current Configuration");
+    console.log();
+    logger.item("Config file", config.path);
+    console.log();
+    const currentStudio = config.defaultStudio;
+    const currentGame = config.defaultGame;
+    if (currentStudio || currentGame) {
+      logger.header("Default Upload Target");
+      if (currentStudio) {
+        logger.item("Studio", currentStudio);
+      }
+      if (currentGame) {
+        logger.item("Game", currentGame);
+      }
+      console.log();
+      logger.info("These defaults are used when --studio/--game are not provided.");
+      console.log();
+      logger.info(`To change: ${logger.command("playtagon config --studio <slug> --game <slug>")}`);
+      logger.info(`To clear:  ${logger.command("playtagon config --clear")}`);
+    } else {
+      logger.info("No default studio or game set.");
+      console.log();
+      logger.info(`Set defaults: ${logger.command("playtagon config --studio <slug> --game <slug>")}`);
+      logger.info(`Or run setup: ${logger.command("playtagon setup spine-integration")}`);
+    }
+  }
+});
+
+// src/index.ts
+var program = new Command10();
+program.name("playtagon").description("Playtagon CLI - Upload and manage game assets").version("0.1.0");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(spineCommand);
+program.addCommand(setupCommand);
+program.addCommand(configCommand);
+program.parse();
+//# sourceMappingURL=index.js.map