@playtagon/cli 0.2.8 → 0.3.1

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 
 // src/commands/login.ts
 import { Command } from "commander";
@@ -17,7 +17,7 @@ import * as crypto from "crypto";
 // src/lib/config.ts
 import Conf from "conf";
 var DEFAULT_SUPABASE_URL = process.env.PLAYTAGON_SUPABASE_URL || "https://pthbeazcwnhjljwksuae.supabase.co";
-var DEFAULT_SUPABASE_ANON_KEY = process.env.PLAYTAGON_SUPABASE_ANON_KEY || "sb_publishable_N6Bokn1e6ehOsKqr6quX2g_gvj7xVfy";
+var DEFAULT_SUPABASE_ANON_KEY = process.env.PLAYTAGON_SUPABASE_ANON_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InB0aGJlYXpjd25oamxqd2tzdWFlIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjcxMjIzNDEsImV4cCI6MjA4MjY5ODM0MX0.ls0hO-UigKnl9cj2NEkxjQL4TnijkIG50iImqZIThVc";
 var configStore = new Conf({
   projectName: "playtagon",
   configFileMode: 384,
@@ -244,7 +244,7 @@ async function loginWithEmail(email, password) {
   });
 }
 async function loginWithBrowser() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const port = 19419;
     const redirectUri = `http://localhost:${port}/callback`;
     const codeVerifier = generateCodeVerifier();
@@ -274,7 +274,7 @@ async function loginWithBrowser() {
           res.writeHead(200, { "Content-Type": "text/html" });
           res.end(getErrorHtml(errorDescription || error));
           cleanup();
-          resolve4({ success: false, error: errorDescription || error });
+          resolve5({ success: false, error: errorDescription || error });
           return;
         }
         const accessToken = url.searchParams.get("access_token");
@@ -288,7 +288,7 @@ async function loginWithBrowser() {
           res.writeHead(200, { "Content-Type": "text/html" });
           res.end(getSuccessHtml(""));
           cleanup();
-          resolve4({ success: true });
+          resolve5({ success: true });
           return;
         }
         const code = url.searchParams.get("code");
@@ -300,7 +300,7 @@ async function loginWithBrowser() {
               res.writeHead(200, { "Content-Type": "text/html" });
               res.end(getErrorHtml(exchangeError?.message || "Failed to exchange code"));
               cleanup();
-              resolve4({ success: false, error: exchangeError?.message || "Failed to exchange code" });
+              resolve5({ success: false, error: exchangeError?.message || "Failed to exchange code" });
               return;
             }
             credentials.save({
@@ -313,19 +313,19 @@ async function loginWithBrowser() {
             res.writeHead(200, { "Content-Type": "text/html" });
             res.end(getSuccessHtml(data.user?.email || ""));
             cleanup();
-            resolve4({ success: true });
+            resolve5({ success: true });
           } catch (err) {
             res.writeHead(200, { "Content-Type": "text/html" });
             res.end(getErrorHtml(err instanceof Error ? err.message : "Unknown error"));
             cleanup();
-            resolve4({ success: false, error: err instanceof Error ? err.message : "Unknown error" });
+            resolve5({ success: false, error: err instanceof Error ? err.message : "Unknown error" });
           }
           return;
         }
         res.writeHead(200, { "Content-Type": "text/html" });
         res.end(getErrorHtml("No authorization token received"));
         cleanup();
-        resolve4({ success: false, error: "No authorization token received" });
+        resolve5({ success: false, error: "No authorization token received" });
       } else {
         res.writeHead(404);
         res.end("Not found");
@@ -337,15 +337,15 @@ async function loginWithBrowser() {
     server.on("error", (err) => {
       if (err.code === "EADDRINUSE") {
         cleanup();
-        resolve4({ success: false, error: `Port ${port} is already in use. Please close any applications using it.` });
+        resolve5({ success: false, error: `Port ${port} is already in use. Please close any applications using it.` });
       } else {
         cleanup();
-        resolve4({ success: false, error: err.message });
+        resolve5({ success: false, error: err.message });
       }
     });
     timeoutId = setTimeout(() => {
       cleanup();
-      resolve4({ success: false, error: "Authentication timed out. Please try again." });
+      resolve5({ success: false, error: "Authentication timed out. Please try again." });
     }, 5 * 60 * 1e3);
   });
 }
