@playtagon/cli 0.3.5 → 0.4.1

package/README.md

@@ -30,7 +30,23 @@ playtagon logout
 
 ## Uploading Spine Assets
 
-### Basic Upload
+### Auto-Upload with File Watcher (Recommended)
+
+Start watching a directory for new exports. Files will automatically upload when you export from Spine Editor:
+
+```bash
+playtagon spine watch ./exports --studio my-studio --game my-game
+```
+
+This command runs in the background and automatically uploads files whenever Spine creates a new export. Just keep it running in a terminal while you work.
+
+**Options:**
+- `--batch` - Enable batch mode for multiple skeletons sharing one atlas
+- `--interval <seconds>` - Change check interval (default: 2 seconds)
+
+Press `Ctrl+C` to stop watching.
+
+### Manual Upload
 
 Upload a Spine asset directory to a specific studio and game:
 
@@ -157,7 +173,8 @@ The CLI tracks synced assets in `.sync-manifest.json`. Subsequent syncs only dow
 | `playtagon whoami` | Show current user info |
 | `playtagon setup` | Interactive setup wizard |
 | `playtagon config` | Manage configuration |
-| `playtagon spine upload` | Upload Spine assets |
+| `playtagon spine upload` | Upload Spine assets (manual) |
+| `playtagon spine watch` | Auto-upload on file changes (recommended) |
 | `playtagon spine validate` | Validate Spine files |
 | `playtagon spine preset` | Output export preset JSON |
 | `playtagon spine sync` | Sync approved assets with codegen |

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 
 // src/commands/login.ts
 import { Command } from "commander";
