@asagiri-design/labels-config 0.2.2 → 0.3.0

package/dist/cli.js

@@ -1,7 +1,28 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/cli.ts
@@ -280,6 +301,60 @@ var ConfigLoader = class {
   }
 };
 
+// src/config/batch-config.ts
+var BatchConfigLoader = class {
+  /**
+   * バッチ設定ファイルの読み込み
+   */
+  static async load(filePath) {
+    const { promises: fs2 } = await import("fs");
+    try {
+      const content = await fs2.readFile(filePath, "utf-8");
+      const config = JSON.parse(content);
+      this.validate(config);
+      return config;
+    } catch (error2) {
+      throw new Error(`Failed to load batch config: ${error2}`);
+    }
+  }
+  /**
+   * バッチ設定のバリデーション
+   */
+  static validate(config) {
+    if (!config.version) {
+      throw new Error("Batch config version is required");
+    }
+    if (!config.targets || config.targets.length === 0) {
+      throw new Error("At least one target is required");
+    }
+    config.targets.forEach((target, index) => {
+      const hasRepoSpec = target.organization || target.user || target.repositories;
+      if (!hasRepoSpec) {
+        throw new Error(`Target ${index}: One of organization, user, or repositories is required`);
+      }
+      const hasLabelSpec = target.template || target.file;
+      if (!hasLabelSpec) {
+        throw new Error(`Target ${index}: Either template or file is required`);
+      }
+    });
+  }
+  /**
+   * BatchConfigTargetをBatchSyncOptionsに変換
+   */
+  static targetToOptions(target, defaults) {
+    return {
+      organization: target.organization,
+      user: target.user,
+      repositories: target.repositories,
+      template: target.template || defaults?.template,
+      mode: target.mode || defaults?.mode || "append",
+      parallel: target.parallel || defaults?.parallel || 3,
+      filter: target.filter,
+      dryRun: false
+    };
+  }
+};
+
 // src/github/client.ts
 var import_child_process = require("child_process");
 var GitHubClient = class {
@@ -557,6 +632,262 @@ var _GitHubLabelSync = class _GitHubLabelSync {
 __publicField(_GitHubLabelSync, "BATCH_SIZE", 5);
 var GitHubLabelSync = _GitHubLabelSync;
 
+// src/utils/ui.ts
+var colors = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Foreground colors
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Background colors
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m"
+};
+function supportsColor() {
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  if (process.env.FORCE_COLOR) {
+    return true;
+  }
+  if (!process.stdout.isTTY) {
+    return false;
+  }
+  if (process.platform === "win32") {
+    return true;
+  }
+  return true;
+}
+function colorize(text, color) {
+  if (!supportsColor()) {
+    return text;
+  }
+  return `${colors[color]}${text}${colors.reset}`;
+}
+function success(message) {
+  return colorize("\u2713", "green") + " " + message;
+}
+function error(message) {
+  return colorize("\u2717", "red") + " " + message;
+}
+function warning(message) {
+  return colorize("\u26A0", "yellow") + " " + message;
+}
+function info(message) {
+  return colorize("\u2139", "blue") + " " + message;
+}
+function header(text) {
+  return "\n" + colorize(text, "bright") + "\n" + "\u2500".repeat(Math.min(text.length, 50));
+}
+var Spinner = class {
+  constructor() {
+    __publicField(this, "frames", ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]);
+    __publicField(this, "interval", null);
+    __publicField(this, "frameIndex", 0);
+    __publicField(this, "message", "");
+  }
+  start(message) {
+    this.message = message;
+    if (!process.stdout.isTTY || !supportsColor()) {
+      console.log(message + "...");
+      return;
+    }
+    this.interval = setInterval(() => {
+      const frame = this.frames[this.frameIndex];
+      process.stdout.write(`\r${colorize(frame, "cyan")} ${this.message}`);
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    }, 80);
+  }
+  succeed(message) {
+    this.stop();
+    console.log(success(message || this.message));
+  }
+  fail(message) {
+    this.stop();
+    console.log(error(message || this.message));
+  }
+  warn(message) {
+    this.stop();
+    console.log(warning(message || this.message));
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+      if (process.stdout.isTTY) {
+        process.stdout.write("\r\x1B[K");
+      }
+    }
+  }
+};
+
+// src/github/batch-sync.ts
+var _BatchLabelSync = class _BatchLabelSync {
+  /**
+   * 複数リポジトリへのラベル一括同期
+   */
+  async syncMultiple(labels, options) {
+    const repos = await this.getTargetRepositories(options);
+    const results = [];
+    console.log(colorize(`
+\u{1F4CB} Target repositories: ${repos.length}`, "cyan"));
+    let completed = 0;
+    const parallel = options.parallel || _BatchLabelSync.DEFAULT_PARALLEL;
+    for (let i = 0; i < repos.length; i += parallel) {
+      const batch = repos.slice(i, i + parallel);
+      const batchResults = await Promise.allSettled(
+        batch.map((repo) => this.syncSingleRepo(repo, labels, options))
+      );
+      batchResults.forEach((result, index) => {
+        const repo = batch[index];
+        if (result.status === "fulfilled") {
+          results.push(result.value);
+          completed++;
+          console.log(colorize(`\u2705 [${completed}/${repos.length}] ${repo}`, "green"));
+        } else {
+          results.push({
+            repository: repo,
+            status: "failed",
+            error: result.reason?.message || "Unknown error"
+          });
+          completed++;
+          console.log(colorize(`\u274C [${completed}/${repos.length}] ${repo}: ${result.reason}`, "red"));
+        }
+      });
+    }
+    return results;
+  }
+  /**
+   * 単一リポジトリへの同期
+   */
+  async syncSingleRepo(repository, labels, options) {
+    try {
+      const [owner, repo] = repository.split("/");
+      if (!owner || !repo) {
+        throw new Error(`Invalid repository format: ${repository}. Expected format: owner/repo`);
+      }
+      const sync = new GitHubLabelSync({
+        owner,
+        repo,
+        deleteExtra: options.mode === "replace",
+        dryRun: options.dryRun || false
+      });
+      const result = await sync.syncLabels(labels);
+      return {
+        repository,
+        status: "success",
+        result
+      };
+    } catch (error2) {
+      return {
+        repository,
+        status: "failed",
+        error: error2 instanceof Error ? error2.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * 対象リポジトリリストの取得
+   */
+  async getTargetRepositories(options) {
+    if (options.repositories && options.repositories.length > 0) {
+      return options.repositories;
+    }
+    if (options.organization) {
+      return this.getOrganizationRepos(options.organization, options.filter);
+    }
+    if (options.user) {
+      return this.getUserRepos(options.user, options.filter);
+    }
+    throw new Error("No target repositories specified");
+  }
+  /**
+   * 組織のリポジトリ一覧を取得
+   */
+  async getOrganizationRepos(org, filter) {
+    const { execSync: execSync2 } = await import("child_process");
+    try {
+      const command = `gh repo list ${org} --json nameWithOwner,visibility,language,isArchived --limit 1000`;
+      const output = execSync2(command, { encoding: "utf-8" });
+      const repos = JSON.parse(output);
+      return repos.filter((repo) => {
+        if (filter?.visibility && filter.visibility !== "all" && repo.visibility !== filter.visibility) {
+          return false;
+        }
+        if (filter?.language && repo.language !== filter.language) {
+          return false;
+        }
+        if (filter?.archived !== void 0 && repo.isArchived !== filter.archived) {
+          return false;
+        }
+        return true;
+      }).map((repo) => repo.nameWithOwner);
+    } catch (error2) {
+      throw new Error(`Failed to fetch organization repos: ${error2}`);
+    }
+  }
+  /**
+   * ユーザーのリポジトリ一覧を取得
+   */
+  async getUserRepos(user, filter) {
+    const { execSync: execSync2 } = await import("child_process");
+    try {
+      const command = `gh repo list ${user} --json nameWithOwner,visibility,language,isArchived --limit 1000`;
+      const output = execSync2(command, { encoding: "utf-8" });
+      const repos = JSON.parse(output);
+      return repos.filter((repo) => {
+        if (filter?.visibility && filter.visibility !== "all" && repo.visibility !== filter.visibility) {
+          return false;
+        }
+        if (filter?.language && repo.language !== filter.language) {
+          return false;
+        }
+        if (filter?.archived !== void 0 && repo.isArchived !== filter.archived) {
+          return false;
+        }
+        return true;
+      }).map((repo) => repo.nameWithOwner);
+    } catch (error2) {
+      throw new Error(`Failed to fetch user repos: ${error2}`);
+    }
+  }
+  /**
+   * 結果サマリーの生成
+   */
+  generateSummary(results) {
+    const successful = results.filter((r) => r.status === "success").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    let summary = "\n\u{1F4CA} Batch Sync Summary:\n";
+    summary += `\u2705 Successful: ${successful}
+`;
+    if (failed > 0) summary += `\u274C Failed: ${failed}
+`;
+    if (skipped > 0) summary += `\u23ED\uFE0F  Skipped: ${skipped}
+`;
+    const failedRepos = results.filter((r) => r.status === "failed");
+    if (failedRepos.length > 0) {
+      summary += "\n\u274C Failed repositories:\n";
+      failedRepos.forEach((repo) => {
+        summary += `  - ${repo.repository}: ${repo.error}
+`;
+      });
+    }
+    return summary;
+  }
+};
+__publicField(_BatchLabelSync, "DEFAULT_PARALLEL", 3);
+var BatchLabelSync = _BatchLabelSync;
+
 // src/config/templates.ts
 var MINIMAL_TEMPLATE = [
   {
@@ -1058,104 +1389,6 @@ function getPositional(args, index) {
   return args.positional[index];
 }
 
-// src/utils/ui.ts
-var colors = {
-  reset: "\x1B[0m",
-  bright: "\x1B[1m",
-  dim: "\x1B[2m",
-  // Foreground colors
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
-  white: "\x1B[37m",
-  gray: "\x1B[90m",
-  // Background colors
-  bgRed: "\x1B[41m",
-  bgGreen: "\x1B[42m",
-  bgYellow: "\x1B[43m",
-  bgBlue: "\x1B[44m"
-};
-function supportsColor() {
-  if (process.env.NO_COLOR) {
-    return false;
-  }
-  if (process.env.FORCE_COLOR) {
-    return true;
-  }
-  if (!process.stdout.isTTY) {
-    return false;
-  }
-  if (process.platform === "win32") {
-    return true;
-  }
-  return true;
-}
-function colorize(text, color) {
-  if (!supportsColor()) {
-    return text;
-  }
-  return `${colors[color]}${text}${colors.reset}`;
-}
-function success(message) {
-  return colorize("\u2713", "green") + " " + message;
-}
-function error(message) {
-  return colorize("\u2717", "red") + " " + message;
-}
-function warning(message) {
-  return colorize("\u26A0", "yellow") + " " + message;
-}
-function info(message) {
-  return colorize("\u2139", "blue") + " " + message;
-}
-function header(text) {
-  return "\n" + colorize(text, "bright") + "\n" + "\u2500".repeat(Math.min(text.length, 50));
-}
-var Spinner = class {
-  constructor() {
-    __publicField(this, "frames", ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]);
-    __publicField(this, "interval", null);
-    __publicField(this, "frameIndex", 0);
-    __publicField(this, "message", "");
-  }
-  start(message) {
-    this.message = message;
-    if (!process.stdout.isTTY || !supportsColor()) {
-      console.log(message + "...");
-      return;
-    }
-    this.interval = setInterval(() => {
-      const frame = this.frames[this.frameIndex];
-      process.stdout.write(`\r${colorize(frame, "cyan")} ${this.message}`);
-      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
-    }, 80);
-  }
-  succeed(message) {
-    this.stop();
-    console.log(success(message || this.message));
-  }
-  fail(message) {
-    this.stop();
-    console.log(error(message || this.message));
-  }
-  warn(message) {
-    this.stop();
-    console.log(warning(message || this.message));
-  }
-  stop() {
-    if (this.interval) {
-      clearInterval(this.interval);
-      this.interval = null;
-      if (process.stdout.isTTY) {
-        process.stdout.write("\r\x1B[K");
-      }
-    }
-  }
-};
-
 // src/cli.ts
 var rawArgs = process.argv.slice(2);
 var parsedArgs = parseArgs(rawArgs);
@@ -1164,6 +1397,8 @@ function printUsage() {
   console.log(header("Commands"));
   console.log("  " + colorize("validate", "cyan") + " <file>           Validate label configuration file");
   console.log("  " + colorize("sync", "cyan") + "                     Sync labels to GitHub repository");
+  console.log("  " + colorize("batch-sync", "cyan") + "               Sync labels to multiple repositories");
+  console.log("  " + colorize("batch-config", "cyan") + " <file>      Sync using batch configuration file");
   console.log("  " + colorize("export", "cyan") + "                   Export labels from GitHub repository");
   console.log("  " + colorize("init", "cyan") + " <template>         Initialize new configuration");
   console.log("  " + colorize("help", "cyan") + "                     Show this help message");
@@ -1175,6 +1410,13 @@ function printUsage() {
   console.log("  " + colorize("--owner", "green") + " <owner>         Repository owner (required for sync/export)");
   console.log("  " + colorize("--repo", "green") + " <repo>          Repository name (required for sync/export)");
   console.log("  " + colorize("--file", "green") + " <file>          Configuration file path");
+  console.log("  " + colorize("--template", "green") + " <name>       Template name (for batch-sync)");
+  console.log("  " + colorize("--org", "green") + " <org>            Organization name (for batch-sync)");
+  console.log("  " + colorize("--user", "green") + " <user>          User name (for batch-sync)");
+  console.log("  " + colorize("--repos", "green") + " <repos>        Comma-separated repository list");
+  console.log("  " + colorize("--parallel", "green") + " <num>       Number of parallel executions (default: 3)");
+  console.log("  " + colorize("--filter-lang", "green") + " <lang>   Filter by programming language");
+  console.log("  " + colorize("--filter-vis", "green") + " <vis>     Filter by visibility (public/private/all)");
   console.log("  " + colorize("--dry-run", "green") + "              Dry run mode (don't make changes)");
   console.log("  " + colorize("--delete-extra", "green") + "         Replace mode: delete labels not in config");
   console.log("  " + colorize("--verbose", "green") + "              Verbose output");
@@ -1201,6 +1443,18 @@ function printUsage() {
   console.log("  # Sync with dry run");
   console.log("  " + colorize("labels-config sync --owner user --repo repo --file labels.json --dry-run", "gray"));
   console.log("");
+  console.log("  # Batch sync to all org repositories");
+  console.log("  " + colorize("labels-config batch-sync --org BoxPistols --template prod-ja --dry-run", "gray"));
+  console.log("");
+  console.log("  # Batch sync to specific repositories");
+  console.log("  " + colorize("labels-config batch-sync --repos owner/repo1,owner/repo2 --file labels.json", "gray"));
+  console.log("");
+  console.log("  # Batch sync with filters");
+  console.log("  " + colorize("labels-config batch-sync --user BoxPistols --template react --filter-lang TypeScript --filter-vis public", "gray"));
+  console.log("");
+  console.log("  # Batch sync using config file");
+  console.log("  " + colorize("labels-config batch-config batch-config.json --dry-run", "gray"));
+  console.log("");
 }
 async function validateCommand() {
   const file = getPositional(parsedArgs, 0);
@@ -1386,6 +1640,170 @@ async function initCommand() {
     process.exit(1);
   }
 }
+async function batchSyncCommand() {
+  const spinner = new Spinner();
+  try {
+    const file = getOption(parsedArgs, "--file");
+    const template = getOption(parsedArgs, "--template");
+    const org = getOption(parsedArgs, "--org");
+    const user = getOption(parsedArgs, "--user");
+    const reposOption = getOption(parsedArgs, "--repos");
+    const parallel = parseInt(getOption(parsedArgs, "--parallel") || "3");
+    const filterLang = getOption(parsedArgs, "--filter-lang");
+    const filterVis = getOption(parsedArgs, "--filter-vis");
+    const dryRun = hasFlag(parsedArgs, "--dry-run");
+    const deleteExtra = hasFlag(parsedArgs, "--delete-extra");
+    if (!file && !template) {
+      console.error(error("Error: Either --file or --template is required for batch-sync"));
+      console.log(info("Available templates: ") + listTemplates().map((t) => colorize(t, "magenta")).join(", "));
+      process.exit(1);
+    }
+    if (!org && !user && !reposOption) {
+      console.error(error("Error: One of --org, --user, or --repos is required"));
+      console.log(info("Specify target repositories using:"));
+      console.log("  --org <organization>  (sync all org repos)");
+      console.log("  --user <username>     (sync all user repos)");
+      console.log("  --repos owner/repo1,owner/repo2  (specific repos)");
+      process.exit(1);
+    }
+    let labels;
+    if (file) {
+      try {
+        await import_fs.promises.access(file);
+      } catch {
+        console.error(error(`File not found: ${file}`));
+        process.exit(1);
+      }
+      spinner.start(`Loading labels from ${file}`);
+      const content = await import_fs.promises.readFile(file, "utf-8");
+      const loader = new ConfigLoader();
+      labels = loader.loadFromString(content);
+      spinner.succeed(`Loaded ${labels.length} labels from file`);
+    } else if (template) {
+      if (!listTemplates().includes(template)) {
+        console.error(error(`Invalid template "${template}"`));
+        console.log(info("Available templates: ") + listTemplates().map((t) => colorize(t, "magenta")).join(", "));
+        process.exit(1);
+      }
+      spinner.start(`Loading "${template}" template`);
+      labels = CONFIG_TEMPLATES[template];
+      spinner.succeed(`Loaded ${labels.length} labels from "${template}" template`);
+    } else {
+      throw new Error("Either --file or --template is required");
+    }
+    const repositories = reposOption ? reposOption.split(",").map((r) => r.trim()) : void 0;
+    const batchSync = new BatchLabelSync();
+    const options = {
+      repositories,
+      organization: org,
+      user,
+      template,
+      mode: deleteExtra ? "replace" : "append",
+      dryRun,
+      parallel,
+      filter: {
+        visibility: filterVis,
+        language: filterLang,
+        archived: false
+      }
+    };
+    const modeText = dryRun ? colorize("[DRY RUN] ", "yellow") : "";
+    console.log(`
+${modeText}${header("Batch Sync Configuration")}`);
+    console.log(info(`Labels: ${labels.length}`));
+    if (org) console.log(info(`Organization: ${org}`));
+    if (user) console.log(info(`User: ${user}`));
+    if (repositories) console.log(info(`Repositories: ${repositories.length} specified`));
+    if (filterLang) console.log(info(`Filter (language): ${filterLang}`));
+    if (filterVis) console.log(info(`Filter (visibility): ${filterVis}`));
+    console.log(info(`Parallel: ${parallel}`));
+    console.log(info(`Mode: ${deleteExtra ? "replace" : "append"}`));
+    const results = await batchSync.syncMultiple(labels, options);
+    const summary = batchSync.generateSummary(results);
+    console.log(summary);
+    const hasErrors = results.some((r) => r.status === "failed");
+    if (hasErrors) {
+      process.exit(1);
+    }
+  } catch (err) {
+    spinner.fail("Batch sync failed");
+    console.error(error(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
+async function batchConfigCommand() {
+  const configFile = getPositional(parsedArgs, 0);
+  const dryRun = hasFlag(parsedArgs, "--dry-run");
+  const spinner = new Spinner();
+  if (!configFile) {
+    console.error(error("Configuration file path required"));
+    console.error("Usage: labels-config batch-config <file>");
+    console.log(info("Example: labels-config batch-config batch-config.json --dry-run"));
+    process.exit(1);
+  }
+  try {
+    spinner.start(`Loading batch configuration from ${configFile}`);
+    const config = await BatchConfigLoader.load(configFile);
+    spinner.succeed(`Loaded batch configuration with ${config.targets.length} targets`);
+    const modeText = dryRun ? colorize("[DRY RUN] ", "yellow") : "";
+    console.log(`
+${modeText}${header("Batch Configuration")}`);
+    console.log(info(`Version: ${config.version}`));
+    if (config.description) console.log(info(`Description: ${config.description}`));
+    console.log(info(`Targets: ${config.targets.length}`));
+    let totalSuccess = 0;
+    let totalFailed = 0;
+    for (let i = 0; i < config.targets.length; i++) {
+      const target = config.targets[i];
+      console.log(`
+${header(`Target ${i + 1}/${config.targets.length}`)}`);
+      let labels;
+      if (target.file) {
+        spinner.start(`Loading labels from ${target.file}`);
+        const content = await import_fs.promises.readFile(target.file, "utf-8");
+        const loader = new ConfigLoader();
+        labels = loader.loadFromString(content);
+        spinner.succeed(`Loaded ${labels.length} labels`);
+      } else if (target.template) {
+        const templateName = target.template || config.defaults?.template;
+        if (!templateName || !listTemplates().includes(templateName)) {
+          console.error(error(`Invalid template "${templateName}"`));
+          continue;
+        }
+        spinner.start(`Loading "${templateName}" template`);
+        labels = CONFIG_TEMPLATES[templateName];
+        spinner.succeed(`Loaded ${labels.length} labels`);
+      } else {
+        console.error(error("No template or file specified"));
+        continue;
+      }
+      const batchSync = new BatchLabelSync();
+      const options = BatchConfigLoader.targetToOptions(target, config.defaults);
+      options.dryRun = dryRun;
+      console.log(info(`Mode: ${options.mode}`));
+      if (target.organization) console.log(info(`Organization: ${target.organization}`));
+      if (target.user) console.log(info(`User: ${target.user}`));
+      if (target.repositories) console.log(info(`Repositories: ${target.repositories.length}`));
+      const results = await batchSync.syncMultiple(labels, options);
+      const successful = results.filter((r) => r.status === "success").length;
+      const failed = results.filter((r) => r.status === "failed").length;
+      totalSuccess += successful;
+      totalFailed += failed;
+      console.log(success(`Target ${i + 1}: ${successful} successful, ${failed} failed`));
+    }
+    console.log(`
+${header("Overall Summary")}`);
+    console.log(success(`Total successful: ${totalSuccess}`));
+    if (totalFailed > 0) {
+      console.log(error(`Total failed: ${totalFailed}`));
+      process.exit(1);
+    }
+  } catch (err) {
+    spinner.fail("Batch config execution failed");
+    console.error(error(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
 async function main() {
   const command = parsedArgs.command;
   if (!command || command === "help" || hasFlag(parsedArgs, "--help", "-h")) {
@@ -1399,6 +1817,12 @@ async function main() {
     case "sync":
       await syncCommand();
       break;
+    case "batch-sync":
+      await batchSyncCommand();
+      break;
+    case "batch-config":
+      await batchConfigCommand();
+      break;
     case "export":
       await exportCommand();
       break;