@weavix/cli 0.1.0-dev → 0.2.0-dev

package/build/index.js

@@ -40,6 +40,24 @@ var CLI_NAME, CLI_DESCRIPTION, CLI_HELP_TEXT, init_meta = __esm({
   }
 });
 
+// src/utils/verbose.ts
+function setVerboseEnabled(value) {
+  verboseEnabled = value;
+}
+function isVerboseEnabled() {
+  return verboseEnabled;
+}
+function writeVerboseArtifact(relativePath, content) {
+  let targetPath = import_path.default.resolve(".tracker-cli-debug", relativePath);
+  return import_fs.default.mkdirSync(import_path.default.dirname(targetPath), { recursive: !0 }), import_fs.default.writeFileSync(targetPath, content), targetPath;
+}
+var import_fs, import_path, verboseEnabled, init_verbose = __esm({
+  "src/utils/verbose.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs")), import_path = __toESM(require("path")), verboseEnabled = !1;
+  }
+});
+
 // src/utils/logger.ts
 function success(message) {
   console.info(import_picocolors.default.green(`\u2705 ${message}`)), newLine();
@@ -54,6 +72,9 @@ function warning(message) {
 function info(message) {
   console.info(message), newLine();
 }
+function verbose(message) {
+  isVerboseEnabled() && (console.info(import_picocolors.default.dim(message)), newLine());
+}
 function suggest(command) {
   console.info(`Run: ${command}`), newLine();
 }
@@ -73,11 +94,13 @@ var import_picocolors, logger, logger_default, init_logger = __esm({
   "src/utils/logger.ts"() {
     "use strict";
     import_picocolors = __toESM(require("picocolors"));
+    init_verbose();
     logger = {
       success,
       error,
       warning,
       info,
+      verbose,
       suggest,
       newLine,
       separator,
@@ -86,102 +109,112 @@ var import_picocolors, logger, logger_default, init_logger = __esm({
   }
 });
 
-// src/distributions/external/configStore.ts
-async function readConfig() {
-  if (!(0, import_fs.existsSync)(CONFIG_FILE))
-    return null;
-  let raw = await (0, import_promises.readFile)(CONFIG_FILE, "utf-8");
-  return JSON.parse(raw);
+// src/distributions/external/config/configManager.ts
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function readConfig() {
+  if (cached !== void 0)
+    return cached;
+  if (!(0, import_fs2.existsSync)(CONFIG_FILE))
+    return cached = null, cached;
+  try {
+    cached = JSON.parse((0, import_fs2.readFileSync)(CONFIG_FILE, "utf-8"));
+  } catch {
+    cached = null;
+  }
+  return cached;
+}
+function writeConfig(config) {
+  (0, import_fs2.existsSync)(CONFIG_DIR) || (0, import_fs2.mkdirSync)(CONFIG_DIR, { recursive: !0, mode: 448 }), (0, import_fs2.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 }), cached = config;
 }
-async function writeConfig(config) {
-  (0, import_fs.existsSync)(CONFIG_DIR) || (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: !0, mode: 448 }), await (0, import_promises.writeFile)(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 });
+function clearConfig() {
+  (0, import_fs2.existsSync)(CONFIG_FILE) && (0, import_fs2.rmSync)(CONFIG_FILE), cached = null;
 }
-async function clearConfig() {
-  (0, import_fs.existsSync)(CONFIG_FILE) && await (0, import_promises.unlink)(CONFIG_FILE);
+function requireConfig() {
+  let config = readConfig();
+  if (!config)
+    throw new Error('CLI is not configured. Run "weavix config set" to configure.');
+  return config;
 }
-var import_fs, import_promises, os, import_path, CONFIG_DIR, CONFIG_FILE, CONFIG_FILE_PATH, init_configStore = __esm({
-  "src/distributions/external/configStore.ts"() {
+var import_fs2, os, import_path2, CONFIG_DIR, CONFIG_FILE, cached, init_configManager = __esm({
+  "src/distributions/external/config/configManager.ts"() {
     "use strict";
-    import_fs = require("fs"), import_promises = require("fs/promises"), os = __toESM(require("os")), import_path = __toESM(require("path")), CONFIG_DIR = import_path.default.join(os.homedir(), ".tracker-cli"), CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json"), CONFIG_FILE_PATH = CONFIG_FILE;
+    import_fs2 = require("fs"), os = __toESM(require("os")), import_path2 = __toESM(require("path")), CONFIG_DIR = import_path2.default.join(os.homedir(), ".tracker-cli"), CONFIG_FILE = import_path2.default.join(CONFIG_DIR, "config.json");
   }
 });
 
-// src/distributions/external/configCommand.ts
-function withErrorHandling(fn) {
-  return async (...args) => {
-    try {
-      await fn(...args);
-    } catch (error2) {
-      error2 instanceof Error && error2.name === "ExitPromptError" && process.exit(0), logger_default.error(error2), process.exit(1);
-    }
-  };
-}
-async function configSet() {
-  let current = await readConfig(), awsEndpoint = await (0, import_prompts.input)({
-    message: "S3 endpoint (e.g. https://s3.amazonaws.com):",
-    default: current?.awsEndpoint,
-    validate: (v) => v.trim() ? !0 : "required"
-  }), awsRegion = await (0, import_prompts.input)({
-    message: "S3 region:",
-    default: current?.awsRegion,
-    validate: (v) => v.trim() ? !0 : "required"
-  }), staticBucket = await (0, import_prompts.input)({
-    message: "Bucket for plugin files:",
-    default: current?.staticBucket,
-    validate: (v) => v.trim() ? !0 : "required"
-  }), configBucket = await (0, import_prompts.input)({
-    message: "Bucket for plugins config.json:",
-    default: current?.configBucket,
-    validate: (v) => v.trim() ? !0 : "required"
-  }), mdsEndpoint = await (0, import_prompts.input)({
-    message: "MDS endpoint (optional, defaults to S3 endpoint):",
-    default: current?.mdsEndpoint || ""
-  }), platformApiUrl = await (0, import_prompts.input)({
-    message: "Platform API URL (optional):",
-    default: current?.platformApiUrl || ""
-  }), trackerApiUrl = await (0, import_prompts.input)({
-    message: "Tracker API URL (optional):",
-    default: current?.trackerApiUrl || ""
-  }), config = {
-    awsEndpoint: awsEndpoint.trim(),
-    awsRegion: awsRegion.trim(),
-    staticBucket: staticBucket.trim(),
-    configBucket: configBucket.trim()
-  };
-  mdsEndpoint.trim() && (config.mdsEndpoint = mdsEndpoint.trim()), platformApiUrl.trim() && (config.platformApiUrl = platformApiUrl.trim()), trackerApiUrl.trim() && (config.trackerApiUrl = trackerApiUrl.trim()), await writeConfig(config), logger_default.success(`Configuration saved to ${CONFIG_FILE_PATH}`);
+// src/distributions/external/config/index.ts
+async function promptString(message, current, required = !0) {
+  return (await (0, import_prompts.input)({
+    message: current ? `${message} (current: ${current})` : message,
+    default: current,
+    required: required && !current
+  }))?.trim() || void 0;
+}
+async function runConfigSet() {
+  let existing = readConfig() ?? {};
+  logger_default.info("Configure CLI endpoints. Empty input keeps the current value.");
+  let s3Endpoint = await promptString("S3 endpoint", existing.s3?.endpoint), s3Region = await promptString("S3 region", existing.s3?.region), mdsEndpoint = await promptString("MDS endpoint", existing.mds?.endpoint), testingStatic = await promptString(
+    "Testing bucket (static)",
+    existing.buckets?.testing?.static
+  ), testingConfig = await promptString(
+    "Testing bucket (config)",
+    existing.buckets?.testing?.config
+  ), productionStatic = await promptString(
+    "Production bucket (static)",
+    existing.buckets?.production?.static
+  ), productionConfig = await promptString(
+    "Production bucket (config)",
+    existing.buckets?.production?.config
+  ), pluginDownloadTesting = await promptString(
+    "Plugin download base URL (testing)",
+    existing.pluginDownloadBase?.testing
+  ), pluginDownloadProduction = await promptString(
+    "Plugin download base URL (production)",
+    existing.pluginDownloadBase?.production
+  ), platformBaseUrl = await promptString(
+    "Platform API base URL",
+    existing.api?.platformBaseUrl
+  ), trackerBaseUrl = await promptString("Tracker API base URL", existing.api?.trackerBaseUrl), oauthUrl = await promptString("OAuth token URL", existing.auth?.oauthUrl);
+  writeConfig({
+    s3: { endpoint: s3Endpoint, region: s3Region },
+    mds: { endpoint: mdsEndpoint },
+    buckets: {
+      testing: { static: testingStatic, config: testingConfig },
+      production: { static: productionStatic, config: productionConfig }
+    },
+    pluginDownloadBase: {
+      testing: pluginDownloadTesting,
+      production: pluginDownloadProduction
+    },
+    api: { platformBaseUrl, trackerBaseUrl },
+    auth: { oauthUrl }
+  }), logger_default.success(`Configuration saved \u2192 ${getConfigPath()}`);
 }
-async function configShow() {
-  let cfg = await readConfig();
+function runConfigShow() {
+  let cfg = readConfig();
   if (!cfg) {
-    logger_default.info("No configuration. Run: tracker-cli config set");
+    logger_default.info(
+      `No configuration found at ${getConfigPath()}. Run "weavix config set" to create one.`
+    );
     return;
   }
-  logger_default.info(JSON.stringify(cfg, null, 2));
+  logger_default.info(`Configuration at ${getConfigPath()}:`), logger_default.info(JSON.stringify(cfg, null, 2));
 }
-async function configClear() {
-  if (!await readConfig()) {
-    logger_default.info("No configuration to clear.");
-    return;
-  }
-  if (!await (0, import_prompts.confirm)({
-    message: `Remove configuration at ${CONFIG_FILE_PATH}?`,
-    default: !1
-  })) {
-    logger_default.info("Cancelled.");
-    return;
-  }
-  await clearConfig(), logger_default.success("Configuration removed.");
+function runConfigClear() {
+  clearConfig(), logger_default.success(`Configuration removed (${getConfigPath()})`);
 }
 function registerConfigCommand(program) {
-  let config = program.command("config").description("manage CLI configuration (S3 endpoints, buckets, API URLs)");
-  config.command("set").description("set configuration interactively").action(withErrorHandling(configSet)), config.command("show").description("show current configuration").action(withErrorHandling(configShow)), config.command("clear").description("remove configuration").action(withErrorHandling(configClear));
+  let config = program.command("config").description("manage CLI configuration");
+  config.command("set").description("set CLI configuration values interactively").action(runConfigSet), config.command("show").description("display current CLI configuration").action(runConfigShow), config.command("clear").description("remove stored CLI configuration").action(runConfigClear);
 }
-var import_prompts, init_configCommand = __esm({
-  "src/distributions/external/configCommand.ts"() {
+var import_prompts, init_config = __esm({
+  "src/distributions/external/config/index.ts"() {
     "use strict";
     import_prompts = require("@inquirer/prompts");
     init_logger();
-    init_configStore();
+    init_configManager();
   }
 });
 
@@ -196,92 +229,85 @@ function registerDistributionCommands(program) {
 var init_registerCommands = __esm({
   "src/distributions/external/registerCommands.ts"() {
     "use strict";
-    init_configCommand();
+    init_config();
   }
 });
 
-// src/distributions/external/auth.ts
-var auth_exports = {};
-__export(auth_exports, {
-  getNpmUpdateUrl: () => getNpmUpdateUrl,
-  getOAuthTokenUrl: () => getOAuthTokenUrl
+// src/distributions/external/hosts.ts
+var hosts_exports = {};
+__export(hosts_exports, {
+  getBuckets: () => getBuckets,
+  getMdsEndpoint: () => getMdsEndpoint,
+  getOAuthTokenUrl: () => getOAuthTokenUrl,
+  getPlatformBaseUrl: () => getPlatformBaseUrl,
+  getPluginDownloadBase: () => getPluginDownloadBase,
+  getS3Endpoint: () => getS3Endpoint,
+  getS3Region: () => getS3Region,
+  getTrackerBaseUrl: () => getTrackerBaseUrl,
+  getUpdateCheckInfo: () => getUpdateCheckInfo
 });
-async function getOAuthTokenUrl() {
+function getS3Endpoint() {
+  let cfg = requireConfig();
+  if (!cfg.s3?.endpoint)
+    throw new Error('S3 endpoint is not configured. Run "weavix config set" to configure.');
+  return cfg.s3.endpoint;
+}
+function getMdsEndpoint() {
+  let cfg = requireConfig();
+  if (!cfg.mds?.endpoint)
+    throw new Error('MDS endpoint is not configured. Run "weavix config set" to configure.');
+  return cfg.mds.endpoint;
+}
+function getS3Region() {
+  let cfg = requireConfig();
+  if (!cfg.s3?.region)
+    throw new Error('S3 region is not configured. Run "weavix config set" to configure.');
+  return cfg.s3.region;
+}
+function getBuckets() {
+  let buckets = requireConfig().buckets, testing = buckets?.testing, production = buckets?.production;
+  if (!testing?.static || !testing?.config || !production?.static || !production?.config)
+    throw new Error('S3 buckets are not configured. Run "weavix config set" to configure.');
+  return {
+    testing: { static: testing.static, config: testing.config },
+    production: { static: production.static, config: production.config }
+  };
 }
-async function getNpmUpdateUrl() {
+function getPluginDownloadBase(env) {
+  let base = requireConfig().pluginDownloadBase?.[env];
+  if (!base)
+    throw new Error(
+      `Plugin download base for "${env}" is not configured. Run "weavix config set" to configure.`
+    );
+  return base;
 }
-var init_auth = __esm({
-  "src/distributions/external/auth.ts"() {
-    "use strict";
-  }
-});
-
-// src/distributions/external/apiUrls.ts
-var apiUrls_exports = {};
-__export(apiUrls_exports, {
-  getPlatformApiUrl: () => getPlatformApiUrl,
-  getTrackerApiUrl: () => getTrackerApiUrl
-});
-async function getPlatformApiUrl() {
-  let cfg = await readConfig();
-  if (!cfg?.platformApiUrl)
-    throw new Error("Platform API URL is not configured. Run: tracker-cli config set");
-  return cfg.platformApiUrl;
-}
-async function getTrackerApiUrl() {
-  let cfg = await readConfig();
-  if (!cfg?.trackerApiUrl)
-    throw new Error("Tracker API URL is not configured. Run: tracker-cli config set");
-  return cfg.trackerApiUrl;
-}
-var init_apiUrls = __esm({
-  "src/distributions/external/apiUrls.ts"() {
-    "use strict";
-    init_configStore();
-  }
-});
-
-// src/distributions/external/promptEnvironment.ts
-var promptEnvironment_exports = {};
-__export(promptEnvironment_exports, {
-  promptEnvironment: () => promptEnvironment
-});
-async function promptEnvironment() {
-  return "";
+function getPlatformBaseUrl() {
+  let cfg = requireConfig();
+  if (!cfg.api?.platformBaseUrl)
+    throw new Error(
+      'Platform API URL is not configured. Run "weavix config set" to configure.'
+    );
+  return cfg.api.platformBaseUrl;
 }
-var init_promptEnvironment = __esm({
-  "src/distributions/external/promptEnvironment.ts"() {
-    "use strict";
-  }
-});
-
-// src/distributions/external/storage.ts
-var storage_exports = {};
-__export(storage_exports, {
-  DEFAULT_ENVIRONMENT: () => DEFAULT_ENVIRONMENT,
-  getStorageSettings: () => getStorageSettings,
-  listEnvironments: () => listEnvironments
-});
-async function getStorageSettings(_environment) {
-  let cfg = await readConfig();
-  if (!cfg)
-    throw new Error("CLI is not configured. Run: tracker-cli config set");
-  return {
-    awsEndpoint: cfg.awsEndpoint,
-    awsRegion: cfg.awsRegion,
-    mdsEndpoint: cfg.mdsEndpoint ?? cfg.awsEndpoint,
-    configBucket: cfg.configBucket,
-    staticBucket: cfg.staticBucket
-  };
+function getTrackerBaseUrl() {
+  let cfg = requireConfig();
+  if (!cfg.api?.trackerBaseUrl)
+    throw new Error('Tracker API URL is not configured. Run "weavix config set" to configure.');
+  return cfg.api.trackerBaseUrl;
+}
+function getOAuthTokenUrl() {
+  let cfg = requireConfig();
+  if (!cfg.auth?.oauthUrl)
+    throw new Error('OAuth URL is not configured. Run "weavix config set" to configure.');
+  return cfg.auth.oauthUrl;
 }
-async function listEnvironments() {
-  return [];
+function getUpdateCheckInfo() {
+  return null;
 }
-var DEFAULT_ENVIRONMENT, init_storage = __esm({
-  "src/distributions/external/storage.ts"() {
+var init_hosts = __esm({
+  "src/distributions/external/hosts.ts"() {
     "use strict";
-    init_configStore();
-    DEFAULT_ENVIRONMENT = "";
+    init_configManager();
   }
 });
 
@@ -297,26 +323,35 @@ var impl2 = (init_registerCommands(), __toCommonJS(registerCommands_exports)), {
 // src/utils/checkUpdate.ts
 var import_node_fetch = __toESM(require("node-fetch"));
 
-// src/distribution/auth.ts
-var impl3 = (init_auth(), __toCommonJS(auth_exports)), { getOAuthTokenUrl: getOAuthTokenUrl2, getNpmUpdateUrl: getNpmUpdateUrl2 } = impl3;
+// src/distribution/hosts.ts
+var impl3 = (init_hosts(), __toCommonJS(hosts_exports)), {
+  getS3Endpoint: getS3Endpoint2,
+  getMdsEndpoint: getMdsEndpoint2,
+  getS3Region: getS3Region2,
+  getBuckets: getBuckets2,
+  getPluginDownloadBase: getPluginDownloadBase2,
+  getPlatformBaseUrl: getPlatformBaseUrl2,
+  getTrackerBaseUrl: getTrackerBaseUrl2,
+  getOAuthTokenUrl: getOAuthTokenUrl2,
+  getUpdateCheckInfo: getUpdateCheckInfo2
+} = impl3;
 
 // src/utils/checkUpdate.ts
 init_logger();
 var checkUpdate = async (version) => {
-  try {
-    let registryUrl = await getNpmUpdateUrl2();
-    if (!registryUrl)
-      return;
-    let response = await (0, import_node_fetch.default)(`${registryUrl}/@yandex-data-ui/tracker-cli/latest`);
-    if (!response.ok)
-      return;
-    let latest = await response.json();
-    latest.version !== version && (logger_default.newLine(), logger_default.info(
-      `\u{1F514} Update available ${version} \u2192 ${latest.version}
-Run: npm i -g @yandex-data-ui/tracker-cli@latest --registry=${registryUrl}`
-    ));
-  } catch {
-  }
+  let info3 = getUpdateCheckInfo2();
+  if (info3)
+    try {
+      let response = await (0, import_node_fetch.default)(`${info3.registryUrl}/${info3.packageName}/latest`);
+      if (!response.ok)
+        return;
+      let latest = await response.json();
+      latest.version !== version && (logger_default.newLine(), logger_default.info(
+        `\u{1F514} Update available ${version} \u2192 ${latest.version}
+Run: npm i -g ${info3.packageName}@latest --registry=${info3.registryUrl}`
+      ));
+    } catch {
+    }
 };
 
 // src/utils/execCommand.ts
@@ -346,173 +381,269 @@ var build = async ({ environment = "production" } = {}) => {
   );
 };
 
-// src/api/tracker.ts
-var import_form_data = __toESM(require("form-data"));
+// src/commands/create/index.ts
+var path8 = __toESM(require("path")), import_prompts2 = require("@inquirer/prompts");
 
-// src/api/trackerApiRequest.ts
-var import_node_fetch2 = __toESM(require("node-fetch"));
+// src/core/manifest/constants.ts
+var DATA_PERMISSIONS = [
+  // top 10
+  "tracker:issues:read",
+  "tracker:issues:write",
+  "tracker:issuetypes:read",
+  "tracker:statuses:read",
+  "tracker:queues:read",
+  "tracker:fields:read",
+  "tracker:entities:read",
+  "tracker:attachments:read",
+  "tracker:attachments:write",
+  // in alphabetical order
+  "tracker:applications:read",
+  "tracker:boards:read",
+  "tracker:boards:write",
+  "tracker:bulk:read",
+  "tracker:bulk:write",
+  "tracker:bulkchange:read",
+  "tracker:bulkchange:write",
+  "tracker:charts:read",
+  "tracker:commentTemplates:read",
+  "tracker:commentTemplates:write",
+  "tracker:components:read",
+  "tracker:components:write",
+  "tracker:data:read",
+  "tracker:departments:read",
+  "tracker:entities:write",
+  "tracker:externalEventTypes:write",
+  "tracker:externalEvents:write",
+  "tracker:fields:write",
+  "tracker:filterFolders:write",
+  "tracker:filters:read",
+  "tracker:filters:write",
+  "tracker:goals:read",
+  "tracker:goals:write",
+  "tracker:groups:read",
+  "tracker:issueTemplates:read",
+  "tracker:issueTemplates:write",
+  "tracker:links:read",
+  "tracker:linktypes:read",
+  "tracker:liveBoards:write",
+  "tracker:localFields:read",
+  "tracker:maillists:read",
+  "tracker:maillists:write",
+  "tracker:myself:read",
+  "tracker:myself:write",
+  "tracker:priorities:read",
+  "tracker:queues:write",
+  "tracker:reminders:read",
+  "tracker:reminders:write",
+  "tracker:remotelinks:read",
+  "tracker:reports:read",
+  "tracker:reports:write",
+  "tracker:resolutions:read",
+  "tracker:resources:read",
+  "tracker:resources:write",
+  "tracker:roles:read",
+  "tracker:screens:read",
+  "tracker:services:read",
+  "tracker:sprints:read",
+  "tracker:sprints:write",
+  "tracker:system:write",
+  "tracker:tags:read",
+  "tracker:translations:read",
+  "tracker:users:read",
+  "tracker:users:write",
+  "tracker:versions:read",
+  "tracker:versions:write",
+  "tracker:workflows:read",
+  "tracker:workflows:write",
+  "tracker:worklog:read",
+  "tracker:worklog:write"
+], TOP_DATA_PERMISSIONS = DATA_PERMISSIONS.slice(0, 10);
+var TEMPLATES = [
+  "default",
+  "issue.action",
+  "issue.block",
+  "issue.tab",
+  "issue.comment.action",
+  "navigation",
+  "trigger.action",
+  "project.action",
+  "portfolio.action",
+  "goal.action",
+  "issue.floatingbottom.action",
+  "attachment.viewer.action"
+];
+var TEMPLATE_SLOTS = {
+  default: [],
+  "issue.action": ["issue.action"],
+  "issue.block": ["issue.block"],
+  "issue.tab": ["issue.tab"],
+  "issue.comment.action": ["issue.comment.action"],
+  navigation: ["navigation"],
+  "trigger.action": ["trigger.create.action", "trigger.edit.action"],
+  "project.action": ["project.action"],
+  "portfolio.action": ["portfolio.action"],
+  "goal.action": ["goal.action"],
+  "issue.floatingbottom.action": ["issue.floatingbottom.action"],
+  "attachment.viewer.action": ["attachment.viewer.action"]
+};
 
-// src/core/auth/authManager.ts
-var fs = __toESM(require("fs")), os2 = __toESM(require("os")), path2 = __toESM(require("path")), authDir = path2.join(os2.homedir(), ".tracker-cli"), authFile = path2.join(authDir, "auth.json"), getData = () => {
-  try {
-    if (!fs.existsSync(authFile))
-      return null;
-    let data = fs.readFileSync(authFile, "utf-8");
-    return JSON.parse(data);
-  } catch {
-    return null;
-  }
-}, getAuthHeader = () => {
-  let authData = getData();
-  return authData ? `OAuth ${authData.token}` : null;
-}, saveAuthData = (token) => {
-  let authData = {
-    token
+// src/commands/create/index.ts
+init_logger();
+
+// src/commands/create/utils/getWelcomeMessage.ts
+var import_picocolors2 = __toESM(require("picocolors")), getWelcomeMessage = (pwd) => `
+${import_picocolors2.default.bold(import_picocolors2.default.white("\u{1F680} Create new tracker plugin"))}
+
+${import_picocolors2.default.dim(`\u{1F4C1} Creating an app in your current directory: ${pwd}`)}
+
+${import_picocolors2.default.dim("Press")} ${import_picocolors2.default.yellow("Ctrl+C")} ${import_picocolors2.default.dim("to cancel.")}
+`;
+
+// src/commands/create/utils/initManifest.ts
+var fs2 = __toESM(require("fs")), path3 = __toESM(require("path"));
+
+// src/commands/create/utils/generateManifest.ts
+function buildSlots(template, slotTitle) {
+  let slotNames = TEMPLATE_SLOTS[template];
+  if (slotNames.length === 0) return;
+  let slotEntry = {
+    entrypoint: "index.html",
+    title: { ru: slotTitle, en: slotTitle }
   };
-  fs.existsSync(authDir) || fs.mkdirSync(authDir, { recursive: !0, mode: 448 }), fs.writeFileSync(authFile, JSON.stringify(authData, null, 2), {
-    mode: 384
-  });
-}, removeAuthData = () => {
-  fs.existsSync(authFile) && fs.unlinkSync(authFile);
-}, authManager = {
-  get authHeader() {
-    return getAuthHeader();
+  return {
+    tracker: Object.fromEntries(slotNames.map((slotName) => [slotName, [slotEntry]]))
+  };
+}
+var generateManifest = (answers) => ({
+  $schema: "./manifest.schema.json",
+  manifest_version: 1,
+  supported_services: ["tracker"],
+  slug: answers.packageSlug,
+  version: answers.version,
+  name: {
+    ru: answers.pluginName,
+    en: answers.pluginName
   },
-  get data() {
-    return getData();
+  description: {
+    ru: answers.pluginDescription,
+    en: answers.pluginDescription
   },
-  saveAuthData,
-  removeAuthData
+  permissions: answers.permissions,
+  support: [{ type: "email", value: answers.supportEmail }],
+  slots: buildSlots(answers.template, answers.slotTitle)
+});
+
+// src/commands/create/utils/initManifest.ts
+var initManifest = ({ answers, targetDir }) => {
+  let generatedManifest = generateManifest(answers), manifestPath2 = path3.join(targetDir, "manifest.json");
+  fs2.writeFileSync(manifestPath2, JSON.stringify(generatedManifest, null, 2), "utf-8");
 };
 
-// src/distribution/apiUrls.ts
-var impl4 = (init_apiUrls(), __toCommonJS(apiUrls_exports)), { getPlatformApiUrl: getPlatformApiUrl2, getTrackerApiUrl: getTrackerApiUrl2 } = impl4;
+// src/commands/create/utils/initTemplate.ts
+var fs5 = __toESM(require("fs")), path7 = __toESM(require("path"));
 
-// src/api/trackerApiRequest.ts
-function buildQueryString(queryParams) {
-  if (!queryParams || Object.keys(queryParams).length === 0)
-    return "";
-  let params = new URLSearchParams();
-  return Object.entries(queryParams).forEach(([key, value]) => {
-    params.append(key, String(value));
-  }), `?${params.toString()}`;
-}
-async function parseResponse(response) {
-  return response.status === 204 || response.headers.get("content-length") === "0" ? void 0 : response.headers.get("content-type")?.includes("application/json") ? await response.json() : await response.text();
-}
-async function trackerApiRequest(endpoint, options = {}) {
-  let { method = "GET", body, headers = {}, formData, queryParams } = options, authHeader = authManager.authHeader;
-  if (!authHeader)
-    throw new Error('Not authenticated. Run "tracker-cli login" first.');
-  let requestHeaders = {
-    Authorization: authHeader,
-    Accept: "application/json",
-    ...headers
-  }, requestBody;
-  if (formData) {
-    let formHeaders = formData.getHeaders?.();
-    Object.assign(requestHeaders, formHeaders), requestBody = formData;
-  } else body && method !== "GET" && (requestHeaders["Content-Type"] = "application/json", requestBody = JSON.stringify(body));
-  let queryString = buildQueryString(queryParams), url = `${await getTrackerApiUrl2()}${endpoint}${queryString}`, response = await (0, import_node_fetch2.default)(url, {
-    method,
-    headers: requestHeaders,
-    body: requestBody
+// src/utils/copyDirectory.ts
+var fs3 = __toESM(require("fs")), import_path3 = __toESM(require("path")), import_tinyglobby = require("tinyglobby"), resolveTargetFileName = (file) => file.endsWith(".template") ? "." + file.replace(".template", "") : file, copyDirectory = async (sourceDir, targetDir) => {
+  let files = await (0, import_tinyglobby.glob)(["**/*"], {
+    cwd: sourceDir,
+    onlyFiles: !0,
+    dot: !0
   });
-  if (!response.ok) {
-    let errorText = await response.text(), errorMessage = `Tracker API error ${response.status}: ${errorText}`;
-    try {
-      let errorJson = JSON.parse(errorText);
-      errorJson.message && (errorMessage = `Tracker API error ${response.status}: ${errorJson.message}`);
-    } catch {
-    }
-    throw new Error(errorMessage);
-  }
-  return parseResponse(response);
-}
+  await Promise.all(
+    files.map(async (file) => {
+      let sourcePath = import_path3.default.join(sourceDir, file), targetFile = resolveTargetFileName(file), targetPath = import_path3.default.join(targetDir, targetFile);
+      await fs3.promises.mkdir(import_path3.default.dirname(targetPath), { recursive: !0 }), await fs3.promises.copyFile(sourcePath, targetPath);
+    })
+  );
+};
 
-// src/api/tracker.ts
-var PLUGINMOD_QUEUE = "PLUGINMOD";
-function buildIssueSummary(slug) {
-  return `Plugin: ${slug}`;
-}
-function buildIssueDescription(params) {
-  let { pluginId, slug, version, manifestJson, catalogName, catalogDescription, catalogTags } = params, lines = [
-    `**Plugin UUID:** ${pluginId}`,
-    `**Slug:** ${slug}`,
-    `**Version:** ${version}`
-  ];
-  return catalogName && lines.push(`**Name:** ${catalogName}`), catalogDescription && lines.push(`**Description:** ${catalogDescription}`), catalogTags && catalogTags.length > 0 && lines.push(`**Tags:** ${catalogTags.join(", ")}`), lines.push("", "**Manifest:**", "```json", manifestJson, "```"), lines.join(`
+// src/utils/getProjectPath.ts
+var import_path4 = __toESM(require("path")), isDevelopment = () => __dirname.includes("/src/"), getProjectPath = (relativePath) => {
+  let levelsUp = isDevelopment() ? "../.." : "..";
+  return import_path4.default.resolve(__dirname, levelsUp, relativePath);
+}, getTemplatesBaseDir = () => getProjectPath("templates"), getTemplatePath = (filename) => import_path4.default.join(getTemplatesBaseDir(), "_shared", filename);
+
+// src/commands/create/utils/initTemplate.ts
+init_logger();
+
+// src/commands/create/utils/updatePackageJson.ts
+var fs4 = __toESM(require("fs")), path6 = __toESM(require("path")), updatePackageJson = (targetDir, packageSlug) => {
+  let packageJsonPath = path6.join(targetDir, "package.json");
+  if (fs4.existsSync(packageJsonPath)) {
+    let packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+    packageJson.name = packageSlug, fs4.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
 `);
+  }
+};
+
+// src/commands/create/utils/initTemplate.ts
+var initTemplate = async ({ answers, targetDir }) => {
+  fs5.existsSync(targetDir) || fs5.mkdirSync(targetDir, { recursive: !0 });
+  let templatesBaseDir = getTemplatesBaseDir(), templatesDir = path7.join(templatesBaseDir, answers.template), sharedDir = path7.join(templatesBaseDir, "_shared");
+  await copyDirectory(sharedDir, targetDir), await copyDirectory(templatesDir, targetDir), updatePackageJson(targetDir, answers.packageSlug), logger_default.info("Created template with marketplace publication requirements."), logger_default.info(
+    "Before publishing, add ./marketplace/index.md, ./marketplace/header-image.jpg (784:325), and ./public/logo.svg (square)."
+  );
+};
+
+// src/commands/create/index.ts
+var DEFAULT_VERSION = "0.0.1";
+async function create() {
+  logger_default.info(getWelcomeMessage(process.cwd()));
+  let packageSlug = await (0, import_prompts2.input)({
+    message: "Enter app slug (e.g., my-tracker-plugin):",
+    required: !0
+  }), pluginName = await (0, import_prompts2.input)({
+    message: "Enter plugin name:",
+    required: !0
+  }), pluginDescription = await (0, import_prompts2.input)({
+    message: "Enter plugin description:",
+    required: !0
+  }), supportEmail = await (0, import_prompts2.input)({
+    message: "Enter support email:",
+    required: !0,
+    validate: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) || "Please enter a valid email address"
+  }), template = await (0, import_prompts2.select)({
+    message: "Select a template:",
+    choices: TEMPLATES.map((templateName) => ({
+      name: templateName,
+      value: templateName
+    }))
+  }), dataPermissions = await (0, import_prompts2.checkbox)({
+    message: "Select data permissions (some popular options):",
+    choices: TOP_DATA_PERMISSIONS.map((permission) => ({
+      name: permission,
+      value: permission
+    }))
+  }), answers = {
+    packageSlug,
+    slotTitle: packageSlug,
+    pluginName,
+    pluginDescription,
+    supportEmail,
+    template,
+    permissions: {
+      data: dataPermissions
+    },
+    version: DEFAULT_VERSION
+  }, targetDir = path8.join(process.cwd(), answers.packageSlug);
+  await initTemplate({
+    answers,
+    targetDir
+  }), initManifest({
+    answers,
+    targetDir
+  }), logger_default.newLine(), logger_default.success("Package generated!"), logger_default.commands("To get started, run", [
+    `cd ${answers.packageSlug}`,
+    "npm install",
+    "tracker-cli debug"
+  ]);
 }
-async function createPluginIssue(params) {
-  let { slug, pluginId, version, manifestJson } = params, body = {
-    queue: PLUGINMOD_QUEUE,
-    summary: buildIssueSummary(slug),
-    description: buildIssueDescription({ pluginId, slug, version, manifestJson }),
-    tags: ["tracker-plugin"]
-  };
-  return trackerApiRequest("/issues", {
-    method: "POST",
-    body
-  });
-}
-async function updatePluginIssue(issueKey, params) {
-  return trackerApiRequest(`/issues/${issueKey}`, {
-    method: "PATCH",
-    body: params
-  });
-}
-async function attachFileToIssue(issueKey, fileBuffer, fileName) {
-  let formData = new import_form_data.default();
-  return formData.append("file", fileBuffer, {
-    filename: fileName,
-    contentType: "application/zip"
-  }), trackerApiRequest(`/issues/${issueKey}/attachments`, {
-    method: "POST",
-    formData
-  });
-}
-async function getIssueAttachments(issueKey) {
-  return trackerApiRequest(`/issues/${issueKey}/attachments`, {
-    method: "GET"
-  });
-}
-async function getIssueTransitions(issueKey) {
-  return trackerApiRequest(`/issues/${issueKey}/transitions`, {
-    method: "GET"
-  });
-}
-async function executeIssueTransition(issueKey, transitionId) {
-  await trackerApiRequest(`/issues/${issueKey}/transitions/${transitionId}/_execute`, {
-    method: "POST",
-    body: {}
-  });
-}
-async function getIssue(issueKey) {
-  return trackerApiRequest(`/issues/${issueKey}`, {
-    method: "GET"
-  });
-}
-async function getMyPluginIssues() {
-  return trackerApiRequest("/issues/_search", {
-    method: "POST",
-    body: {
-      filter: {
-        queue: PLUGINMOD_QUEUE,
-        createdBy: "me()"
-      }
-    }
-  });
-}
-async function addIssueComment(issueKey, text) {
-  await trackerApiRequest(`/issues/${issueKey}/comments`, {
-    method: "POST",
-    body: { text }
-  });
-}
+
+// src/commands/debug/index.ts
+var import_fs7 = __toESM(require("fs")), import_path8 = __toESM(require("path"));
 
 // src/core/manifest/manifestManager.ts
-var import_fs2 = require("fs"), import_promises2 = require("fs/promises"), import_ajv = __toESM(require("ajv")), import_ajv_formats = __toESM(require("ajv-formats"));
+var import_fs3 = require("fs"), import_promises = require("fs/promises"), import_ajv = __toESM(require("ajv")), import_ajv_formats = __toESM(require("ajv-formats"));
 
 // src/core/manifest/formatValidationErrors.ts
 var priorityOrder = [
@@ -539,14 +670,14 @@ var priorityOrder = [
 }, formatValidationErrors = (errors) => {
   let errorsByPath = {};
   for (let error2 of errors) {
-    let path17 = error2.instancePath || "root";
-    errorsByPath[path17] || (errorsByPath[path17] = []), errorsByPath[path17].push(error2);
+    let path18 = error2.instancePath || "root";
+    errorsByPath[path18] || (errorsByPath[path18] = []), errorsByPath[path18].push(error2);
   }
-  return Object.entries(errorsByPath).map(([path17, pathErrors]) => {
+  return Object.entries(errorsByPath).map(([path18, pathErrors]) => {
     let error2 = [...pathErrors].sort(
       (a, b) => getPriority(a.keyword) - getPriority(b.keyword)
     )[0], formatter = errorMessages[error2.keyword], message = formatter ? formatter(error2.params) : error2.message;
-    return `  - ${path17}: ${message}`;
+    return `  - ${path18}: ${message}`;
   }).join(`
 `);
 };
@@ -560,7 +691,10 @@ var manifest_schema_default = {
   required: [
     "slug",
     "version",
-    "permissions"
+    "permissions",
+    "name",
+    "description",
+    "support"
   ],
   properties: {
     $schema: {
@@ -573,6 +707,23 @@ var manifest_schema_default = {
       maxLength: 63,
       pattern: "^[a-z0-9-]+$"
     },
+    manifest_version: {
+      type: "number",
+      description: "Manifest format version",
+      minimum: 1
+    },
+    supported_services: {
+      type: "array",
+      description: "Supported services for this plugin",
+      items: {
+        type: "string",
+        enum: [
+          "tracker"
+        ]
+      },
+      minItems: 1,
+      uniqueItems: !0
+    },
     slug: {
       type: "string",
       description: "Unique identifier for the plugin (lowercase letters, numbers, hyphen)",
@@ -621,13 +772,13 @@ var manifest_schema_default = {
           type: "string",
           description: "Russian description",
           minLength: 1,
-          maxLength: 300
+          maxLength: 255
         },
         en: {
           type: "string",
           description: "English description",
           minLength: 1,
-          maxLength: 300
+          maxLength: 255
         }
       },
       additionalProperties: !1
@@ -931,435 +1082,116 @@ var manifest_schema_default = {
       description: "Configuration for a specific slot",
       required: [
         "entrypoint",
-        "title"
-      ],
-      properties: {
-        entrypoint: {
-          type: "string",
-          description: "Entry point file path for the slot",
-          minLength: 1
-        },
-        title: {
-          type: "object",
-          description: "Localized titles for the slot",
-          required: [
-            "ru",
-            "en"
-          ],
-          properties: {
-            ru: {
-              type: "string",
-              description: "Russian title",
-              minLength: 1,
-              maxLength: 32
-            },
-            en: {
-              type: "string",
-              description: "English title",
-              minLength: 1,
-              maxLength: 32
-            }
-          },
-          additionalProperties: !1
-        },
-        description: {
-          type: "object",
-          description: "Localized descriptions for the slot",
-          required: [
-            "ru",
-            "en"
-          ],
-          properties: {
-            ru: {
-              type: "string",
-              description: "Russian description",
-              minLength: 1,
-              maxLength: 300
-            },
-            en: {
-              type: "string",
-              description: "English description",
-              minLength: 1,
-              maxLength: 300
-            }
-          },
-          additionalProperties: !1
-        }
-      },
-      additionalProperties: !1
-    }
-  }
-};
-
-// src/core/manifest/manifestManager.ts
-var validator = (() => {
-  let ajv = new import_ajv.default({ allErrors: !0, strict: !1 });
-  return (0, import_ajv_formats.default)(ajv), ajv.compile(manifest_schema_default);
-})(), manifestPath = "./manifest.json", parseManifest = (content) => {
-  let manifest;
-  try {
-    manifest = JSON.parse(content);
-  } catch (error2) {
-    throw error2 instanceof SyntaxError ? new Error(`File manifest.json contains invalid JSON: ${error2.message}`) : new Error(`Error reading manifest.json: ${error2.message}`);
-  }
-  return manifest;
-}, loadRaw = async () => {
-  if (!(0, import_fs2.existsSync)(manifestPath))
-    throw new Error(`File manifest.json not found at path: ${manifestPath}`);
-  try {
-    return await (0, import_promises2.readFile)(manifestPath, "utf8");
-  } catch (error2) {
-    throw error2 instanceof Error ? new Error(`Error reading manifest.json: ${error2.message}`) : new Error("Error loading manifest");
-  }
-}, load = async () => {
-  let manifestContent = await loadRaw();
-  return parseManifest(manifestContent);
-}, validate = async () => {
-  let manifest = await load();
-  if (!validator(manifest) && validator.errors) {
-    let errorMessages2 = formatValidationErrors(validator.errors);
-    throw new Error(`Manifest validation failed:
-${errorMessages2}`);
-  }
-}, save = async (manifest) => {
-  try {
-    let content = JSON.stringify(manifest, null, 4);
-    await (0, import_promises2.writeFile)(manifestPath, content, "utf8");
-  } catch (error2) {
-    throw error2 instanceof Error ? new Error(`Error saving manifest.json: ${error2.message}`) : new Error("Error saving manifest");
-  }
-}, update = async (updates) => {
-  let updatedManifest = { ...await load(), ...updates };
-  return await save(updatedManifest), updatedManifest;
-}, manifestManager = {
-  load,
-  loadRaw,
-  validate,
-  save,
-  update
-};
-
-// src/core/pluginState/pluginStateManager.ts
-var import_fs3 = require("fs"), import_promises3 = require("fs/promises"), STATE_FILE = ".tracker-plugin", load2 = async () => {
-  if (!(0, import_fs3.existsSync)(STATE_FILE))
-    return {};
-  try {
-    let content = await (0, import_promises3.readFile)(STATE_FILE, "utf8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}, save2 = async (state) => {
-  try {
-    let content = JSON.stringify(state, null, 4);
-    await (0, import_promises3.writeFile)(STATE_FILE, content, "utf8");
-  } catch (error2) {
-    throw error2 instanceof Error ? new Error(`Error saving ${STATE_FILE}: ${error2.message}`) : new Error(`Error saving ${STATE_FILE}`);
-  }
-}, update2 = async (updates) => {
-  let updated = { ...await load2(), ...updates };
-  return await save2(updated), updated;
-}, pluginStateManager = {
-  load: load2,
-  save: save2,
-  update: update2
-};
-
-// src/commands/catalog/index.ts
-init_logger();
-
-// src/utils/promptPluginMetadata.ts
-var import_prompts2 = require("@inquirer/prompts");
-async function promptPluginName() {
-  return (0, import_prompts2.input)({
-    message: "Plugin name:",
-    validate: (value) => value.trim() ? !0 : "Name is required"
-  });
-}
-async function promptPluginDescription() {
-  return (0, import_prompts2.input)({
-    message: "Plugin description:",
-    validate: (value) => value.trim() ? !0 : "Description is required"
-  });
-}
-async function promptPluginId(manifest) {
-  return (0, import_prompts2.input)({
-    message: "Plugin ID:",
-    default: manifest.id || void 0,
-    validate: (value) => value.trim() ? !0 : "Plugin ID is required"
-  });
-}
-async function promptPluginTags() {
-  return (await (0, import_prompts2.input)({
-    message: "Tags (comma-separated):"
-  })).split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0);
-}
-
-// src/commands/catalog/index.ts
-async function catalog() {
-  let manifest = await manifestManager.load(), state = await pluginStateManager.load();
-  if (!state.trackerIssueKey) {
-    logger_default.warning('Plugin is not registered yet. Run "tracker-cli register" first.'), logger_default.suggest("tracker-cli register");
-    return;
-  }
-  logger_default.newLine(), logger_default.info("\u{1F4DD} Catalog entry information:");
-  let name = await promptPluginName(), description = await promptPluginDescription(), tags = await promptPluginTags();
-  await pluginStateManager.update({
-    catalog: { name, description, tags }
-  }), logger_default.newLine(), logger_default.info("\u{1F4E4} Syncing catalog metadata to Tracker issue...");
-  let manifestJson = await manifestManager.loadRaw(), issueDescription = buildIssueDescription({
-    pluginId: manifest.id ?? "",
-    slug: manifest.slug,
-    version: manifest.version,
-    manifestJson,
-    catalogName: name,
-    catalogDescription: description,
-    catalogTags: tags
-  });
-  await updatePluginIssue(state.trackerIssueKey, {
-    description: issueDescription
-  }), logger_default.success("Catalog entry updated successfully!");
-}
-
-// src/commands/create/index.ts
-var path8 = __toESM(require("path")), import_prompts3 = require("@inquirer/prompts");
-
-// src/core/manifest/constants.ts
-var DATA_PERMISSIONS = [
-  // top 10
-  "tracker:issues:read",
-  "tracker:issues:write",
-  "tracker:issuetypes:read",
-  "tracker:statuses:read",
-  "tracker:queues:read",
-  "tracker:fields:read",
-  "tracker:entities:read",
-  "tracker:attachments:read",
-  "tracker:attachments:write",
-  // in alphabetical order
-  "tracker:applications:read",
-  "tracker:boards:read",
-  "tracker:boards:write",
-  "tracker:bulk:read",
-  "tracker:bulk:write",
-  "tracker:bulkchange:read",
-  "tracker:bulkchange:write",
-  "tracker:charts:read",
-  "tracker:commentTemplates:read",
-  "tracker:commentTemplates:write",
-  "tracker:components:read",
-  "tracker:components:write",
-  "tracker:data:read",
-  "tracker:departments:read",
-  "tracker:entities:write",
-  "tracker:externalEventTypes:write",
-  "tracker:externalEvents:write",
-  "tracker:fields:write",
-  "tracker:filterFolders:write",
-  "tracker:filters:read",
-  "tracker:filters:write",
-  "tracker:goals:read",
-  "tracker:goals:write",
-  "tracker:groups:read",
-  "tracker:issueTemplates:read",
-  "tracker:issueTemplates:write",
-  "tracker:links:read",
-  "tracker:linktypes:read",
-  "tracker:liveBoards:write",
-  "tracker:localFields:read",
-  "tracker:maillists:read",
-  "tracker:maillists:write",
-  "tracker:myself:read",
-  "tracker:myself:write",
-  "tracker:priorities:read",
-  "tracker:queues:write",
-  "tracker:reminders:read",
-  "tracker:reminders:write",
-  "tracker:remotelinks:read",
-  "tracker:reports:read",
-  "tracker:reports:write",
-  "tracker:resolutions:read",
-  "tracker:resources:read",
-  "tracker:resources:write",
-  "tracker:roles:read",
-  "tracker:screens:read",
-  "tracker:services:read",
-  "tracker:sprints:read",
-  "tracker:sprints:write",
-  "tracker:system:write",
-  "tracker:tags:read",
-  "tracker:translations:read",
-  "tracker:users:read",
-  "tracker:users:write",
-  "tracker:versions:read",
-  "tracker:versions:write",
-  "tracker:workflows:read",
-  "tracker:workflows:write",
-  "tracker:worklog:read",
-  "tracker:worklog:write"
-], TOP_DATA_PERMISSIONS = DATA_PERMISSIONS.slice(0, 10);
-var TEMPLATES = [
-  "default",
-  "issue.action",
-  "issue.block",
-  "issue.tab",
-  "issue.comment.action",
-  "navigation",
-  "trigger.action",
-  "project.action",
-  "portfolio.action",
-  "goal.action",
-  "issue.floatingbottom.action",
-  "attachment.viewer.action"
-];
-var TEMPLATE_SLOTS = {
-  default: [],
-  "issue.action": ["issue.action"],
-  "issue.block": ["issue.block"],
-  "issue.tab": ["issue.tab"],
-  "issue.comment.action": ["issue.comment.action"],
-  navigation: ["navigation"],
-  "trigger.action": ["trigger.create.action", "trigger.edit.action"],
-  "project.action": ["project.action"],
-  "portfolio.action": ["portfolio.action"],
-  "goal.action": ["goal.action"],
-  "issue.floatingbottom.action": ["issue.floatingbottom.action"],
-  "attachment.viewer.action": ["attachment.viewer.action"]
-};
-
-// src/commands/create/index.ts
-init_logger();
-
-// src/commands/create/utils/getWelcomeMessage.ts
-var import_picocolors2 = __toESM(require("picocolors")), getWelcomeMessage = (pwd) => `
-${import_picocolors2.default.bold(import_picocolors2.default.white("\u{1F680} Create new tracker plugin"))}
-
-${import_picocolors2.default.dim(`\u{1F4C1} Creating an app in your current directory: ${pwd}`)}
-
-${import_picocolors2.default.dim("Press")} ${import_picocolors2.default.yellow("Ctrl+C")} ${import_picocolors2.default.dim("to cancel.")}
-`;
-
-// src/commands/create/utils/initManifest.ts
-var fs2 = __toESM(require("fs")), path3 = __toESM(require("path"));
-
-// src/commands/create/utils/generateManifest.ts
-function buildSlots(template, slotTitle) {
-  let slotNames = TEMPLATE_SLOTS[template];
-  if (slotNames.length === 0) return;
-  let slotEntry = {
-    entrypoint: "index.html",
-    title: { ru: slotTitle, en: slotTitle }
-  };
-  return {
-    tracker: Object.fromEntries(slotNames.map((slotName) => [slotName, [slotEntry]]))
-  };
-}
-var generateManifest = (answers) => ({
-  $schema: "./manifest.schema.json",
-  slug: answers.packageSlug,
-  version: answers.version,
-  permissions: answers.permissions,
-  slots: buildSlots(answers.template, answers.slotTitle)
-});
-
-// src/commands/create/utils/initManifest.ts
-var initManifest = ({ answers, targetDir }) => {
-  let generatedManifest = generateManifest(answers), manifestPath2 = path3.join(targetDir, "manifest.json");
-  fs2.writeFileSync(manifestPath2, JSON.stringify(generatedManifest, null, 2), "utf-8");
-};
-
-// src/commands/create/utils/initTemplate.ts
-var fs5 = __toESM(require("fs")), path7 = __toESM(require("path"));
-
-// src/utils/copyDirectory.ts
-var fs3 = __toESM(require("fs")), import_path2 = __toESM(require("path")), import_tinyglobby = require("tinyglobby"), resolveTargetFileName = (file) => file.endsWith(".template") ? "." + file.replace(".template", "") : file, copyDirectory = async (sourceDir, targetDir) => {
-  let files = await (0, import_tinyglobby.glob)(["**/*"], {
-    cwd: sourceDir,
-    onlyFiles: !0,
-    dot: !0
-  });
-  await Promise.all(
-    files.map(async (file) => {
-      let sourcePath = import_path2.default.join(sourceDir, file), targetFile = resolveTargetFileName(file), targetPath = import_path2.default.join(targetDir, targetFile);
-      await fs3.promises.mkdir(import_path2.default.dirname(targetPath), { recursive: !0 }), await fs3.promises.copyFile(sourcePath, targetPath);
-    })
-  );
-};
-
-// src/utils/getProjectPath.ts
-var import_path3 = __toESM(require("path")), isDevelopment = () => __dirname.includes("/src/"), getProjectPath = (relativePath) => {
-  let levelsUp = isDevelopment() ? "../.." : "..";
-  return import_path3.default.resolve(__dirname, levelsUp, relativePath);
-}, getTemplatesBaseDir = () => getProjectPath("templates"), getTemplatePath = (filename) => import_path3.default.join(getTemplatesBaseDir(), "_shared", filename);
-
-// src/commands/create/utils/initTemplate.ts
-init_logger();
-
-// src/commands/create/utils/updatePackageJson.ts
-var fs4 = __toESM(require("fs")), path6 = __toESM(require("path")), updatePackageJson = (targetDir, packageSlug) => {
-  let packageJsonPath = path6.join(targetDir, "package.json");
-  if (fs4.existsSync(packageJsonPath)) {
-    let packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
-    packageJson.name = packageSlug, fs4.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
-`);
+        "title"
+      ],
+      properties: {
+        entrypoint: {
+          type: "string",
+          description: "Entry point file path for the slot",
+          minLength: 1
+        },
+        title: {
+          type: "object",
+          description: "Localized titles for the slot",
+          required: [
+            "ru",
+            "en"
+          ],
+          properties: {
+            ru: {
+              type: "string",
+              description: "Russian title",
+              minLength: 1,
+              maxLength: 32
+            },
+            en: {
+              type: "string",
+              description: "English title",
+              minLength: 1,
+              maxLength: 32
+            }
+          },
+          additionalProperties: !1
+        },
+        description: {
+          type: "object",
+          description: "Localized descriptions for the slot",
+          required: [
+            "ru",
+            "en"
+          ],
+          properties: {
+            ru: {
+              type: "string",
+              description: "Russian description",
+              minLength: 1,
+              maxLength: 300
+            },
+            en: {
+              type: "string",
+              description: "English description",
+              minLength: 1,
+              maxLength: 300
+            }
+          },
+          additionalProperties: !1
+        }
+      },
+      additionalProperties: !1
+    }
   }
 };
 
-// src/commands/create/utils/initTemplate.ts
-var initTemplate = async ({ answers, targetDir }) => {
-  fs5.existsSync(targetDir) || fs5.mkdirSync(targetDir, { recursive: !0 });
-  let templatesBaseDir = getTemplatesBaseDir(), templatesDir = path7.join(templatesBaseDir, answers.template), sharedDir = path7.join(templatesBaseDir, "_shared");
-  await copyDirectory(sharedDir, targetDir), await copyDirectory(templatesDir, targetDir), updatePackageJson(targetDir, answers.packageSlug), logger_default.info("Created template with marketplace publication requirements."), logger_default.info(
-    "Before publishing, add ./marketplace/index.md, ./marketplace/header-image.jpg (784:325), and ./public/logo.svg (square)."
-  );
+// src/core/manifest/manifestManager.ts
+var validator = (() => {
+  let ajv = new import_ajv.default({ allErrors: !0, strict: !1 });
+  return (0, import_ajv_formats.default)(ajv), ajv.compile(manifest_schema_default);
+})(), manifestPath = "./manifest.json", parseManifest = (content) => {
+  let manifest;
+  try {
+    manifest = JSON.parse(content);
+  } catch (error2) {
+    throw error2 instanceof SyntaxError ? new Error(`File manifest.json contains invalid JSON: ${error2.message}`) : new Error(`Error reading manifest.json: ${error2.message}`);
+  }
+  return manifest;
+}, loadRaw = async () => {
+  if (!(0, import_fs3.existsSync)(manifestPath))
+    throw new Error(`File manifest.json not found at path: ${manifestPath}`);
+  try {
+    return await (0, import_promises.readFile)(manifestPath, "utf8");
+  } catch (error2) {
+    throw error2 instanceof Error ? new Error(`Error reading manifest.json: ${error2.message}`) : new Error("Error loading manifest");
+  }
+}, load = async () => {
+  let manifestContent = await loadRaw();
+  return parseManifest(manifestContent);
+}, validate = async () => {
+  let manifest = await load();
+  if (!validator(manifest) && validator.errors) {
+    let errorMessages2 = formatValidationErrors(validator.errors);
+    throw new Error(`Manifest validation failed:
+${errorMessages2}`);
+  }
+}, save = async (manifest) => {
+  try {
+    let content = JSON.stringify(manifest, null, 4);
+    await (0, import_promises.writeFile)(manifestPath, content, "utf8");
+  } catch (error2) {
+    throw error2 instanceof Error ? new Error(`Error saving manifest.json: ${error2.message}`) : new Error("Error saving manifest");
+  }
+}, update = async (updates) => {
+  let updatedManifest = { ...await load(), ...updates };
+  return await save(updatedManifest), updatedManifest;
+}, manifestManager = {
+  load,
+  loadRaw,
+  validate,
+  save,
+  update
 };
 
-// src/commands/create/index.ts
-var DEFAULT_VERSION = "0.0.1";
-async function create() {
-  logger_default.info(getWelcomeMessage(process.cwd()));
-  let packageSlug = await (0, import_prompts3.input)({
-    message: "Enter app slug (e.g., my-tracker-plugin):",
-    required: !0
-  }), template = await (0, import_prompts3.select)({
-    message: "Select a template:",
-    choices: TEMPLATES.map((templateName) => ({
-      name: templateName,
-      value: templateName
-    }))
-  }), dataPermissions = await (0, import_prompts3.checkbox)({
-    message: "Select data permissions (some popular options):",
-    choices: TOP_DATA_PERMISSIONS.map((permission) => ({
-      name: permission,
-      value: permission
-    }))
-  }), answers = {
-    packageSlug,
-    slotTitle: packageSlug,
-    template,
-    permissions: {
-      data: dataPermissions
-    },
-    version: DEFAULT_VERSION
-  }, targetDir = path8.join(process.cwd(), answers.packageSlug);
-  await initTemplate({
-    answers,
-    targetDir
-  }), initManifest({
-    answers,
-    targetDir
-  }), logger_default.newLine(), logger_default.success("Package generated!"), logger_default.commands("To get started, run", [
-    `cd ${answers.packageSlug}`,
-    "npm install",
-    "tracker-cli debug"
-  ]);
-}
-
-// src/commands/debug/index.ts
-var import_fs7 = __toESM(require("fs")), import_path7 = __toESM(require("path"));
-
 // src/core/s3config/constants.ts
-var CONFIG_FILE_NAME = "config.json", mimeTypes = {
+var CONFIG_FILE_NAME = "config.json", DEFAULT_ENVIRONMENT = "production", mimeTypes = {
   ".html": "text/html",
   ".css": "text/css",
   ".js": "text/javascript",
@@ -1390,13 +1222,13 @@ var registerCleanup = (cleanup) => {
 };
 
 // src/commands/debug/utils/createDebugConfig.ts
-var import_fs4 = __toESM(require("fs")), import_path4 = __toESM(require("path"));
+var import_fs4 = __toESM(require("fs")), import_path5 = __toESM(require("path"));
 
 // src/utils/convertManifestToConfig.ts
-function buildPluginDownloadUrl(baseUrl, id, version) {
-  return `${baseUrl.replace(/\/+$/, "")}/${id}/${version}`;
+function buildPluginDownloadUrl(env, id, version) {
+  return `${getPluginDownloadBase2(env)}/${id}/${version}`;
 }
-var convertManifestToConfig = (manifest, downloadBaseUrl) => {
+var convertManifestToConfig = (manifest, environment) => {
   let config = {};
   if (!manifest.slots)
     return config;
@@ -1420,7 +1252,7 @@ var convertManifestToConfig = (manifest, downloadBaseUrl) => {
               entrypoint: slotConfig.entrypoint,
               title: slotConfig.title,
               downloadUrl: buildPluginDownloadUrl(
-                downloadBaseUrl,
+                environment,
                 manifest.slug,
                 manifest.version
               )
@@ -1434,13 +1266,13 @@ var convertManifestToConfig = (manifest, downloadBaseUrl) => {
 };
 
 // src/commands/debug/utils/createDebugConfig.ts
-var DEBUG_DOWNLOAD_BASE = "http://localhost:5173/plugins-debug", createDebugConfig = async () => {
-  let manifest = await manifestManager.load(), config = convertManifestToConfig(manifest, DEBUG_DOWNLOAD_BASE), configPath = import_path4.default.join(process.cwd(), CONFIG_FILE_NAME);
+var createDebugConfig = async () => {
+  let manifest = await manifestManager.load(), config = convertManifestToConfig(manifest, "debug"), configPath = import_path5.default.join(process.cwd(), CONFIG_FILE_NAME);
   import_fs4.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
 };
 
 // src/commands/debug/utils/lockFile.ts
-var import_fs5 = __toESM(require("fs")), import_path5 = __toESM(require("path")), LOCK_FILE_NAME = ".tracker-cli-debug.lock", getLockFilePath = () => import_path5.default.join(process.cwd(), LOCK_FILE_NAME), getRunningDebugPid = () => {
+var import_fs5 = __toESM(require("fs")), import_path6 = __toESM(require("path")), LOCK_FILE_NAME = ".tracker-cli-debug.lock", getLockFilePath = () => import_path6.default.join(process.cwd(), LOCK_FILE_NAME), getRunningDebugPid = () => {
   let lockPath = getLockFilePath();
   if (!import_fs5.default.existsSync(lockPath))
     return null;
@@ -1465,10 +1297,10 @@ var import_fs5 = __toESM(require("fs")), import_path5 = __toESM(require("path"))
 };
 
 // src/commands/debug/utils/watchManifest.ts
-var import_fs6 = __toESM(require("fs")), import_path6 = __toESM(require("path"));
+var import_fs6 = __toESM(require("fs")), import_path7 = __toESM(require("path"));
 init_logger();
 var watchManifest = () => {
-  let manifestPath2 = import_path6.default.join(process.cwd(), "manifest.json"), debounceTimer = null, watcher = import_fs6.default.watch(manifestPath2, async (eventType) => {
+  let manifestPath2 = import_path7.default.join(process.cwd(), "manifest.json"), debounceTimer = null, watcher = import_fs6.default.watch(manifestPath2, async (eventType) => {
     eventType === "change" && (debounceTimer && clearTimeout(debounceTimer), debounceTimer = setTimeout(async () => {
       try {
         logger_default.newLine(), logger_default.info("Manifest file changed, validating..."), await manifestManager.validate(), logger_default.info("Regenerating debug config..."), await createDebugConfig(), logger_default.success("Debug config regenerated successfully");
@@ -1492,7 +1324,7 @@ Please stop the existing instance before starting a new one.
 If you lost the terminal tab, you can kill the process with:
   kill ${runningPid}`
   ), process.exit(1));
-  let configPath = import_path7.default.join(process.cwd(), CONFIG_FILE_NAME);
+  let configPath = import_path8.default.join(process.cwd(), CONFIG_FILE_NAME);
   options.lint && await manifestManager.validate(), await createDebugConfig();
   let watcher = watchManifest(), cleanup = () => {
     watcher.close(), import_fs7.default.existsSync(configPath) && import_fs7.default.unlinkSync(configPath), removeLockFile();
@@ -1500,16 +1332,21 @@ If you lost the terminal tab, you can kill the process with:
   registerCleanup(cleanup), createLockFile(), await execCommand(pluginCmd.dev), cleanup();
 }
 
-// src/distribution/promptEnvironment.ts
-var impl5 = (init_promptEnvironment(), __toCommonJS(promptEnvironment_exports)), { promptEnvironment: promptEnvironment2 } = impl5;
-
-// src/core/s3config/s3Manager.ts
-var import_fs8 = require("fs"), import_promises4 = require("fs/promises"), os3 = __toESM(require("os")), import_path8 = __toESM(require("path")), import_client_s3 = require("@aws-sdk/client-s3"), import_lib_storage = require("@aws-sdk/lib-storage"), import_tinyglobby2 = require("tinyglobby");
-
-// src/distribution/storage.ts
-var impl6 = (init_storage(), __toCommonJS(storage_exports)), { DEFAULT_ENVIRONMENT: DEFAULT_ENVIRONMENT2, getStorageSettings: getStorageSettings2, listEnvironments: listEnvironments2 } = impl6;
+// src/core/s3config/promptEnvironment.ts
+var import_prompts3 = require("@inquirer/prompts");
+async function promptEnvironment() {
+  return await (0, import_prompts3.select)({
+    message: "Select environment:",
+    choices: [
+      { name: "Testing", value: "testing" },
+      { name: "Production", value: "production" }
+    ],
+    default: "testing"
+  });
+}
 
 // src/core/s3config/s3Manager.ts
+var import_fs8 = require("fs"), import_promises2 = require("fs/promises"), os2 = __toESM(require("os")), import_path9 = __toESM(require("path")), import_client_s3 = require("@aws-sdk/client-s3"), import_lib_storage = require("@aws-sdk/lib-storage"), import_tinyglobby2 = require("tinyglobby");
 init_logger();
 
 // src/core/s3config/promptCredentials.ts
@@ -1540,23 +1377,22 @@ var import_prompts4 = require("@inquirer/prompts"), promptS3Credentials = async
 };
 
 // src/core/s3config/s3Manager.ts
+async function streamToBuffer(body) {
+  if (!body)
+    return Buffer.alloc(0);
+  let chunks = [];
+  for await (let chunk of body)
+    chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks);
+}
 var S3Manager = class {
   constructor() {
-    this.credentialsDir = import_path8.default.join(os3.homedir(), ".tracker-cli");
-    this.credentialsFile = import_path8.default.join(this.credentialsDir, "s3-credentials.json");
-    this._environment = DEFAULT_ENVIRONMENT2;
-    this._settings = null;
-  }
-  async setEnvironment(environment) {
-    this._environment = environment, this._settings = await getStorageSettings2(environment), logger_default.info(`Environment set to: ${environment}`);
-  }
-  getEnvironment() {
-    return this._environment;
+    this.credentialsDir = import_path9.default.join(os2.homedir(), ".tracker-cli");
+    this.credentialsFile = import_path9.default.join(this.credentialsDir, "s3-credentials.json");
+    this._environment = DEFAULT_ENVIRONMENT;
   }
-  getSettings() {
-    if (!this._settings)
-      throw new Error("Storage settings not loaded. Call s3Manager.setEnvironment() first.");
-    return this._settings;
+  setEnvironment(environment) {
+    this._environment = environment, logger_default.info(`Environment set to: ${environment}`);
   }
   async checkS3Auth() {
     await this.checkAuth("s3");
@@ -1565,7 +1401,7 @@ var S3Manager = class {
     await this.checkAuth("mds");
   }
   async saveCredentials(credentials) {
-    (0, import_fs8.existsSync)(this.credentialsDir) || (0, import_fs8.mkdirSync)(this.credentialsDir, { recursive: !0, mode: 448 }), await (0, import_promises4.writeFile)(this.credentialsFile, JSON.stringify(credentials, null, 2), {
+    (0, import_fs8.existsSync)(this.credentialsDir) || (0, import_fs8.mkdirSync)(this.credentialsDir, { recursive: !0, mode: 448 }), await (0, import_promises2.writeFile)(this.credentialsFile, JSON.stringify(credentials, null, 2), {
       mode: 384
     });
   }
@@ -1580,21 +1416,18 @@ var S3Manager = class {
     }
   }
   async getPluginsConfig() {
-    let s3Client = this.createMdsS3Client(), bucket = this.getSettings().configBucket;
+    let s3Client = this.createMdsS3Client(), bucket = this.getConfigBucket();
     try {
-      let { Body } = await s3Client.send(
+      let response = await s3Client.send(
         new import_client_s3.GetObjectCommand({ Bucket: bucket, Key: CONFIG_FILE_NAME })
-      );
-      if (!Body)
-        return logger_default.info("NO DATA"), {};
-      let text = await Body.transformToString("utf8");
-      return JSON.parse(text);
+      ), body = await streamToBuffer(response.Body);
+      return body.length ? JSON.parse(body.toString("utf8")) : (logger_default.info("NO DATA"), {});
     } catch (error2) {
       return logger_default.error("Error getting plugins config from S3", error2), process.exit();
     }
   }
   async savePluginsConfig(config) {
-    let s3Client = this.createMdsS3Client(), bucket = this.getSettings().configBucket;
+    let s3Client = this.createMdsS3Client(), bucket = this.getConfigBucket();
     try {
       await new import_lib_storage.Upload({
         client: s3Client,
@@ -1614,11 +1447,11 @@ var S3Manager = class {
       logger_default.warning("No files to upload in dist folder");
       return;
     }
-    let keyPrefix = `${manifest.slug}/${manifest.version}/`, s3Client = this.createAwsS3Client(), distPath = import_path8.default.resolve("./dist"), bucket = this.getSettings().staticBucket;
+    let keyPrefix = `${manifest.slug}/${manifest.version}/`, s3Client = this.createAwsS3Client(), distPath = import_path9.default.resolve("./dist"), bucket = this.getStaticBucket();
     logger_default.info(`\u{1F4E6} Starting file upload from ${distPath} to S3 bucket: ${bucket}`);
     for (let filePath of files)
       try {
-        let fileContent = await (0, import_promises4.readFile)(filePath), relativePath = import_path8.default.relative(distPath, filePath), s3Key = keyPrefix + relativePath.replace(/\\/g, "/"), mimeType = this.getMimeType(filePath);
+        let fileContent = await (0, import_promises2.readFile)(filePath), relativePath = import_path9.default.relative(distPath, filePath), s3Key = keyPrefix + relativePath.replace(/\\/g, "/"), mimeType = this.getMimeType(filePath);
         logger_default.info(`\u2B06\uFE0F  Uploading: ${relativePath}`), await new import_lib_storage.Upload({
           client: s3Client,
           params: {
@@ -1639,15 +1472,15 @@ var S3Manager = class {
    * @param rootPaths  paths relative to cwd, e.g. ['manifest.json', 'marketplace']
    */
   async uploadRootFiles(manifest, rootPaths) {
-    let keyPrefix = `${manifest.slug}/${manifest.version}/`, s3Client = this.createAwsS3Client(), bucket = this.getSettings().staticBucket, cwd = process.cwd();
+    let keyPrefix = `${manifest.slug}/${manifest.version}/`, s3Client = this.createAwsS3Client(), bucket = this.getStaticBucket(), cwd = process.cwd();
     for (let rootPath of rootPaths) {
-      let absPath = import_path8.default.resolve(cwd, rootPath);
+      let absPath = import_path9.default.resolve(cwd, rootPath);
       if (!(0, import_fs8.existsSync)(absPath)) {
         logger_default.warning(`Skipping "${rootPath}" \u2014 not found`);
         continue;
       }
       if ((await import("fs")).statSync(absPath).isFile()) {
-        let fileContent = await (0, import_promises4.readFile)(absPath), s3Key = keyPrefix + import_path8.default.basename(absPath), mimeType = this.getMimeType(absPath);
+        let fileContent = await (0, import_promises2.readFile)(absPath), s3Key = keyPrefix + import_path9.default.basename(absPath), mimeType = this.getMimeType(absPath);
         logger_default.info(`\u2B06\uFE0F  Uploading: ${rootPath}`), await new import_lib_storage.Upload({
           client: s3Client,
           params: {
@@ -1665,7 +1498,7 @@ var S3Manager = class {
         });
         for (let filePath of files)
           try {
-            let fileContent = await (0, import_promises4.readFile)(filePath), relativePath = import_path8.default.relative(cwd, filePath), s3Key = keyPrefix + relativePath.replace(/\\/g, "/"), mimeType = this.getMimeType(filePath);
+            let fileContent = await (0, import_promises2.readFile)(filePath), relativePath = import_path9.default.relative(cwd, filePath), s3Key = keyPrefix + relativePath.replace(/\\/g, "/"), mimeType = this.getMimeType(filePath);
             logger_default.info(`\u2B06\uFE0F  Uploading: ${relativePath}`), await new import_lib_storage.Upload({
               client: s3Client,
               params: {
@@ -1682,10 +1515,10 @@ var S3Manager = class {
     }
   }
   createAwsS3Client() {
-    let credentials = this.credentials, settings = this.getSettings();
+    let credentials = this.credentials;
     return (!credentials?.s3AccessKeyId || !credentials?.s3SecretAccessKey) && (logger_default.error("S3 credentials not found. Please log in using: tracker-cli login"), process.exit()), new import_client_s3.S3Client({
-      region: settings.awsRegion,
-      endpoint: settings.awsEndpoint,
+      region: getS3Region2(),
+      endpoint: getS3Endpoint2(),
       credentials: {
         accessKeyId: credentials.s3AccessKeyId,
         secretAccessKey: credentials.s3SecretAccessKey
@@ -1700,10 +1533,9 @@ var S3Manager = class {
     if (!creds || !creds.s3AccessKeyId || !creds.s3SecretAccessKey)
       return !1;
     try {
-      let settings = await this.resolveSettings();
       return await new import_client_s3.S3Client({
-        region: settings.awsRegion,
-        endpoint: settings.awsEndpoint,
+        region: getS3Region2(),
+        endpoint: getS3Endpoint2(),
         credentials: {
           accessKeyId: creds.s3AccessKeyId,
           secretAccessKey: creds.s3SecretAccessKey
@@ -1718,18 +1550,8 @@ var S3Manager = class {
     if (!creds || !creds.mdsAccessKeyId || !creds.mdsSecretAccessKey)
       return !1;
     try {
-      let settings = await this.resolveSettings();
-      return await new import_client_s3.S3Client({
-        region: settings.awsRegion,
-        endpoint: settings.mdsEndpoint,
-        forcePathStyle: !0,
-        credentials: {
-          accessKeyId: creds.mdsAccessKeyId,
-          secretAccessKey: creds.mdsSecretAccessKey
-        }
-      }).send(
-        new import_client_s3.GetObjectCommand({ Bucket: settings.configBucket, Key: CONFIG_FILE_NAME })
-      ), !0;
+      let mdsClient = this.buildMdsS3Client(creds), bucket = this.getConfigBucket();
+      return await mdsClient.send(new import_client_s3.GetObjectCommand({ Bucket: bucket, Key: CONFIG_FILE_NAME })), !0;
     } catch (error2) {
       return logger_default.error("MDS credential validation failed:", error2), !1;
     }
@@ -1760,11 +1582,20 @@ var S3Manager = class {
     }
     await this.saveCredentials(updatedCreds), logger_default.success(`${type.toUpperCase()} credentials saved successfully.`);
   }
+  getConfigBucket() {
+    return getBuckets2()[this._environment].config;
+  }
+  getStaticBucket() {
+    return getBuckets2()[this._environment].static;
+  }
   createMdsS3Client() {
-    let credentials = this.credentials, settings = this.getSettings();
-    return (!credentials?.mdsAccessKeyId || !credentials?.mdsSecretAccessKey) && (logger_default.error("MdsS3 credentials not found. Please log in using: tracker-cli login"), process.exit()), new import_client_s3.S3Client({
-      region: settings.awsRegion,
-      endpoint: settings.mdsEndpoint,
+    let credentials = this.credentials;
+    return (!credentials?.mdsAccessKeyId || !credentials?.mdsSecretAccessKey) && (logger_default.error("MdsS3 credentials not found. Please log in using: tracker-cli login"), process.exit()), this.buildMdsS3Client(credentials);
+  }
+  buildMdsS3Client(credentials) {
+    return new import_client_s3.S3Client({
+      region: getS3Region2(),
+      endpoint: getMdsEndpoint2(),
       forcePathStyle: !0,
       credentials: {
         accessKeyId: credentials.mdsAccessKeyId,
@@ -1772,37 +1603,192 @@ var S3Manager = class {
       }
     });
   }
-  async resolveSettings() {
-    return this._settings ? this._settings : (this._settings = await getStorageSettings2(this._environment), this._settings);
-  }
   getMimeType(filePath) {
-    let ext = import_path8.default.extname(filePath).toLowerCase();
+    let ext = import_path9.default.extname(filePath).toLowerCase();
     return mimeTypes[ext] || "application/octet-stream";
   }
 }, s3Manager = new S3Manager();
 
-// src/utils/getFiles.ts
-var import_fs9 = __toESM(require("fs")), import_path9 = __toESM(require("path")), import_tinyglobby3 = require("tinyglobby");
-init_logger();
-var getFiles = async () => {
-  let distPath = import_path9.default.resolve("./dist");
-  import_fs9.default.existsSync(distPath) || (logger_default.error("Dist folder not found. Build the project first"), process.exit());
-  let files = await (0, import_tinyglobby3.glob)(["**/*"], {
-    cwd: distPath,
-    onlyFiles: !0,
-    absolute: !0
+// src/utils/getFiles.ts
+var import_fs9 = __toESM(require("fs")), import_path10 = __toESM(require("path")), import_tinyglobby3 = require("tinyglobby");
+init_logger();
+var getFiles = async () => {
+  let distPath = import_path10.default.resolve("./dist");
+  import_fs9.default.existsSync(distPath) || (logger_default.error("Dist folder not found. Build the project first"), process.exit());
+  let files = await (0, import_tinyglobby3.glob)(["**/*"], {
+    cwd: distPath,
+    onlyFiles: !0,
+    absolute: !0
+  });
+  return logger_default.info(`\u{1F4C1} Found ${files.length} files to upload`), files;
+};
+
+// src/commands/deploy/index.ts
+async function deploy() {
+  await s3Manager.checkS3Auth();
+  let environment = await promptEnvironment();
+  s3Manager.setEnvironment(environment);
+  let manifest = await manifestManager.load();
+  await build({ environment });
+  let files = await getFiles();
+  await s3Manager.uploadPluginFiles(manifest, files);
+}
+
+// src/api/tracker.ts
+var import_form_data = __toESM(require("form-data"));
+
+// src/api/trackerApiRequest.ts
+var import_node_fetch2 = __toESM(require("node-fetch"));
+
+// src/core/auth/authManager.ts
+var fs11 = __toESM(require("fs")), os3 = __toESM(require("os")), path15 = __toESM(require("path")), authDir = path15.join(os3.homedir(), ".tracker-cli"), authFile = path15.join(authDir, "auth.json"), getData = () => {
+  try {
+    if (!fs11.existsSync(authFile))
+      return null;
+    let data = fs11.readFileSync(authFile, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}, getAuthHeader = () => {
+  let authData = getData();
+  return authData ? `OAuth ${authData.token}` : null;
+}, saveAuthData = (token) => {
+  let authData = {
+    token
+  };
+  fs11.existsSync(authDir) || fs11.mkdirSync(authDir, { recursive: !0, mode: 448 }), fs11.writeFileSync(authFile, JSON.stringify(authData, null, 2), {
+    mode: 384
+  });
+}, removeAuthData = () => {
+  fs11.existsSync(authFile) && fs11.unlinkSync(authFile);
+}, authManager = {
+  get authHeader() {
+    return getAuthHeader();
+  },
+  get data() {
+    return getData();
+  },
+  saveAuthData,
+  removeAuthData
+};
+
+// src/api/trackerApiRequest.ts
+function buildQueryString(queryParams) {
+  if (!queryParams || Object.keys(queryParams).length === 0)
+    return "";
+  let params = new URLSearchParams();
+  return Object.entries(queryParams).forEach(([key, value]) => {
+    params.append(key, String(value));
+  }), `?${params.toString()}`;
+}
+async function parseResponse(response) {
+  return response.status === 204 || response.headers.get("content-length") === "0" ? void 0 : response.headers.get("content-type")?.includes("application/json") ? await response.json() : await response.text();
+}
+async function trackerApiRequest(endpoint, options = {}) {
+  let { method = "GET", body, headers = {}, formData, queryParams } = options, authHeader = authManager.authHeader;
+  if (!authHeader)
+    throw new Error('Not authenticated. Run "tracker-cli login" first.');
+  let requestHeaders = {
+    Authorization: authHeader,
+    Accept: "application/json",
+    ...headers
+  }, requestBody;
+  if (formData) {
+    let formHeaders = formData.getHeaders?.();
+    Object.assign(requestHeaders, formHeaders), requestBody = formData;
+  } else body && method !== "GET" && (requestHeaders["Content-Type"] = "application/json", requestBody = JSON.stringify(body));
+  let queryString = buildQueryString(queryParams), url = `${getTrackerBaseUrl2()}${endpoint}${queryString}`, response = await (0, import_node_fetch2.default)(url, {
+    method,
+    headers: requestHeaders,
+    body: requestBody
+  });
+  if (!response.ok) {
+    let errorText = await response.text(), errorMessage = `Tracker API error ${response.status}: ${errorText}`;
+    try {
+      let errorJson = JSON.parse(errorText);
+      errorJson.message && (errorMessage = `Tracker API error ${response.status}: ${errorJson.message}`);
+    } catch {
+    }
+    throw new Error(errorMessage);
+  }
+  return parseResponse(response);
+}
+
+// src/api/tracker.ts
+var PLUGINMOD_QUEUE = "PLUGINMOD";
+function buildIssueSummary(slug) {
+  return `Plugin: ${slug}`;
+}
+function buildIssueDescription(params) {
+  let { pluginId, slug, version, manifestJson, catalogName, catalogDescription, catalogTags } = params, lines = [
+    `**Plugin UUID:** ${pluginId}`,
+    `**Slug:** ${slug}`,
+    `**Version:** ${version}`
+  ];
+  return catalogName && lines.push(`**Name:** ${catalogName}`), catalogDescription && lines.push(`**Description:** ${catalogDescription}`), catalogTags && catalogTags.length > 0 && lines.push(`**Tags:** ${catalogTags.join(", ")}`), lines.push("", "**Manifest:**", "```json", manifestJson, "```"), lines.join(`
+`);
+}
+async function createPluginIssue(params) {
+  let { slug, pluginId, version, manifestJson } = params, body = {
+    queue: PLUGINMOD_QUEUE,
+    summary: buildIssueSummary(slug),
+    description: buildIssueDescription({ pluginId, slug, version, manifestJson }),
+    tags: ["tracker-plugin"]
+  };
+  return trackerApiRequest("/issues", {
+    method: "POST",
+    body
+  });
+}
+async function updatePluginIssue(issueKey, params) {
+  return trackerApiRequest(`/issues/${issueKey}`, {
+    method: "PATCH",
+    body: params
+  });
+}
+async function attachFileToIssue(issueKey, fileBuffer, fileName) {
+  let formData = new import_form_data.default();
+  return formData.append("file", fileBuffer, {
+    filename: fileName,
+    contentType: "application/zip"
+  }), trackerApiRequest(`/issues/${issueKey}/attachments`, {
+    method: "POST",
+    formData
+  });
+}
+async function getIssueTransitions(issueKey) {
+  return trackerApiRequest(`/issues/${issueKey}/transitions`, {
+    method: "GET"
+  });
+}
+async function executeIssueTransition(issueKey, transitionId) {
+  await trackerApiRequest(`/issues/${issueKey}/transitions/${transitionId}/_execute`, {
+    method: "POST",
+    body: {}
+  });
+}
+async function getIssue(issueKey) {
+  return trackerApiRequest(`/issues/${issueKey}`, {
+    method: "GET"
+  });
+}
+async function getMyPluginIssues() {
+  return trackerApiRequest("/issues/_search", {
+    method: "POST",
+    body: {
+      filter: {
+        queue: PLUGINMOD_QUEUE,
+        createdBy: "me()"
+      }
+    }
+  });
+}
+async function addIssueComment(issueKey, text) {
+  await trackerApiRequest(`/issues/${issueKey}/comments`, {
+    method: "POST",
+    body: { text }
   });
-  return logger_default.info(`\u{1F4C1} Found ${files.length} files to upload`), files;
-};
-
-// src/commands/deploy/index.ts
-async function deploy() {
-  let environment = await promptEnvironment2();
-  await s3Manager.setEnvironment(environment), await s3Manager.checkS3Auth();
-  let manifest = await manifestManager.load();
-  await build({ environment });
-  let files = await getFiles();
-  await s3Manager.uploadPluginFiles(manifest, files);
 }
 
 // src/api/utils.ts
@@ -1837,6 +1823,32 @@ function mapTrackerStatusToPluginStatus(issue) {
   }
 }
 
+// src/core/pluginState/pluginStateManager.ts
+var import_fs10 = require("fs"), import_promises3 = require("fs/promises"), STATE_FILE = ".tracker-plugin", load2 = async () => {
+  if (!(0, import_fs10.existsSync)(STATE_FILE))
+    return {};
+  try {
+    let content = await (0, import_promises3.readFile)(STATE_FILE, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}, save2 = async (state) => {
+  try {
+    let content = JSON.stringify(state, null, 4);
+    await (0, import_promises3.writeFile)(STATE_FILE, content, "utf8");
+  } catch (error2) {
+    throw error2 instanceof Error ? new Error(`Error saving ${STATE_FILE}: ${error2.message}`) : new Error(`Error saving ${STATE_FILE}`);
+  }
+}, update2 = async (updates) => {
+  let updated = { ...await load2(), ...updates };
+  return await save2(updated), updated;
+}, pluginStateManager = {
+  load: load2,
+  save: save2,
+  update: update2
+};
+
 // src/commands/info/index.ts
 init_logger();
 
@@ -1860,9 +1872,8 @@ var printHeader = (title) => {
   console.info(`  ${import_picocolors3.default.dim(label.padEnd(minWidth))} ${value}`);
 }, printPluginId = (pluginId) => {
   printField("Plugin ID", import_picocolors3.default.cyan(pluginId));
-}, printVersionId = (versionId) => {
-  printField("Version ID", import_picocolors3.default.cyan(versionId));
-}, printStatus = (status) => {
+};
+var printStatus = (status) => {
   printField("Status", getStatusBadge(status.toUpperCase()));
 }, printCreated = (createdAt) => {
   printField("Created", import_picocolors3.default.white(formatDate(createdAt)));
@@ -1881,23 +1892,9 @@ function showPluginVersions(versions2) {
     console.info(`  ${import_picocolors3.default.bold(String(index + 1) + ".")} ${import_picocolors3.default.cyan(version.versionId)}`), printField("Status", getStatusBadge(version.status.toUpperCase())), printField("Version", import_picocolors3.default.white(version.version)), printCreated(version.createdAt), logger_default.newLine();
   });
 }
-function showPluginList(plugins) {
-  if (!plugins || plugins.length === 0) {
-    console.info(import_picocolors3.default.dim("  No plugins found")), logger_default.newLine();
-    return;
-  }
-  printHeader(`\u{1F4CB} Your Plugins \xB7 ${plugins.length}`), logger_default.newLine(), plugins.forEach((plugin) => {
-    console.info(
-      `  ${import_picocolors3.default.magenta(plugin.slug)}  ${import_picocolors3.default.dim("\xB7")}  ${getStatusBadge(plugin.status.toUpperCase())}  ${import_picocolors3.default.dim("\xB7")}  ${import_picocolors3.default.cyan(plugin.id)}`
-    ), logger_default.newLine();
-  });
-}
 function showPluginCreated(data) {
   printSuccessHeader("\u2705 Plugin Created"), logger_default.newLine(), printPluginId(data.id);
 }
-function showPluginSubmitted(data) {
-  printSuccessHeader("\u{1F680} Plugin Submitted"), logger_default.newLine(), printPluginId(data.pluginId), printVersionId(data.versionId), printStatus(data.status);
-}
 function showTrackerPluginList(issues, mapStatus) {
   if (!issues || issues.length === 0) {
     console.info(import_picocolors3.default.dim("  No plugins found")), logger_default.newLine();
@@ -1959,12 +1956,13 @@ var mergeConfigs = (config, newConfig) => {
 
 // src/commands/install/index.ts
 async function install() {
-  let environment = await promptEnvironment2();
-  await s3Manager.setEnvironment(environment), await s3Manager.checkMdsAuth();
+  await s3Manager.checkMdsAuth();
+  let environment = await promptEnvironment();
+  s3Manager.setEnvironment(environment);
   let [config, manifest] = await Promise.all([
     s3Manager.getPluginsConfig(),
     manifestManager.load()
-  ]), settings = s3Manager.getSettings(), downloadBaseUrl = `${settings.awsEndpoint.replace(/\/+$/, "")}/${settings.staticBucket}`, pluginConfig = convertManifestToConfig(manifest, downloadBaseUrl), mergedConfig = mergeConfigs(config, pluginConfig);
+  ]), pluginConfig = convertManifestToConfig(manifest, environment), mergedConfig = mergeConfigs(config, pluginConfig);
   await s3Manager.savePluginsConfig(mergedConfig), logger_default.info("\u{1F389} Installation completed successfully!");
 }
 
@@ -2000,7 +1998,7 @@ async function apiRequest(endpoint, options = {}) {
     headers: requestHeaders
   };
   body && method !== "GET" && (requestOptions.body = JSON.stringify(body));
-  let url = `${await getTrackerApiUrl2()}${endpoint}`, response = await fetch(url, requestOptions);
+  let url = `${getTrackerBaseUrl2()}${endpoint}`, response = await fetch(url, requestOptions);
   if (!response.ok)
     throw new Error([response.status, response.statusText].join(" ").trim());
   let contentType = response.headers.get("content-type");
@@ -2020,13 +2018,13 @@ init_logger();
 
 // src/commands/login/utils/promptForCredentials.ts
 var import_prompts5 = require("@inquirer/prompts"), import_picocolors4 = __toESM(require("picocolors"));
-var OSC = "\x1B]", BEL = "\x07", promptForCredentials = async () => {
-  let tokenUrl = await getOAuthTokenUrl2();
-  return tokenUrl && (console.info(
-    import_picocolors4.default.dim("Get your OAuth token at: ") + import_picocolors4.default.cyan(`${OSC}8;;${tokenUrl}${BEL}${tokenUrl}${OSC}8;;${BEL}`)
-  ), console.info("")), {
+var ESC = "\x1B", BEL = "\x07", promptForCredentials = async () => {
+  let tokenUrl = getOAuthTokenUrl2();
+  return console.info(
+    import_picocolors4.default.dim("Get your OAuth token at: ") + import_picocolors4.default.cyan(`${ESC}]8;;${tokenUrl}${BEL}${tokenUrl}${ESC}]8;;${BEL}`)
+  ), console.info(""), {
     token: (await (0, import_prompts5.input)({
-      message: "Enter your OAuth token:",
+      message: "Enter your Yandex Tracker OAuth token:",
       required: !0
     })).trim()
   };
@@ -2058,66 +2056,10 @@ function logout() {
 }
 
 // src/commands/register/index.ts
-var import_crypto = require("crypto");
 init_logger();
-async function register() {
-  let manifest = await manifestManager.load(), state = await pluginStateManager.load();
-  if (state.trackerIssueKey)
-    try {
-      let issue2 = await getIssue(state.trackerIssueKey);
-      logger_default.error(
-        `Plugin is already registered. Tracker issue: ${issue2.key} (${issue2.summary})`
-      ), process.exit(1);
-    } catch {
-    }
-  let pluginId = manifest.id ?? (0, import_crypto.randomUUID)();
-  logger_default.info("\u23F3 Creating plugin issue in Tracker..."), manifest.id || await manifestManager.update({ id: pluginId });
-  let manifestJson = await manifestManager.loadRaw(), issue = await createPluginIssue({
-    pluginId,
-    slug: manifest.slug,
-    version: manifest.version,
-    manifestJson
-  });
-  await pluginStateManager.update({ trackerIssueKey: issue.key }), logger_default.success("Plugin registered!"), logger_default.info(`  Tracker issue : ${issue.key}`), logger_default.info(`  Summary       : ${issue.summary}`), logger_default.info(`  Plugin UUID   : ${pluginId}`), logger_default.commands("\u{1F4A1} Next steps", [
-    "tracker-cli catalog   # Update catalog metadata",
-    "tracker-cli upload    # Build and upload plugin bundle",
-    "tracker-cli submit    # Submit for review"
-  ]);
-}
 
 // src/commands/submit/index.ts
 init_logger();
-var SUBMIT_TRANSITION_DISPLAY = "waiting for approve";
-async function submit() {
-  let manifest = await manifestManager.load(), state = await pluginStateManager.load();
-  if (!state.trackerIssueKey) {
-    logger_default.warning('Plugin is not registered yet. Run "tracker-cli register" first.'), logger_default.suggest("tracker-cli register");
-    return;
-  }
-  let issueKey = state.trackerIssueKey;
-  logger_default.info(`\u23F3 Checking for uploaded bundle on ${issueKey}...`);
-  let attachments = await getIssueAttachments(issueKey), archiveName = `${manifest.slug}-${manifest.version}.zip`;
-  if (!attachments.some((a) => a.name === archiveName)) {
-    logger_default.warning(
-      `No bundle found for version ${manifest.version}. Upload it first with "tracker-cli upload".`
-    ), logger_default.suggest("tracker-cli upload");
-    return;
-  }
-  logger_default.info(`\u23F3 Fetching available transitions for ${issueKey}...`);
-  let transitions = await getIssueTransitions(issueKey), submitTransition = transitions.find(
-    (t) => t.display?.toLowerCase().includes(SUBMIT_TRANSITION_DISPLAY) || t.id?.toLowerCase().includes("waitingforapprove") || t.id?.toLowerCase().includes("waiting")
-  );
-  if (!submitTransition) {
-    let available = transitions.map((t) => `"${t.display ?? t.id}"`).join(", ");
-    logger_default.error(
-      `Could not find a "Waiting for approve" transition on ${issueKey}. Available: ${available}`
-    );
-    return;
-  }
-  logger_default.info(
-    `\u{1F680} Submitting plugin for review (transition: "${submitTransition.display ?? submitTransition.id}")...`
-  ), await executeIssueTransition(issueKey, submitTransition.id), await addIssueComment(issueKey, `Submitted version \`${manifest.version}\` for review.`), logger_default.success("Plugin submitted for review!"), logger_default.info(`  Tracker issue : ${issueKey}`), logger_default.info(`  Version       : ${manifest.version}`);
-}
 
 // src/commands/uninstall/index.ts
 init_logger();
@@ -2136,8 +2078,7 @@ var removePluginFromConfig = (config, pluginSlug) => {
 
 // src/commands/uninstall/index.ts
 async function uninstall() {
-  let environment = await promptEnvironment2();
-  await s3Manager.setEnvironment(environment), await s3Manager.checkMdsAuth();
+  await s3Manager.checkMdsAuth();
   let [config, manifest] = await Promise.all([
     s3Manager.getPluginsConfig(),
     manifestManager.load()
@@ -2159,26 +2100,32 @@ async function uninstall() {
 }
 
 // src/commands/up/utils/copyTemplateFiles.ts
-var import_fs10 = require("fs"), import_promises5 = require("fs/promises");
+var import_fs11 = require("fs"), import_promises4 = require("fs/promises");
 var copyTemplateFiles = async (filenames) => {
   await Promise.all(
     filenames.map(async (filename) => {
       let templatePath = getTemplatePath(filename), targetPath = `./${filename}`;
-      (0, import_fs10.existsSync)(templatePath) && (0, import_fs10.existsSync)(targetPath) && await (0, import_promises5.copyFile)(templatePath, targetPath);
+      (0, import_fs11.existsSync)(templatePath) && (0, import_fs11.existsSync)(targetPath) && await (0, import_promises4.copyFile)(templatePath, targetPath);
     })
   );
 };
 
+// src/commands/up/utils/updateManifestCompatibility.ts
+async function updateManifestCompatibility() {
+  let manifest = await manifestManager.load(), updates = {};
+  "manifest_version" in manifest || (updates.manifest_version = 1), "supported_services" in manifest || (updates.supported_services = ["tracker"]), Object.keys(updates).length > 0 && await manifestManager.update(updates);
+}
+
 // src/commands/up/utils/updatePackageDependencies.ts
-var import_fs11 = require("fs"), import_promises6 = require("fs/promises");
+var import_fs12 = require("fs"), import_promises5 = require("fs/promises");
 var updatePackageDependencies = async (dependencies) => {
   let packageJsonPath = "./package.json", templatePackageJsonPath = getTemplatePath("package.json");
-  if (!(0, import_fs11.existsSync)(packageJsonPath) || !(0, import_fs11.existsSync)(templatePackageJsonPath))
+  if (!(0, import_fs12.existsSync)(packageJsonPath) || !(0, import_fs12.existsSync)(templatePackageJsonPath))
     return;
-  let packageJsonContent = await (0, import_promises6.readFile)(packageJsonPath, "utf-8"), templatePackageJsonContent = await (0, import_promises6.readFile)(templatePackageJsonPath, "utf-8"), packageJson = JSON.parse(packageJsonContent), templatePackageJson = JSON.parse(templatePackageJsonContent), updated = !1;
+  let packageJsonContent = await (0, import_promises5.readFile)(packageJsonPath, "utf-8"), templatePackageJsonContent = await (0, import_promises5.readFile)(templatePackageJsonPath, "utf-8"), packageJson = JSON.parse(packageJsonContent), templatePackageJson = JSON.parse(templatePackageJsonContent), updated = !1;
   dependencies.forEach((dep) => {
     packageJson.dependencies?.[dep] && templatePackageJson.dependencies?.[dep] && packageJson.dependencies[dep] !== templatePackageJson.dependencies[dep] && (packageJson.dependencies[dep] = templatePackageJson.dependencies[dep], updated = !0);
-  }), updated && await (0, import_promises6.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
+  }), updated && await (0, import_promises5.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
 `, "utf-8");
 };
 
@@ -2188,40 +2135,72 @@ var templateFiles = ["manifest.schema.json", "vite.config.ts"], templateDeps = [
   "@yandex-data-ui/tracker-pub-api-types"
 ];
 async function up() {
-  await copyTemplateFiles(templateFiles), await updatePackageDependencies(templateDeps);
+  await copyTemplateFiles(templateFiles), await updateManifestCompatibility(), await updatePackageDependencies(templateDeps);
 }
 
 // src/utils/buildArchive.ts
-var import_path11 = __toESM(require("path")), import_archiver = __toESM(require("archiver"));
+var import_path12 = __toESM(require("path")), import_archiver = __toESM(require("archiver"));
 init_logger();
 
 // src/utils/marketplace.ts
-var import_fs12 = __toESM(require("fs")), import_path10 = __toESM(require("path"));
+var import_fs13 = __toESM(require("fs")), import_path11 = __toESM(require("path"));
 init_logger();
 var MARKETPLACE_DIR = "marketplace", MARKETPLACE_INDEX_FILE = "index.md", MARKETPLACE_HEADER_IMAGE_FILE = "header-image.jpg", PUBLIC_DIR = "public", PUBLIC_LOGO_FILE = "logo.svg", MANIFEST_FILE = "manifest.json", DIST_DIR = "dist", SRC_DIR = "src", ensurePathExists = (targetPath, errorMessage) => {
-  import_fs12.default.existsSync(targetPath) || (logger_default.error(errorMessage), process.exit(1));
+  import_fs13.default.existsSync(targetPath) || (logger_default.error(errorMessage), process.exit(1));
+}, ensureManifestCatalogFields = (manifest) => {
+  (!manifest.name?.ru || !manifest.name?.en) && (logger_default.error(
+    'Manifest field "name" is required for publishing. Add localized "name.ru" and "name.en" to ./manifest.json.'
+  ), process.exit(1)), (!manifest.description?.ru || !manifest.description?.en) && (logger_default.error(
+    'Manifest field "description" is required for publishing. Add localized "description.ru" and "description.en" to ./manifest.json.'
+  ), process.exit(1));
 };
 function validateMarketplaceAssets() {
-  let marketplaceDir = import_path10.default.resolve(MARKETPLACE_DIR);
+  let marketplaceDir = import_path11.default.resolve(MARKETPLACE_DIR);
   ensurePathExists(
     marketplaceDir,
     "Marketplace folder not found. Create ./marketplace and add index.md and header-image.jpg before publishing."
   ), ensurePathExists(
-    import_path10.default.join(marketplaceDir, MARKETPLACE_INDEX_FILE),
+    import_path11.default.join(marketplaceDir, MARKETPLACE_INDEX_FILE),
     "Marketplace description not found. Add ./marketplace/index.md before publishing."
   ), ensurePathExists(
-    import_path10.default.join(marketplaceDir, MARKETPLACE_HEADER_IMAGE_FILE),
+    import_path11.default.join(marketplaceDir, MARKETPLACE_HEADER_IMAGE_FILE),
     "Marketplace header image not found. Add ./marketplace/header-image.jpg before publishing."
   ), ensurePathExists(
-    import_path10.default.resolve(PUBLIC_DIR, PUBLIC_LOGO_FILE),
+    import_path11.default.resolve(PUBLIC_DIR, PUBLIC_LOGO_FILE),
     "Plugin logo not found. Add ./public/logo.svg before publishing."
   );
 }
 function validateArchiveSources() {
-  ensurePathExists(import_path10.default.resolve(DIST_DIR), "Dist folder not found. Build the project first."), ensurePathExists(
-    import_path10.default.resolve(SRC_DIR),
+  ensurePathExists(import_path11.default.resolve(DIST_DIR), "Dist folder not found. Build the project first."), ensurePathExists(
+    import_path11.default.resolve(SRC_DIR),
     "Source folder not found. Add ./src before publishing."
-  ), ensurePathExists(import_path10.default.resolve(MANIFEST_FILE), "manifest.json not found in plugin root."), validateMarketplaceAssets();
+  ), ensurePathExists(import_path11.default.resolve(MANIFEST_FILE), "manifest.json not found in plugin root."), validateMarketplaceAssets();
+}
+async function getMarketplaceCatalogEntry() {
+  let indexPath = import_path11.default.resolve(MARKETPLACE_DIR, MARKETPLACE_INDEX_FILE);
+  ensurePathExists(
+    indexPath,
+    "Marketplace description not found. Add ./marketplace/index.md before uploading."
+  );
+  let manifest = await manifestManager.load();
+  ensureManifestCatalogFields(manifest);
+  let longDescription = import_fs13.default.readFileSync(indexPath, "utf-8").trim();
+  return {
+    name: manifest.name.ru,
+    description: manifest.description.ru,
+    longDescription,
+    tags: manifest.keywords ?? []
+  };
+}
+function getMarketplaceHeaderImage() {
+  let imagePath = import_path11.default.resolve(MARKETPLACE_DIR, MARKETPLACE_HEADER_IMAGE_FILE);
+  return ensurePathExists(
+    imagePath,
+    "Marketplace header image not found. Add ./marketplace/header-image.jpg before uploading."
+  ), {
+    buffer: import_fs13.default.readFileSync(imagePath),
+    filename: MARKETPLACE_HEADER_IMAGE_FILE
+  };
 }
 var marketplacePaths = {
   distDir: DIST_DIR,
@@ -2231,41 +2210,55 @@ var marketplacePaths = {
 };
 
 // src/utils/buildArchive.ts
+init_verbose();
 async function buildArchive() {
-  return validateArchiveSources(), new Promise((resolve2, reject) => {
+  return validateArchiveSources(), (await manifestManager.load()).manifest_version === void 0 && (logger_default.error(
+    'manifest_version is missing in manifest.json. Run "tracker-cli up" or add "manifest_version": 1 manually before uploading.'
+  ), process.exit(1)), new Promise((resolve2, reject) => {
     let archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } }), chunks = [];
     archive.on("data", (chunk) => chunks.push(chunk)), archive.on("end", () => {
       let buffer = Buffer.concat(chunks);
-      logger_default.info(`\u{1F4E6} Archive created (${buffer.length} bytes)`), resolve2(buffer);
-    }), archive.on("error", reject), archive.file(import_path11.default.resolve(marketplacePaths.manifestFile), { name: "manifest.json" }), archive.directory(import_path11.default.resolve(marketplacePaths.distDir), "dist"), archive.directory(import_path11.default.resolve(marketplacePaths.srcDir), "src"), archive.directory(import_path11.default.resolve(marketplacePaths.marketplaceDir), "marketplace"), archive.finalize();
+      if (logger_default.info(`\u{1F4E6} Archive created (${buffer.length} bytes)`), isVerboseEnabled()) {
+        let debugPath = writeVerboseArtifact("archive/latest-upload.zip", buffer);
+        logger_default.info(`[platform-api-debug] Saved archive copy to ${debugPath}`);
+      }
+      resolve2(buffer);
+    }), archive.on("error", reject), archive.file(import_path12.default.resolve(marketplacePaths.manifestFile), { name: "manifest.json" }), archive.glob(
+      "**/*",
+      {
+        cwd: import_path12.default.resolve(marketplacePaths.distDir),
+        ignore: ["**/.DS_Store"]
+      },
+      { prefix: "dist/" }
+    ), archive.glob(
+      "**/*",
+      {
+        cwd: import_path12.default.resolve(marketplacePaths.srcDir),
+        ignore: ["**/.DS_Store"]
+      },
+      { prefix: "src/" }
+    ), archive.finalize();
   });
 }
 
 // src/commands/upload/index.ts
 init_logger();
-async function upload() {
-  let manifest = await manifestManager.load(), state = await pluginStateManager.load();
-  if (!state.trackerIssueKey) {
-    logger_default.warning('Plugin is not registered yet. Run "tracker-cli register" first.'), logger_default.suggest("tracker-cli register");
-    return;
-  }
-  logger_default.info("\u{1F528} Building plugin..."), await build(), logger_default.info("\u{1F4E6} Creating archive...");
-  let archiveBuffer = await buildArchive(), archiveName = `${manifest.slug}-${manifest.version}.zip`;
-  logger_default.info(`\u2B06\uFE0F  Attaching ${archiveName} to ${state.trackerIssueKey}...`), await attachFileToIssue(state.trackerIssueKey, archiveBuffer, archiveName), await addIssueComment(
-    state.trackerIssueKey,
-    `Updated bundle: \`${archiveName}\` (${archiveBuffer.length} bytes)`
-  ), logger_default.success(`Bundle updated on ${state.trackerIssueKey}: ${archiveName}`);
-}
 
 // src/api/platform.ts
 var import_form_data2 = __toESM(require("form-data"));
 
 // src/api/platformApiRequest.ts
 var import_node_fetch3 = __toESM(require("node-fetch"));
+init_logger();
+init_verbose();
+var PLATFORM_API_TIMEOUT_MS = Number(process.env.TRACKER_CLI_PLATFORM_TIMEOUT_MS || 3e4);
 function buildRequestHeaders(headers, formData) {
-  let authHeader = authManager.authHeader, requestHeaders = {
+  let authHeader = authManager.authHeader;
+  if (!authHeader)
+    throw new Error('Not authenticated. Run "tracker-cli login" first.');
+  let requestHeaders = {
     Accept: "*/*",
-    ...authHeader ? { Authorization: authHeader } : {},
+    Authorization: authHeader,
     ...headers
   };
   return formData || (requestHeaders["Content-Type"] = "application/json"), requestHeaders;
@@ -2300,25 +2293,52 @@ async function platformApiRequest(endpoint, options = {}) {
     method,
     headers: { ...requestHeaders, ...additionalHeaders },
     body: requestBody
-  }, queryString = buildQueryString2(queryParams), url = `${await getPlatformApiUrl2()}${endpoint}${queryString}`, response = await (0, import_node_fetch3.default)(url, requestOptions);
-  if (!response.ok) {
-    let errorText = await response.text(), errorMessage = errorText;
-    try {
-      let errorJson = JSON.parse(errorText);
-      errorJson.message && (errorMessage = errorJson.message);
-    } catch {
+  }, queryString = buildQueryString2(queryParams), url = `${getPlatformBaseUrl2()}${endpoint}${queryString}`, controller = new AbortController(), timeout = setTimeout(() => controller.abort(), PLATFORM_API_TIMEOUT_MS);
+  if (isVerboseEnabled() && (logger_default.info(
+    `[platform-api-debug] Request: method=${method} url=${url} hasBody=${!!body} hasFormData=${!!formData} timeoutMs=${PLATFORM_API_TIMEOUT_MS}`
+  ), body !== void 0 && logger_default.info(`[platform-api-debug] Request body: ${JSON.stringify(body)}`), formData)) {
+    let debugPath = writeVerboseArtifact(
+      "requests/latest-form-data.txt",
+      `method=${method}
+url=${url}
+headers=${JSON.stringify({ ...requestHeaders, ...additionalHeaders }, null, 2)}
+formData=present
+`
+    );
+    logger_default.info(`[platform-api-debug] Saved form-data request metadata to ${debugPath}`);
+  }
+  try {
+    let response = await (0, import_node_fetch3.default)(url, {
+      ...requestOptions,
+      signal: controller.signal
+    });
+    if (isVerboseEnabled() && logger_default.info(
+      `[platform-api-debug] Response: method=${method} url=${url} status=${response.status} contentType=${response.headers.get("content-type") ?? "n/a"}`
+    ), !response.ok) {
+      let errorText = await response.text(), errorMessage = errorText;
+      try {
+        let errorJson = JSON.parse(errorText);
+        errorJson.message && (errorMessage = errorJson.message);
+      } catch {
+      }
+      throw new Error(errorMessage);
     }
-    throw new Error(errorMessage);
+    return parseResponse2(response);
+  } catch (error2) {
+    throw error2 instanceof Error && error2.name === "AbortError" ? new Error(
+      `Platform API request timed out after ${PLATFORM_API_TIMEOUT_MS}ms: ${method} ${url}`
+    ) : error2;
+  } finally {
+    clearTimeout(timeout);
   }
-  return parseResponse2(response);
 }
 
 // src/api/platform.ts
-async function createPlugin(manifestContent) {
+async function createPlugin(archiveBuffer, archiveName) {
   let formData = new import_form_data2.default();
-  return formData.append("archive", manifestContent, {
-    filename: "manifest.json",
-    contentType: "application/json"
+  return formData.append("archive", archiveBuffer, {
+    filename: archiveName,
+    contentType: "application/zip"
   }), platformApiRequest("/api/v1/plugins", {
     method: "POST",
     formData
@@ -2340,6 +2360,16 @@ async function updateCatalogEntry(pluginId, catalogData) {
     body: catalogData
   });
 }
+async function updateCatalogImage(pluginId, imageBuffer, imageName) {
+  let formData = new import_form_data2.default();
+  return formData.append("image", imageBuffer, {
+    filename: imageName,
+    contentType: "image/jpeg"
+  }), platformApiRequest(`/api/v1/plugins/${pluginId}/catalog-image`, {
+    method: "PUT",
+    formData
+  });
+}
 async function submitPlugin(pluginId, version) {
   return platformApiRequest(`/api/v1/plugins/${pluginId}/submit`, {
     method: "POST",
@@ -2358,11 +2388,6 @@ async function getPluginVersions(pluginId) {
     method: "GET"
   });
 }
-async function getMyPlugins() {
-  return platformApiRequest("/api/v1/plugins/my", {
-    method: "GET"
-  });
-}
 async function checkSlugAvailability(slug) {
   return platformApiRequest(`/api/v1/slugs/${slug}/available`, {
     method: "GET"
@@ -2415,19 +2440,6 @@ async function whoami() {
   }
 }
 
-// src/commands/catalog/platform.ts
-init_logger();
-async function catalogPlatform() {
-  let manifest = await manifestManager.load(), pluginId = await promptPluginId(manifest);
-  logger_default.newLine(), logger_default.info("\u{1F4DD} Catalog entry information:");
-  let name = await promptPluginName(), description = await promptPluginDescription(), tags = await promptPluginTags();
-  logger_default.newLine(), logger_default.info("\u{1F4E4} Updating catalog entry..."), await updateCatalogEntry(pluginId, {
-    name,
-    description,
-    tags
-  }), logger_default.success("Catalog entry updated successfully!");
-}
-
 // src/commands/info/platform.ts
 init_logger();
 async function infoPlatform(pluginId) {
@@ -2441,36 +2453,6 @@ async function infoPlatform(pluginId) {
   }
 }
 
-// src/commands/list/platform.ts
-init_logger();
-async function listPlatform() {
-  logger_default.info("\u23F3 Fetching my plugins...");
-  try {
-    let plugins = await getMyPlugins();
-    showPluginList(plugins);
-  } catch (error2) {
-    throw logger_default.error("Failed to fetch plugins list"), error2;
-  }
-}
-
-// src/commands/register/platform.ts
-init_logger();
-async function registerPlatform() {
-  let manifest = await manifestManager.load();
-  if (manifest.id)
-    try {
-      let pluginInfo = await getPluginInfo(manifest.id);
-      logger_default.error(`Plugin is already registered with ID: ${pluginInfo.id}`), process.exit(1);
-    } catch {
-    }
-  await build(), logger_default.info("\u23F3 Creating plugin...");
-  let manifestContent = await manifestManager.loadRaw(), response = await createPlugin(manifestContent);
-  showPluginCreated(response), await manifestManager.update({ id: response.id }), logger_default.commands("\u{1F4A1} Next steps", [
-    "tracker-cli catalog # Update catalog data",
-    "tracker-cli submit  # Submit for review"
-  ]);
-}
-
 // src/commands/submit/platform.ts
 init_logger();
 
@@ -2502,44 +2484,115 @@ async function validateAndGetUniqueSlug(currentSlug) {
 }
 
 // src/commands/submit/platform.ts
+var SUBMIT_TRANSITION_DISPLAY = "waiting for approve";
 async function submitPlatform() {
-  let manifest = await manifestManager.load(), pluginId = manifest.id;
-  if (!pluginId) {
-    logger_default.warning("Please register the plugin first"), logger_default.suggest("tracker-cli register");
-    return;
+  let manifest = await manifestManager.load(), state = await pluginStateManager.load();
+  validateMarketplaceAssets(), await build(), logger_default.info("\u{1F4E6} Creating archive...");
+  let archiveBuffer = await buildArchive(), archiveName = `${manifest.slug}-${manifest.version}.zip`, pluginId = manifest.id;
+  if (pluginId)
+    logger_default.info("\u{1F4E4} Updating plugin archive..."), await updatePluginArchive(pluginId, archiveBuffer, archiveName);
+  else {
+    logger_default.info("\u23F3 Creating plugin...");
+    let createdPlugin = await createPlugin(archiveBuffer, archiveName);
+    showPluginCreated(createdPlugin), pluginId = createdPlugin.id, await manifestManager.update({ id: pluginId });
+  }
+  let manifestContent = await manifestManager.loadRaw(), issueKey = state.trackerIssueKey;
+  if (!issueKey) {
+    logger_default.info("\u23F3 Creating plugin issue in Tracker...");
+    let issue = await createPluginIssue({
+      pluginId,
+      slug: manifest.slug,
+      version: manifest.version,
+      manifestJson: manifestContent
+    });
+    await pluginStateManager.update({ trackerIssueKey: issue.key }), issueKey = issue.key;
   }
+  let catalogEntry = await getMarketplaceCatalogEntry();
+  logger_default.info("\u{1F4DD} Updating catalog entry from ./marketplace/index.md..."), await updateCatalogEntry(pluginId, catalogEntry);
+  let headerImage = getMarketplaceHeaderImage();
+  logger_default.info("\u{1F5BC}\uFE0F Uploading catalog image from ./marketplace/header-image.jpg..."), await updateCatalogImage(pluginId, headerImage.buffer, headerImage.filename);
   let validatedSlug = await validateAndGetUniqueSlug(manifest.slug);
-  validatedSlug !== manifest.slug && await manifestManager.update({ slug: validatedSlug });
-  let response = await submitPlugin(pluginId, manifest.version);
-  showPluginSubmitted(response), logger_default.newLine();
+  validatedSlug !== manifest.slug && await manifestManager.update({ slug: validatedSlug }), await submitPlugin(pluginId, manifest.version);
+  let transitions = await getIssueTransitions(issueKey), submitTransition = transitions.find(
+    (t) => t.display?.toLowerCase().includes(SUBMIT_TRANSITION_DISPLAY) || t.id?.toLowerCase().includes("waitingforapprove") || t.id?.toLowerCase().includes("waiting")
+  );
+  if (!submitTransition) {
+    let available = transitions.map((t) => `"${t.display ?? t.id}"`).join(", ");
+    logger_default.error(
+      `Could not find a "Waiting for approve" transition on ${issueKey}. Available: ${available}`
+    );
+    return;
+  }
+  logger_default.info("\u{1F680} Submitting for review..."), await executeIssueTransition(issueKey, submitTransition.id), await addIssueComment(issueKey, `Submitted version \`${manifest.version}\` for review.`), logger_default.success("Plugin submitted for review!"), logger_default.info(`  Tracker issue : ${issueKey}`), logger_default.info(`  Version       : ${manifest.version}`), logger_default.newLine();
 }
 
-// src/commands/upload/platform.ts
+// src/commands/submit/tracker.ts
+var import_crypto = require("crypto");
 init_logger();
-async function uploadPlatform() {
-  let manifest = await manifestManager.load(), pluginId = manifest.id;
-  if (!pluginId) {
-    logger_default.warning("Please register the plugin first"), logger_default.suggest("tracker-cli register");
-    return;
+var SUBMIT_TRANSITION_DISPLAY2 = "waiting for approve";
+async function submitTracker() {
+  let manifest = await manifestManager.load(), issueKey = (await pluginStateManager.load()).trackerIssueKey;
+  if (issueKey)
+    try {
+      await getIssue(issueKey);
+    } catch {
+      issueKey = void 0;
+    }
+  let pluginId = manifest.id ?? (0, import_crypto.randomUUID)();
+  manifest.id || await manifestManager.update({ id: pluginId });
+  let manifestJson = await manifestManager.loadRaw();
+  if (issueKey) {
+    logger_default.verbose(`\u23F3 Updating issue ${issueKey} with latest manifest...`);
+    let issueDescription = buildIssueDescription({
+      pluginId,
+      slug: manifest.slug,
+      version: manifest.version,
+      manifestJson
+    });
+    await updatePluginIssue(issueKey, { description: issueDescription });
+  } else {
+    logger_default.info("\u23F3 Creating plugin issue in Tracker...");
+    let issue = await createPluginIssue({
+      pluginId,
+      slug: manifest.slug,
+      version: manifest.version,
+      manifestJson
+    });
+    await pluginStateManager.update({ trackerIssueKey: issue.key }), issueKey = issue.key, logger_default.info(`  Tracker issue : ${issueKey}`);
   }
-  await build(), logger_default.info("\u{1F4E6} Creating archive...");
+  logger_default.info("\u{1F528} Building plugin..."), await build(), logger_default.info("\u{1F4E6} Creating archive...");
   let archiveBuffer = await buildArchive(), archiveName = `${manifest.slug}-${manifest.version}.zip`;
-  logger_default.info("\u{1F4E4} Updating plugin archive..."), await updatePluginArchive(pluginId, archiveBuffer, archiveName), logger_default.success("Plugin archive updated successfully!");
+  logger_default.verbose(`\u2B06\uFE0F  Attaching ${archiveName} to ${issueKey}...`), await attachFileToIssue(issueKey, archiveBuffer, archiveName), await addIssueComment(
+    issueKey,
+    `Updated bundle: \`${archiveName}\` (${archiveBuffer.length} bytes)`
+  ), logger_default.verbose(`\u23F3 Fetching available transitions for ${issueKey}...`);
+  let transitions = await getIssueTransitions(issueKey), submitTransition = transitions.find(
+    (t) => t.display?.toLowerCase().includes(SUBMIT_TRANSITION_DISPLAY2) || t.id?.toLowerCase().includes("waitingforapprove") || t.id?.toLowerCase().includes("waiting")
+  );
+  if (!submitTransition) {
+    let available = transitions.map((t) => `"${t.display ?? t.id}"`).join(", ");
+    logger_default.error(
+      `Could not find a "Waiting for approve" transition on ${issueKey}. Available: ${available}`
+    );
+    return;
+  }
+  logger_default.info("\u{1F680} Submitting plugin for review..."), await executeIssueTransition(issueKey, submitTransition.id), await addIssueComment(issueKey, `Submitted version \`${manifest.version}\` for review.`), logger_default.success("Plugin submitted for review!"), logger_default.info(`  Tracker issue : ${issueKey}`), logger_default.info(`  Version       : ${manifest.version}`), logger_default.newLine();
 }
 
 // src/utils/getVersion.ts
-var import_fs13 = require("fs"), import_path12 = require("path"), UNKNOWN_VERSION = "unknown", getVersionFromPackageJson = () => {
+var import_fs14 = require("fs"), import_path13 = require("path"), UNKNOWN_VERSION = "unknown", getVersionFromPackageJson = () => {
   try {
-    let packagePath = (0, import_path12.resolve)(__dirname, "../../package.json");
-    return (0, import_fs13.existsSync)(packagePath) && JSON.parse((0, import_fs13.readFileSync)(packagePath, "utf-8")).version || null;
+    let packagePath = (0, import_path13.resolve)(__dirname, "../../package.json");
+    return (0, import_fs14.existsSync)(packagePath) && JSON.parse((0, import_fs14.readFileSync)(packagePath, "utf-8")).version || null;
   } catch {
     return null;
   }
-}, getVersion = () => "0.1.0-dev";
+}, getVersion = () => "0.2.0-dev";
 
 // src/index.ts
 init_logger();
-function withErrorHandling2(fn) {
+init_verbose();
+function withErrorHandling(fn) {
   return async (...args) => {
     try {
       await fn(...args);
@@ -2550,19 +2603,21 @@ function withErrorHandling2(fn) {
 }
 async function main() {
   let program = new import_commander.Command(), version = getVersion();
-  await checkUpdate(version), program.name(CLI_NAME2).description(CLI_DESCRIPTION2).version(version), CLI_HELP_TEXT2 && program.addHelpText("before", CLI_HELP_TEXT2), program.command("feedback").description("Let us know what you think about Yandex Tracker plugins").action(() => {
+  await checkUpdate(version), program.name(CLI_NAME2).description(CLI_DESCRIPTION2).version(version), CLI_HELP_TEXT2 && program.addHelpText("before", CLI_HELP_TEXT2), program.hook("preAction", (thisCommand) => {
+    setVerboseEnabled(!!thisCommand.opts().verbose);
+  }), registerDistributionCommands2(program), program.command("feedback").description("Let us know what you think about Yandex Tracker plugins").action(() => {
     logger_default.info(
       `Help us make Yandex Tracker even better.
 To report bugs or issues, go to: https://forms.yandex.ru/surveys/6767/`
     );
-  }), program.command("create").description("create your app").action(withErrorHandling2(create)), program.command("up").description("update plugin from old template to latest version").action(withErrorHandling2(up)), program.command("build").description("build your app").action(withErrorHandling2(build)), program.command("debug").description(
+  }), program.command("create").description("create your app").action(withErrorHandling(create)), program.command("up").description("update plugin from old template to latest version").action(withErrorHandling(up)), program.command("build").description("build your app").action(withErrorHandling(build)), program.command("debug").description(
     "start a tunnel to connect your local code with the app running in the development environment"
-  ).option("--no-lint", "skip lint validation").action((options) => withErrorHandling2(debug)(options)), program.command("lint").description("run TypeScript and ESLint checks").action(withErrorHandling2(lint)), program.command("login").description("authenticate with Yandex Tracker").action(withErrorHandling2(login)), program.command("logout").description("remove authentication credentials").action(withErrorHandling2(logout)), program.command("whoami").description("display current authentication status").action(withErrorHandling2(async () => await whoami())), process.env.USE_BACKEND_TO_PUBLISH ? (program.command("register").description("register a new plugin and upload archive").action(withErrorHandling2(registerPlatform)), program.command("upload").description("upload plugin archive").action(withErrorHandling2(uploadPlatform)), program.command("update-catalog").description("update plugin catalog entry").action(withErrorHandling2(catalogPlatform)), program.command("submit").description("submit plugin for review").action(withErrorHandling2(submitPlatform)), program.command("list").description("list my plugins").action(withErrorHandling2(listPlatform)), program.command("info [plugin-id]").description(
+  ).option("--no-lint", "skip lint validation").action((options) => withErrorHandling(debug)(options)), program.command("lint").description("run TypeScript and ESLint checks").action(withErrorHandling(lint)), program.command("login").description("authenticate with Yandex Tracker").action(withErrorHandling(login)), program.command("logout").description("remove authentication credentials").action(withErrorHandling(logout)), program.command("whoami").description("display current authentication status").action(withErrorHandling(async () => await whoami())), process.env.USE_TRACKER_TO_PUBLISH ? (program.command("submit").description("build, attach archive to Tracker issue, and submit for review").action(withErrorHandling(submitTracker)), program.command("list").description("list my plugins").action(withErrorHandling(list)), program.command("info [issue-key]").description(
+    "get detailed information about a plugin (uses manifest.trackerIssueKey if issue-key not provided)"
+  ).action(withErrorHandling(info2))) : (program.command("submit").description("create plugin, upload data, and submit for review").action(withErrorHandling(submitPlatform)), program.command("list").description("list my plugins").action(withErrorHandling(list)), program.command("info [plugin-id]").description(
     "get detailed information about a plugin (uses manifest.id if plugin-id not provided)"
-  ).action(withErrorHandling2(infoPlatform)), program.command("versions [plugin-id]").description(
+  ).action(withErrorHandling(infoPlatform)), program.command("versions [plugin-id]").description(
     "list all versions of a plugin (uses manifest.id if plugin-id not provided)"
-  ).action(withErrorHandling2(versions))) : (program.command("register").description("register a new plugin and create a Tracker issue").action(withErrorHandling2(register)), program.command("upload").description("build and upload plugin bundle").action(withErrorHandling2(upload)), program.command("catalog").description("update plugin catalog metadata").action(withErrorHandling2(catalog)), program.command("submit").description("submit plugin for review").action(withErrorHandling2(submit)), program.command("list").description("list my plugins").action(withErrorHandling2(list)), program.command("info [issue-key]").description(
-    "get detailed information about a plugin (uses manifest.trackerIssueKey if issue-key not provided)"
-  ).action(withErrorHandling2(info2))), process.env.TRACKER_CLI_ADMIN && (program.command("deploy").description("build and upload plugin bundle to S3 for production").action(withErrorHandling2(deploy)), program.command("install").description("manage app installations").action(withErrorHandling2(install)), program.command("uninstall").description("uninstall app from all slots").action(withErrorHandling2(uninstall))), registerDistributionCommands2(program), await program.parseAsync(), process.exit(0);
+  ).action(withErrorHandling(versions))), process.env.TRACKER_CLI_ADMIN && (program.command("deploy").description("build and upload plugin bundle to S3 for production").action(withErrorHandling(deploy)), program.command("install").description("manage app installations").action(withErrorHandling(install)), program.command("uninstall").description("uninstall app from all slots").action(withErrorHandling(uninstall))), await program.parseAsync(), process.exit(0);
 }
 main();