@@ -497,8 +497,8 @@ async function promptEmailLogin() {
     input: process.stdin,
     output: process.stdout
   });
-  const question = (prompt) => new Promise((resolve4) => {
-    rl.question(prompt, resolve4);
+  const question = (prompt) => new Promise((resolve5) => {
+    rl.question(prompt, resolve5);
   });
   try {
     const email = await question("Email: ");
@@ -590,7 +590,7 @@ async function browserLogin() {
   }
 }
 function questionHidden(prompt, rl) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const stdin = process.stdin;
     const stdout = process.stdout;
     stdout.write(prompt);
@@ -610,7 +610,7 @@ function questionHidden(prompt, rl) {
           }
           stdin.removeListener("data", onData);
           stdout.write("\n");
-          resolve4(password);
+          resolve5(password);
           break;
         case "":
           process.exit(1);
@@ -682,7 +682,7 @@ var whoamiCommand = new Command3("whoami").description("Show current logged in u
 });
 
 // src/commands/spine/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 
 // src/commands/spine/validate.ts
 import { Command as Command4 } from "commander";
@@ -698,14 +698,28 @@ 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"];
+var TEXTURE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".webp"];
 function discoverSpineFiles(directory) {
   const absolutePath = path.resolve(directory);
   if (!fs.existsSync(absolutePath)) {
-    throw new Error(`Directory not found: ${directory}`);
+    throw new Error(`Directory not found: ${absolutePath}
+
+Make sure you're pointing to a folder containing exported Spine files (.json, .atlas, .png), not a .spine project file.`);
   }
   if (!fs.statSync(absolutePath).isDirectory()) {
-    throw new Error(`Not a directory: ${directory}`);
+    const ext = path.extname(absolutePath).toLowerCase();
+    if (ext === ".spine") {
+      throw new Error(`Cannot upload .spine project files directly.
+
+You need to export from Spine Editor first:
+  1. Open ${path.basename(absolutePath)} in Spine Editor
+  2. Go to File \u2192 Export
+  3. Export as JSON with atlas
+  4. Upload the exported folder`);
+    }
+    throw new Error(`Not a directory: ${absolutePath}
+
+The upload command expects a folder containing exported Spine files (.json, .atlas, .png).`);
   }
   const files = fs.readdirSync(absolutePath);
   const skeletons = [];
@@ -764,8 +778,8 @@ function parseAtlasTextures(atlasPath) {
   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 (trimmed.endsWith(".png") || trimmed.endsWith(".jpg") || trimmed.endsWith(".jpeg") || trimmed.endsWith(".webp")) {
+      const texturePath = path.isAbsolute(trimmed) ? trimmed : path.join(atlasDir, trimmed);
       if (fs.existsSync(texturePath)) {
         textures.push(texturePath);
       }
@@ -807,8 +821,8 @@ function validateDirectory(directory, batchMode = false) {
   if (discovered.skeletons.length === 0) {
     issues.push({
       type: "error",
-      message: "No Spine skeleton files found",
-      detail: "Expected .json (Spine skeleton) or .skel files"
+      message: "No Spine skeleton files found in this directory",
+      detail: "Expected exported files: skeleton.json + skeleton.atlas + texture.png. Export from Spine Editor first (File \u2192 Export \u2192 JSON)."
     });
     return {
       assets: [],
@@ -1080,30 +1094,10 @@ function validateSlug(slug) {
 var SPINE_EXPORT_PRESET = {
   class: "export-json",
   name: "Playtagon Platform",
-  output: "{projectDir}/exports/{skeletonName}",
-  extension: ".json",
-  format: "json",
+  output: "{projectDir}/exports",
   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
-  }
+  pack: true
 };
 
 // src/commands/spine/validate.ts
@@ -1202,7 +1196,8 @@ async function uploadSpineAsset(formData) {
   const response = await fetch(`${API_BASE}/functions/v1/spine-upload`, {
     method: "POST",
     headers: {
-      Authorization: `Bearer ${token}`
+      Authorization: `Bearer ${token}`,
+      apikey: config.supabaseAnonKey
     },
     body: formData
   });
@@ -1306,6 +1301,37 @@ async function resolveGame(studioId, gameIdOrSlug) {
   const data = await response.json();
   return data[0] || null;
 }
+async function getSyncManifest(studioId, gameId, since) {
+  const token = getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run `playtagon login` first.");
+  }
+  const params = new URLSearchParams();
+  params.set("studioId", studioId);
+  if (gameId) params.set("gameId", gameId);
+  if (since) params.set("since", since);
+  const response = await fetch(
+    `${API_BASE}/functions/v1/spine-assets/sync?${params}`,
+    {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        apikey: config.supabaseAnonKey
+      }
+    }
+  );
+  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(`Failed to fetch sync manifest: ${errorMessage}`);
+  }
+  return response.json();
+}
 
 // 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) => {
@@ -1502,25 +1528,387 @@ var presetCommand = new Command6("preset").description("Output Spine export pres
   console.log(json);
 });
 
+// src/commands/spine/sync.ts
+import { Command as Command7 } from "commander";
+import * as fs4 from "fs";
+import * as path5 from "path";
+import ora5 from "ora";
+
+// src/lib/codegen.ts
+function pascalCase(str) {
+  return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"');
+}
+function generateAssetTypes(asset) {
+  const name = pascalCase(asset.slug);
+  const ext = asset.skeleton_format === "binary" ? ".skel" : ".json";
+  const animationNames = asset.animations.map((a) => a.name);
+  const skinNames = asset.skins.map((s) => s.name);
+  const eventNames = asset.events.map((e) => e.name);
+  return `// Auto-generated by @playtagon/cli
+// Do not edit manually - changes will be overwritten on next sync
+
+/**
+ * ${asset.name}
+ * @version ${asset.version}
+ */
+
+export const ${name}Animations = {
+${animationNames.map((n) => `  '${escapeString(n)}': '${escapeString(n)}',`).join("\n")}
+} as const;
+
+export type ${name}Animation = typeof ${name}Animations[keyof typeof ${name}Animations];
+
+export const ${name}Skins = {
+${skinNames.map((n) => `  '${escapeString(n)}': '${escapeString(n)}',`).join("\n")}
+} as const;
+
+export type ${name}Skin = typeof ${name}Skins[keyof typeof ${name}Skins];
+
+${eventNames.length > 0 ? `export const ${name}Events = {
+${eventNames.map((n) => `  '${escapeString(n)}': '${escapeString(n)}',`).join("\n")}
+} as const;
+
+export type ${name}Event = typeof ${name}Events[keyof typeof ${name}Events];
+` : `export const ${name}Events = {} as const;
+
+export type ${name}Event = never;
+`}
+export interface ${name}AnimationInfo {
+  name: ${name}Animation;
+  duration: number;
+}
+
+export const ${name}AnimationDurations: Record<${name}Animation, number> = {
+${asset.animations.map((a) => `  '${escapeString(a.name)}': ${a.duration},`).join("\n")}
+};
+
+export const ${name} = {
+  id: '${asset.slug}',
+  name: '${escapeString(asset.name)}',
+  version: ${asset.version},
+  skeleton: './${asset.slug}${ext}',
+  atlas: './${asset.slug}.atlas',
+  animations: ${name}Animations,
+  skins: ${name}Skins,
+  events: ${name}Events,
+  animationDurations: ${name}AnimationDurations,
+  defaultAnimation: '${escapeString(animationNames[0] || "idle")}' as ${name}Animation,
+  defaultSkin: '${escapeString(skinNames[0] || "default")}' as ${name}Skin,
+} as const;
+
+export type ${name}Config = typeof ${name};
+
+export default ${name};
+`;
+}
+function generateAssetStory(asset) {
+  const name = pascalCase(asset.slug);
+  const animationStories = asset.animations.map((anim) => {
+    return `<Story name="${escapeString(anim.name)}">
+  {#snippet template(args)}
+    <StoryPixiApp {assets}>
+      <SpineAnimation {...args} asset={${name}} animation="${escapeString(anim.name)}" />
+    </StoryPixiApp>
+  {/snippet}
+</Story>`;
+  }).join("\n\n");
+  return `<!-- Auto-generated by @playtagon/cli -->
+<!-- Do not edit manually - changes will be overwritten on next sync -->
+
+<script lang="ts" module>
+  import { defineMeta } from '@storybook/addon-svelte-csf';
+  import { SpineAnimation, createSpineAssets } from 'pixi-svelte';
+  import { StoryPixiApp } from 'components-storybook';
+  import ${name}, { ${name}Animations, ${name}Skins } from './index';
+
+  const { Story } = defineMeta({
+    title: 'Spine/${escapeString(asset.name)}',
+    args: {
+      width: 400,
+      height: 400,
+      x: 200,
+      y: 200,
+      loop: true,
+      speed: 1,
+    },
+    argTypes: {
+      animation: {
+        control: 'select',
+        options: Object.values(${name}Animations),
+        description: 'Animation to play',
+      },
+      skin: {
+        control: 'select',
+        options: Object.values(${name}Skins),
+        description: 'Skin to apply',
+      },
+      loop: {
+        control: 'boolean',
+        description: 'Whether to loop the animation',
+      },
+      speed: {
+        control: { type: 'range', min: 0.1, max: 3, step: 0.1 },
+        description: 'Playback speed multiplier',
+      },
+    },
+  });
+
+  // Create assets for Storybook - adjust baseUrl to match your asset serving path
+  const assets = createSpineAssets([${name}], '.');
+</script>
+
+<!-- Default story with all controls -->
+<Story name="Default">
+  {#snippet template(args)}
+    <StoryPixiApp {assets}>
+      <SpineAnimation
+        {...args}
+        asset={${name}}
+        animation={args.animation ?? ${name}.defaultAnimation}
+        skin={args.skin ?? ${name}.defaultSkin}
+      />
+    </StoryPixiApp>
+  {/snippet}
+</Story>
+
+<!-- Individual animation stories -->
+${animationStories}
+`;
+}
+function generateManifest(slugs) {
+  const imports = slugs.map((slug) => {
+    const name = pascalCase(slug);
+    return `import ${name} from './${slug}';`;
+  }).join("\n");
+  const exports = slugs.map((slug) => {
+    const name = pascalCase(slug);
+    return `  ${name},`;
+  }).join("\n");
+  const reexports = slugs.map((slug) => {
+    const name = pascalCase(slug);
+    return `export * from './${slug}';`;
+  }).join("\n");
+  return `// Auto-generated by @playtagon/cli
+// Do not edit manually - changes will be overwritten on next sync
+
+${imports}
+
+export const SpineAssets = {
+${exports}
+} as const;
+
+export type SpineAssetName = keyof typeof SpineAssets;
+
+// Re-export all individual assets
+${reexports}
+
+export default SpineAssets;
+`;
+}
+
+// src/commands/spine/sync.ts
+var syncCommand = new Command7("sync").description("Sync approved Spine assets to local project").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("-o, --output <dir>", "Output directory", "./src/assets/spine").option("--types", "Generate TypeScript types (default: true)", true).option("--no-types", "Skip TypeScript type generation").option("--stories", "Generate Storybook stories (default: true)", true).option("--no-stories", "Skip Storybook story generation").option("--assets <slugs>", "Comma-separated asset slugs to sync (default: all)").option("--force", "Overwrite local changes").option("--dry-run", "Show what would be synced without making changes").action(async (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>")}`);
+    process.exit(1);
+  }
+  const outputDir = path5.resolve(options.output);
+  const manifestPath = path5.join(outputDir, ".sync-manifest.json");
+  const spinner = ora5("Resolving studio...").start();
+  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}`);
+  }
+  let existingManifest = null;
+  let since;
+  if (fs4.existsSync(manifestPath) && !options.force) {
+    try {
+      existingManifest = JSON.parse(fs4.readFileSync(manifestPath, "utf-8"));
+      if (existingManifest && existingManifest.studioId === studio.id) {
+        since = existingManifest.syncedAt;
+        logger.info(`Incremental sync from ${new Date(since).toLocaleString()}`);
+      }
+    } catch {
+    }
+  }
+  spinner.start("Fetching asset manifest...");
+  let manifest;
+  try {
+    manifest = await getSyncManifest(studio.id, game?.id, options.force ? void 0 : since);
+  } catch (error) {
+    spinner.fail("Failed to fetch manifest");
+    logger.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+  const assets = manifest.assets;
+  let assetsToSync = assets;
+  if (options.assets) {
+    const requestedSlugs = options.assets.split(",").map((s) => s.trim());
+    assetsToSync = assets.filter((a) => requestedSlugs.includes(a.slug));
+    const found = assetsToSync.map((a) => a.slug);
+    const notFound = requestedSlugs.filter((s) => !found.includes(s));
+    if (notFound.length > 0) {
+      logger.warn(`Assets not found (or not approved): ${notFound.join(", ")}`);
+    }
+  }
+  if (assetsToSync.length === 0) {
+    spinner.succeed("No assets to sync");
+    logger.info("All assets are up to date or no approved assets found.");
+    return;
+  }
+  spinner.succeed(`Found ${assetsToSync.length} asset(s) to sync`);
+  const totalSize = assetsToSync.reduce((sum, a) => sum + a.total_size_bytes, 0);
+  console.log();
+  logger.header("Sync Summary");
+  logger.item("Studio", studio.name);
+  if (game) logger.item("Game", game.name);
+  logger.item("Output", outputDir);
+  logger.item("Assets", String(assetsToSync.length));
+  logger.item("Total Size", formatFileSize(totalSize));
+  logger.item("TypeScript Types", options.types ? "Yes" : "No");
+  logger.item("Storybook Stories", options.stories ? "Yes" : "No");
+  console.log();
+  logger.header("Assets");
+  for (const asset of assetsToSync) {
+    console.log(`  ${logger.value(asset.name)} (${asset.slug}) v${asset.version}`);
+  }
+  if (options.dryRun) {
+    console.log();
+    logger.success("Dry run complete. No files were written.");
+    return;
+  }
+  if (!fs4.existsSync(outputDir)) {
+    fs4.mkdirSync(outputDir, { recursive: true });
+  }
+  console.log();
+  const syncedAssets = {};
+  for (const asset of assetsToSync) {
+    spinner.start(`Syncing ${asset.name}...`);
+    try {
+      const assetDir = path5.join(outputDir, asset.slug);
+      if (!fs4.existsSync(assetDir)) {
+        fs4.mkdirSync(assetDir, { recursive: true });
+      }
+      const skeletonExt = asset.skeleton_format === "binary" ? ".skel" : ".json";
+      const skeletonPath = path5.join(assetDir, `${asset.slug}${skeletonExt}`);
+      await downloadFile(asset.skeleton_url, skeletonPath);
+      const atlasPath = path5.join(assetDir, `${asset.slug}.atlas`);
+      await downloadFile(asset.atlas_url, atlasPath);
+      for (const textureUrl of asset.texture_urls) {
+        const textureName = path5.basename(new URL(textureUrl).pathname);
+        const texturePath = path5.join(assetDir, textureName);
+        await downloadFile(textureUrl, texturePath);
+      }
+      if (options.types) {
+        const typesContent = generateAssetTypes(asset);
+        const typesPath = path5.join(assetDir, "index.ts");
+        fs4.writeFileSync(typesPath, typesContent);
+      }
+      if (options.stories) {
+        const storyContent = generateAssetStory(asset);
+        const storyPath = path5.join(assetDir, `${pascalCase2(asset.slug)}.stories.svelte`);
+        fs4.writeFileSync(storyPath, storyContent);
+      }
+      syncedAssets[asset.slug] = {
+        id: asset.id,
+        version: asset.version,
+        checksum: generateChecksum(asset),
+        updatedAt: asset.updated_at
+      };
+      spinner.succeed(`Synced ${asset.name}`);
+    } catch (error) {
+      spinner.fail(`Failed to sync ${asset.name}`);
+      logger.error(error instanceof Error ? error.message : "Unknown error");
+    }
+  }
+  const finalAssets = {
+    ...existingManifest?.assets || {},
+    ...syncedAssets
+  };
+  if (options.types) {
+    spinner.start("Generating manifest...");
+    const manifestContent = generateManifest(Object.keys(finalAssets));
+    fs4.writeFileSync(path5.join(outputDir, "manifest.ts"), manifestContent);
+    spinner.succeed("Generated manifest.ts");
+  }
+  const newManifest = {
+    studioId: studio.id,
+    gameId: game?.id,
+    syncedAt: manifest.syncedAt,
+    assets: finalAssets
+  };
+  fs4.writeFileSync(manifestPath, JSON.stringify(newManifest, null, 2));
+  console.log();
+  logger.success(`Synced ${Object.keys(syncedAssets).length} asset(s) to ${outputDir}`);
+});
+async function downloadFile(url, destPath) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.status} ${response.statusText}`);
+  }
+  const buffer = await response.arrayBuffer();
+  fs4.writeFileSync(destPath, Buffer.from(buffer));
+}
+function generateChecksum(asset) {
+  const data = `${asset.id}:${asset.version}:${asset.updated_at}`;
+  let hash = 0;
+  for (let i = 0; i < data.length; i++) {
+    const char = data.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16);
+}
+function pascalCase2(str) {
+  return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+
 // src/commands/spine/index.ts
-var spineCommand = new Command7("spine").description("Manage Spine animation assets").addCommand(validateCommand).addCommand(uploadCommand).addCommand(presetCommand);
+var spineCommand = new Command8("spine").description("Manage Spine animation assets").addCommand(validateCommand).addCommand(uploadCommand).addCommand(presetCommand).addCommand(syncCommand);
 
 // src/commands/setup.ts
-import { Command as Command8 } from "commander";
-import * as fs4 from "fs";
-import * as path5 from "path";
+import { Command as Command9 } from "commander";
+import * as fs5 from "fs";
+import * as path6 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());
+import { execFile } from "child_process";
+import ora6 from "ora";
+var PLAYTAGON_DIR = path6.join(os.homedir(), ".playtagon");
+var setupCommand = new Command9("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) => {
+  return new Command9("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 spinner = ora6("Checking authentication...").start();
     const user = await getCurrentUser();
     if (!user) {
       spinner.fail("Session expired");
@@ -1552,8 +1940,8 @@ function spineIntegrationCommand() {
       }
     }
     spinner.start("Creating setup files...");
-    if (!fs4.existsSync(PLAYTAGON_DIR)) {
-      fs4.mkdirSync(PLAYTAGON_DIR, { recursive: true, mode: 448 });
+    if (!fs5.existsSync(PLAYTAGON_DIR)) {
+      fs5.mkdirSync(PLAYTAGON_DIR, { recursive: true, mode: 448 });
     }
     const scriptPaths = generatePostExportScripts(studioSlug, options.game, options.force);
     const presetPath = generateExportPreset(scriptPaths.sh, options.force);
@@ -1573,13 +1961,13 @@ function spineIntegrationCommand() {
     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('  4. Click "Import" and select the preset file from the folder that just opened');
     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();
+    openFolder(PLAYTAGON_DIR);
     let gameSlug = options.game;
     if (gameSlug) {
       spinner.start("Verifying game...");
@@ -1622,8 +2010,8 @@ function spineIntegrationCommand() {
   });
 }
 function generatePostExportScripts(studioSlug, gameSlug, force = false) {
-  const shPath = path5.join(PLAYTAGON_DIR, "upload.sh");
-  const batPath = path5.join(PLAYTAGON_DIR, "upload.bat");
+  const shPath = path6.join(PLAYTAGON_DIR, "upload.sh");
+  const batPath = path6.join(PLAYTAGON_DIR, "upload.bat");
   let uploadCmd = `playtagon spine upload "$1" --studio ${studioSlug}`;
   if (gameSlug) {
     uploadCmd += ` --game ${gameSlug}`;
@@ -1685,35 +2073,55 @@ powershell -Command "& {Add-Type -AssemblyName System.Windows.Forms; [System.Win
 
 echo Upload complete!
 `;
-  if (!fs4.existsSync(shPath) || force) {
-    fs4.writeFileSync(shPath, shScript, { mode: 493 });
+  if (!fs5.existsSync(shPath) || force) {
+    fs5.writeFileSync(shPath, shScript, { mode: 493 });
   } else {
     logger.warn(`${shPath} already exists. Use --force to overwrite.`);
   }
-  if (!fs4.existsSync(batPath) || force) {
-    fs4.writeFileSync(batPath, batScript);
+  if (!fs5.existsSync(batPath) || force) {
+    fs5.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 presetPath = path6.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));
+  if (!fs5.existsSync(presetPath) || force) {
+    fs5.writeFileSync(presetPath, JSON.stringify(preset, null, 2));
   } else {
     logger.warn(`${presetPath} already exists. Use --force to overwrite.`);
   }
   return presetPath;
 }
+function openFolder(folderPath) {
+  const platform = process.platform;
+  let cmd;
+  let args;
+  if (platform === "darwin") {
+    cmd = "open";
+    args = [folderPath];
+  } else if (platform === "win32") {
+    cmd = "explorer";
+    args = [folderPath];
+  } else {
+    cmd = "xdg-open";
+    args = [folderPath];
+  }
+  execFile(cmd, args, (error) => {
+    if (error) {
+      logger.debug(`Could not open folder: ${error.message}`);
+    }
+  });
+}
 
 // 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) => {
+import { Command as Command10 } from "commander";
+import ora7 from "ora";
+var configCommand = new Command10("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;
@@ -1726,7 +2134,7 @@ var configCommand = new Command9("config").description("View or set CLI configur
       logger.info(`Run ${logger.command("playtagon login")} first.`);
       process.exit(1);
     }
-    const spinner = ora6("Verifying studio...").start();
+    const spinner = ora7("Verifying studio...").start();
     const studios = await getStudios();
     const studio = studios.find(
       (s) => s.slug === options.studio || s.id === options.studio || s.name === options.studio
@@ -1756,7 +2164,7 @@ var configCommand = new Command9("config").description("View or set CLI configur
       logger.info(`Either provide ${logger.command("--studio <slug>")} or set a default studio first.`);
       process.exit(1);
     }
-    const spinner = ora6("Verifying game...").start();
+    const spinner = ora7("Verifying game...").start();
     const studios = await getStudios();
     const studio = studios.find(
       (s) => s.slug === studioSlug || s.id === studioSlug || s.name === studioSlug
@@ -1816,8 +2224,8 @@ var configCommand = new Command9("config").description("View or set CLI configur
 });
 
 // src/index.ts
-var program = new Command10();
-program.name("playtagon").description("Playtagon CLI - Upload and manage game assets").version("0.2.8");
+var program = new Command11();
+program.name("playtagon").description("Playtagon CLI - Upload and manage game assets").version("0.3.0");
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(whoamiCommand);