@@ -244,7 +244,7 @@ async function loginWithEmail(email, password) {
   });
 }
 async function loginWithBrowser() {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     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();
-          resolve5({ success: false, error: errorDescription || error });
+          resolve6({ 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();
-          resolve5({ success: true });
+          resolve6({ 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();
-              resolve5({ success: false, error: exchangeError?.message || "Failed to exchange code" });
+              resolve6({ 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();
-            resolve5({ success: true });
+            resolve6({ success: true });
           } catch (err) {
             res.writeHead(200, { "Content-Type": "text/html" });
             res.end(getErrorHtml(err instanceof Error ? err.message : "Unknown error"));
             cleanup();
-            resolve5({ success: false, error: err instanceof Error ? err.message : "Unknown error" });
+            resolve6({ 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();
-        resolve5({ success: false, error: "No authorization token received" });
+        resolve6({ 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();
-        resolve5({ success: false, error: `Port ${port} is already in use. Please close any applications using it.` });
+        resolve6({ success: false, error: `Port ${port} is already in use. Please close any applications using it.` });
       } else {
         cleanup();
-        resolve5({ success: false, error: err.message });
+        resolve6({ success: false, error: err.message });
       }
     });
     timeoutId = setTimeout(() => {
       cleanup();
-      resolve5({ success: false, error: "Authentication timed out. Please try again." });
+      resolve6({ 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((resolve5) => {
-    rl.question(prompt, resolve5);
+  const question = (prompt) => new Promise((resolve6) => {
+    rl.question(prompt, resolve6);
   });
   try {
     const email = await question("Email: ");
@@ -590,7 +590,7 @@ async function browserLogin() {
   }
 }
 function questionHidden(prompt, rl) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     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");
-          resolve5(password);
+          resolve6(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 Command8 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/commands/spine/validate.ts
 import { Command as Command4 } from "commander";
@@ -1937,26 +1937,279 @@ function pascalCase2(str) {
   return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
 }
 
+// src/commands/spine/watch.ts
+import { Command as Command8 } from "commander";
+import * as fs5 from "fs";
+import * as path6 from "path";
+import ora6 from "ora";
+var watchCommand = new Command8("watch").description("Watch directory for new Spine exports and auto-upload").argument("<directory>", "Directory to watch for 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("--batch", "Enable batch mode for multiple skeletons sharing atlas").option("--interval <seconds>", "Check interval in seconds", "2").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>")}`);
+    process.exit(1);
+  }
+  const absolutePath = path6.resolve(directory);
+  if (!fs5.existsSync(absolutePath)) {
+    logger.error(`Directory not found: ${absolutePath}`);
+    process.exit(1);
+  }
+  const spinner = ora6("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}`);
+  }
+  const state = {
+    lastModified: /* @__PURE__ */ new Map(),
+    isUploading: false,
+    studioId: studio.id,
+    gameId: game?.id
+  };
+  await scanDirectory(absolutePath, state);
+  console.log();
+  logger.header("Watching for Spine Exports");
+  logger.item("Directory", absolutePath);
+  logger.item("Studio", studio.name);
+  if (game) logger.item("Game", game.name);
+  logger.item("Batch Mode", options.batch ? "Yes" : "No");
+  logger.item("Check Interval", `${options.interval}s`);
+  console.log();
+  logger.info("Watching for changes... (Press Ctrl+C to stop)");
+  console.log();
+  const intervalMs = parseInt(options.interval) * 1e3;
+  setInterval(async () => {
+    await checkForChanges(absolutePath, state, options.batch);
+  }, intervalMs);
+  process.on("SIGINT", () => {
+    console.log();
+    logger.success("Stopped watching.");
+    process.exit(0);
+  });
+});
+async function scanDirectory(directory, state) {
+  const files = getAllFiles(directory);
+  for (const file of files) {
+    const stats = fs5.statSync(file);
+    state.lastModified.set(file, stats.mtimeMs);
+  }
+}
+function getAllFiles(directory) {
+  const files = [];
+  try {
+    const entries = fs5.readdirSync(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path6.join(directory, entry.name);
+      if (entry.isFile()) {
+        const ext = path6.extname(entry.name).toLowerCase();
+        if ([".json", ".skel", ".atlas", ".png", ".jpg", ".jpeg", ".webp"].includes(ext)) {
+          files.push(fullPath);
+        }
+      } else if (entry.isDirectory()) {
+        files.push(...getAllFiles(fullPath));
+      }
+    }
+  } catch (error) {
+  }
+  return files;
+}
+async function checkForChanges(directory, state, batchMode) {
+  if (state.isUploading) {
+    return;
+  }
+  const files = getAllFiles(directory);
+  let hasChanges = false;
+  let newestChangeTime = 0;
+  for (const file of files) {
+    try {
+      const stats = fs5.statSync(file);
+      const lastModified = state.lastModified.get(file) || 0;
+      if (stats.mtimeMs > lastModified) {
+        hasChanges = true;
+        newestChangeTime = Math.max(newestChangeTime, stats.mtimeMs);
+      }
+    } catch (error) {
+    }
+  }
+  if (!hasChanges) {
+    return;
+  }
+  const timeSinceLastChange = Date.now() - newestChangeTime;
+  if (timeSinceLastChange < 3e3) {
+    return;
+  }
+  const hasAtlas = files.some((f) => f.endsWith(".atlas"));
+  const hasTextures = files.some((f) => /\.(png|jpg|jpeg|webp)$/i.test(f));
+  const hasSkeletons = files.some((f) => f.endsWith(".json") || f.endsWith(".skel"));
+  if (!hasAtlas || !hasTextures || !hasSkeletons) {
+    return;
+  }
+  for (const file of files) {
+    try {
+      const stats = fs5.statSync(file);
+      state.lastModified.set(file, stats.mtimeMs);
+    } catch (error) {
+    }
+  }
+  state.isUploading = true;
+  await uploadDirectory(directory, state, batchMode);
+  state.isUploading = false;
+}
+async function uploadDirectory(directory, state, batchMode) {
+  const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  console.log(`[${timestamp}] Changes detected, uploading...`);
+  const spinner = ora6("Validating files...").start();
+  let validation;
+  try {
+    validation = validateDirectory(directory, batchMode);
+  } catch (error) {
+    spinner.fail("Validation failed");
+    logger.error(error instanceof Error ? error.message : "Unknown error");
+    console.log();
+    return;
+  }
+  if (!validation.isValid) {
+    spinner.fail("Validation failed");
+    const errors = validation.issues.filter((i) => i.type === "error");
+    for (const error of errors) {
+      logger.validationError(
+        error.file ? `${error.file}: ${error.message}` : error.message
+      );
+    }
+    console.log();
+    return;
+  }
+  spinner.text = `Validated ${validation.assets.length} asset(s)`;
+  spinner.succeed();
+  const assetName = path6.basename(directory);
+  const slug = generateSlug(assetName);
+  if (!validateSlug(slug)) {
+    logger.error(`Invalid slug generated: "${slug}". Skipping upload.`);
+    console.log();
+    return;
+  }
+  spinner.start("Uploading...");
+  try {
+    const formData = await buildFormData2(validation, {
+      studioId: state.studioId,
+      gameId: state.gameId,
+      name: assetName,
+      slug,
+      batchMode: validation.isBatchMode
+    });
+    const result = await uploadSpineAsset(formData);
+    if (result.success) {
+      spinner.succeed("Upload complete!");
+      if (result.assets && result.assets.length > 1) {
+        console.log(`  Uploaded ${result.assets.length} assets (batch mode)`);
+        for (const asset of result.assets) {
+          console.log(`    ${asset.name} (${asset.slug}) - ${asset.status}`);
+        }
+      } else if (result.asset) {
+        console.log(`  ${result.asset.name} (${result.asset.slug}) - ${result.asset.status}`);
+      }
+      console.log();
+    } else {
+      spinner.fail("Upload failed");
+      logger.error(result.error || "Unknown error");
+      console.log();
+    }
+  } catch (error) {
+    spinner.fail("Upload failed");
+    logger.error(error instanceof Error ? error.message : "Unknown error");
+    console.log();
+  }
+}
+async function buildFormData2(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.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 = fs5.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 = fs5.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 = fs5.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 = fs5.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 = fs5.readFileSync(texturePath);
+        const blob = new Blob([buffer]);
+        formData.append("files", blob, getBaseName(texturePath));
+        filesAdded.add(texturePath);
+      }
+    }
+  }
+  return formData;
+}
+
 // src/commands/spine/index.ts
-var spineCommand = new Command8("spine").description("Manage Spine animation assets").addCommand(validateCommand).addCommand(uploadCommand).addCommand(presetCommand).addCommand(syncCommand);
+var spineCommand = new Command9("spine").description("Manage Spine animation assets").addCommand(validateCommand).addCommand(uploadCommand).addCommand(watchCommand).addCommand(presetCommand).addCommand(syncCommand);
 
 // src/commands/setup.ts
-import { Command as Command9 } from "commander";
-import * as fs5 from "fs";
-import * as path6 from "path";
+import { Command as Command10 } from "commander";
+import * as fs6 from "fs";
+import * as path7 from "path";
 import * as os from "os";
 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());
+import ora7 from "ora";
+var PLAYTAGON_DIR = path7.join(os.homedir(), ".playtagon");
+var setupCommand = new Command10("setup").description("Set up integrations").addCommand(spineIntegrationCommand());
 function spineIntegrationCommand() {
-  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) => {
+  return new Command10("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 = ora6("Checking authentication...").start();
+    const spinner = ora7("Checking authentication...").start();
     const user = await getCurrentUser();
     if (!user) {
       spinner.fail("Session expired");
@@ -1988,8 +2241,8 @@ function spineIntegrationCommand() {
       }
     }
     spinner.start("Creating setup files...");
-    if (!fs5.existsSync(PLAYTAGON_DIR)) {
-      fs5.mkdirSync(PLAYTAGON_DIR, { recursive: true, mode: 448 });
+    if (!fs6.existsSync(PLAYTAGON_DIR)) {
+      fs6.mkdirSync(PLAYTAGON_DIR, { recursive: true, mode: 448 });
     }
     const scriptPaths = generatePostExportScripts(studioSlug, options.game, options.force);
     const presetPath = generateExportPreset(scriptPaths.sh, options.force);
@@ -2058,8 +2311,8 @@ function spineIntegrationCommand() {
   });
 }
 function generatePostExportScripts(studioSlug, gameSlug, force = false) {
-  const shPath = path6.join(PLAYTAGON_DIR, "upload.sh");
-  const batPath = path6.join(PLAYTAGON_DIR, "upload.bat");
+  const shPath = path7.join(PLAYTAGON_DIR, "upload.sh");
+  const batPath = path7.join(PLAYTAGON_DIR, "upload.bat");
   let uploadCmd = `playtagon spine upload "$1" --studio ${studioSlug}`;
   if (gameSlug) {
     uploadCmd += ` --game ${gameSlug}`;
@@ -2132,25 +2385,25 @@ if %ERRORLEVEL% EQU 0 (
   powershell -Command "& {Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show('Upload failed! Check log file', 'Playtagon Error', 'OK', 'Error')}" 2>nul
 )
 `;
-  if (!fs5.existsSync(shPath) || force) {
-    fs5.writeFileSync(shPath, shScript, { mode: 493 });
+  if (!fs6.existsSync(shPath) || force) {
+    fs6.writeFileSync(shPath, shScript, { mode: 493 });
   } else {
     logger.warn(`${shPath} already exists. Use --force to overwrite.`);
   }
-  if (!fs5.existsSync(batPath) || force) {
-    fs5.writeFileSync(batPath, batScript);
+  if (!fs6.existsSync(batPath) || force) {
+    fs6.writeFileSync(batPath, batScript);
   }
   return { sh: shPath, bat: batPath };
 }
 function generateExportPreset(scriptPath, force = false) {
-  const presetPath = path6.join(PLAYTAGON_DIR, "playtagon-spine-preset.export.json");
+  const presetPath = path7.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 (!fs5.existsSync(presetPath) || force) {
-    fs5.writeFileSync(presetPath, JSON.stringify(preset, null, 2));
+  if (!fs6.existsSync(presetPath) || force) {
+    fs6.writeFileSync(presetPath, JSON.stringify(preset, null, 2));
   } else {
     logger.warn(`${presetPath} already exists. Use --force to overwrite.`);
   }
@@ -2178,9 +2431,9 @@ function openFolder(folderPath) {
 }
 
 // src/commands/config.ts
-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) => {
+import { Command as Command11 } from "commander";
+import ora8 from "ora";
+var configCommand = new Command11("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;
@@ -2193,7 +2446,7 @@ var configCommand = new Command10("config").description("View or set CLI configu
       logger.info(`Run ${logger.command("playtagon login")} first.`);
       process.exit(1);
     }
-    const spinner = ora7("Verifying studio...").start();
+    const spinner = ora8("Verifying studio...").start();
     const studios = await getStudios();
     const studio = studios.find(
       (s) => s.slug === options.studio || s.id === options.studio || s.name === options.studio
@@ -2223,7 +2476,7 @@ var configCommand = new Command10("config").description("View or set CLI configu
       logger.info(`Either provide ${logger.command("--studio <slug>")} or set a default studio first.`);
       process.exit(1);
     }
-    const spinner = ora7("Verifying game...").start();
+    const spinner = ora8("Verifying game...").start();
     const studios = await getStudios();
     const studio = studios.find(
       (s) => s.slug === studioSlug || s.id === studioSlug || s.name === studioSlug
@@ -2283,7 +2536,7 @@ var configCommand = new Command10("config").description("View or set CLI configu
 });
 
 // src/index.ts
-var program = new Command11();
+var program = new Command12();
 program.name("playtagon").description("Playtagon CLI - Upload and manage game assets").version("0.3.0");
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);