@weavix/cli 0.1.0-dev

package/build/index.js

@@ -0,0 +1,2568 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+// src/distributions/external/meta.ts
+var meta_exports = {};
+__export(meta_exports, {
+  CLI_DESCRIPTION: () => CLI_DESCRIPTION,
+  CLI_HELP_TEXT: () => CLI_HELP_TEXT,
+  CLI_NAME: () => CLI_NAME
+});
+var CLI_NAME, CLI_DESCRIPTION, CLI_HELP_TEXT, init_meta = __esm({
+  "src/distributions/external/meta.ts"() {
+    "use strict";
+    CLI_NAME = "weavix", CLI_DESCRIPTION = "Weavix CLI", CLI_HELP_TEXT = "";
+  }
+});
+
+// src/utils/logger.ts
+function success(message) {
+  console.info(import_picocolors.default.green(`\u2705 ${message}`)), newLine();
+}
+function error(messageOrErr, err) {
+  let message = messageOrErr instanceof Error ? messageOrErr.message : messageOrErr;
+  console.error(import_picocolors.default.red(`\u274C ${message}`)), err instanceof Error && console.error(import_picocolors.default.red(err.message)), newLine();
+}
+function warning(message) {
+  console.warn(import_picocolors.default.yellow(`\u26A0\uFE0F  ${message}`)), newLine();
+}
+function info(message) {
+  console.info(message), newLine();
+}
+function suggest(command) {
+  console.info(`Run: ${command}`), newLine();
+}
+function newLine(count = 1) {
+  console.info(`
+`.repeat(count - 1));
+}
+function separator(char = "\u2500", length = 60) {
+  console.info(import_picocolors.default.dim(char.repeat(length))), newLine();
+}
+function commands(title, data) {
+  newLine(), console.info(import_picocolors.default.bold(import_picocolors.default.cyan(`${title}:`))), newLine(), data.forEach((cmd) => {
+    console.info(import_picocolors.default.dim("  $ ") + import_picocolors.default.white(cmd));
+  }), newLine();
+}
+var import_picocolors, logger, logger_default, init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    import_picocolors = __toESM(require("picocolors"));
+    logger = {
+      success,
+      error,
+      warning,
+      info,
+      suggest,
+      newLine,
+      separator,
+      commands
+    }, logger_default = logger;
+  }
+});
+
+// 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);
+}
+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 });
+}
+async function clearConfig() {
+  (0, import_fs.existsSync)(CONFIG_FILE) && await (0, import_promises.unlink)(CONFIG_FILE);
+}
+var import_fs, import_promises, os, import_path, CONFIG_DIR, CONFIG_FILE, CONFIG_FILE_PATH, init_configStore = __esm({
+  "src/distributions/external/configStore.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;
+  }
+});
+
+// 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}`);
+}
+async function configShow() {
+  let cfg = await readConfig();
+  if (!cfg) {
+    logger_default.info("No configuration. Run: tracker-cli config set");
+    return;
+  }
+  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 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));
+}
+var import_prompts, init_configCommand = __esm({
+  "src/distributions/external/configCommand.ts"() {
+    "use strict";
+    import_prompts = require("@inquirer/prompts");
+    init_logger();
+    init_configStore();
+  }
+});
+
+// src/distributions/external/registerCommands.ts
+var registerCommands_exports = {};
+__export(registerCommands_exports, {
+  registerDistributionCommands: () => registerDistributionCommands
+});
+function registerDistributionCommands(program) {
+  registerConfigCommand(program);
+}
+var init_registerCommands = __esm({
+  "src/distributions/external/registerCommands.ts"() {
+    "use strict";
+    init_configCommand();
+  }
+});
+
+// src/distributions/external/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  getNpmUpdateUrl: () => getNpmUpdateUrl,
+  getOAuthTokenUrl: () => getOAuthTokenUrl
+});
+async function getOAuthTokenUrl() {
+}
+async function getNpmUpdateUrl() {
+}
+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 "";
+}
+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
+  };
+}
+async function listEnvironments() {
+  return [];
+}
+var DEFAULT_ENVIRONMENT, init_storage = __esm({
+  "src/distributions/external/storage.ts"() {
+    "use strict";
+    init_configStore();
+    DEFAULT_ENVIRONMENT = "";
+  }
+});
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/distribution/meta.ts
+var impl = (init_meta(), __toCommonJS(meta_exports)), { CLI_NAME: CLI_NAME2, CLI_DESCRIPTION: CLI_DESCRIPTION2, CLI_HELP_TEXT: CLI_HELP_TEXT2 } = impl;
+
+// src/distribution/registerCommands.ts
+var impl2 = (init_registerCommands(), __toCommonJS(registerCommands_exports)), { registerDistributionCommands: registerDistributionCommands2 } = impl2;
+
+// 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/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 {
+  }
+};
+
+// src/utils/execCommand.ts
+var import_execa = require("execa"), execCommand = async (command, cwd = process.cwd()) => {
+  await (0, import_execa.execa)(command, {
+    cwd,
+    shell: !0,
+    stdio: "inherit"
+  });
+};
+
+// src/commands/build.ts
+init_logger();
+
+// src/commands/constants/templateCommands.ts
+var pluginCmd = {
+  install: "npm install",
+  build: "npm run build",
+  dev: "npm run dev",
+  lint: "npm run lint"
+};
+
+// src/commands/build.ts
+var build = async ({ environment = "production" } = {}) => {
+  logger_default.info("\u{1F528} Building project..."), await execCommand(pluginCmd.install), await execCommand(
+    environment ? `VITE_DEPLOY_ENV=${environment} ${pluginCmd.build}` : pluginCmd.build
+  );
+};
+
+// 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 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
+  };
+  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();
+  },
+  get data() {
+    return getData();
+  },
+  saveAuthData,
+  removeAuthData
+};
+
+// src/distribution/apiUrls.ts
+var impl4 = (init_apiUrls(), __toCommonJS(apiUrls_exports)), { getPlatformApiUrl: getPlatformApiUrl2, getTrackerApiUrl: getTrackerApiUrl2 } = impl4;
+
+// 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
+  });
+  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 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/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"));
+
+// src/core/manifest/formatValidationErrors.ts
+var priorityOrder = [
+  "required",
+  "type",
+  "minLength",
+  "format",
+  "pattern",
+  "enum",
+  "additionalProperties",
+  "uniqueItems"
+], errorMessages = {
+  required: (params) => `missing required property '${params.missingProperty}'`,
+  type: (params) => `must be ${params.type}`,
+  enum: (params) => `must be one of [${params.allowedValues.join(", ")}]`,
+  pattern: (params) => `must match pattern ${params.pattern}`,
+  format: (params) => `must be a valid ${params.format}`,
+  minLength: () => "must not be empty",
+  additionalProperties: (params) => `unexpected property '${params.additionalProperty}'`,
+  uniqueItems: () => "must contain unique items"
+}, getPriority = (keyword) => {
+  let index = priorityOrder.indexOf(keyword);
+  return index === -1 ? priorityOrder.length : index;
+}, formatValidationErrors = (errors) => {
+  let errorsByPath = {};
+  for (let error2 of errors) {
+    let path17 = error2.instancePath || "root";
+    errorsByPath[path17] || (errorsByPath[path17] = []), errorsByPath[path17].push(error2);
+  }
+  return Object.entries(errorsByPath).map(([path17, 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}`;
+  }).join(`
+`);
+};
+
+// src/core/manifest/manifest.schema.json
+var manifest_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Manifest",
+  description: "Schema for validating plugin manifest",
+  type: "object",
+  required: [
+    "slug",
+    "version",
+    "permissions"
+  ],
+  properties: {
+    $schema: {
+      type: "string"
+    },
+    id: {
+      type: "string",
+      description: "Unique identifier for the plugin ()",
+      minLength: 3,
+      maxLength: 63,
+      pattern: "^[a-z0-9-]+$"
+    },
+    slug: {
+      type: "string",
+      description: "Unique identifier for the plugin (lowercase letters, numbers, hyphen)",
+      minLength: 3,
+      maxLength: 63,
+      pattern: "^[a-z0-9-]+$"
+    },
+    version: {
+      type: "string",
+      description: "Version of the plugin (semver format required)",
+      minLength: 1,
+      pattern: "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$"
+    },
+    name: {
+      type: "object",
+      description: "Localized plugin name",
+      required: [
+        "ru",
+        "en"
+      ],
+      properties: {
+        ru: {
+          type: "string",
+          description: "Russian name",
+          minLength: 1,
+          maxLength: 30
+        },
+        en: {
+          type: "string",
+          description: "English name",
+          minLength: 1,
+          maxLength: 30
+        }
+      },
+      additionalProperties: !1
+    },
+    description: {
+      type: "object",
+      description: "Localized plugin description",
+      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
+    },
+    support: {
+      type: "array",
+      description: "Support contact information",
+      items: {
+        type: "object",
+        required: [
+          "type",
+          "value"
+        ],
+        properties: {
+          type: {
+            type: "string",
+            description: "Type of support contact",
+            enum: [
+              "email"
+            ]
+          },
+          value: {
+            type: "string",
+            description: "Contact value",
+            minLength: 1,
+            maxLength: 100
+          }
+        },
+        additionalProperties: !1
+      },
+      minItems: 1
+    },
+    homepage: {
+      type: "string",
+      description: "Homepage URL for the plugin (http or https)",
+      pattern: "^https?://",
+      maxLength: 1e3
+    },
+    license: {
+      type: "string",
+      description: "License identifier (e.g., MIT, Apache-2.0)",
+      minLength: 1,
+      maxLength: 32
+    },
+    keywords: {
+      type: "array",
+      description: "Keywords for plugin discovery",
+      items: {
+        type: "string",
+        minLength: 1,
+        maxLength: 30
+      },
+      uniqueItems: !0
+    },
+    whatsnew: {
+      type: "string",
+      description: "What's new in this version",
+      minLength: 1,
+      maxLength: 300
+    },
+    externalHost: {
+      type: "string",
+      description: "External host URL for the plugin (https only)",
+      format: "uri",
+      pattern: "^https://",
+      maxLength: 1e3
+    },
+    permissions: {
+      type: "object",
+      description: "Permissions required by the plugin",
+      required: [
+        "data"
+      ],
+      properties: {
+        data: {
+          type: "array",
+          description: "Data access permissions",
+          items: {
+            type: "string",
+            enum: [
+              "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",
+              "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"
+            ]
+          },
+          uniqueItems: !0
+        },
+        ui: {
+          type: "array",
+          description: "UI permissions",
+          items: {
+            type: "string"
+          },
+          uniqueItems: !0
+        },
+        device: {
+          type: "array",
+          description: "Device permissions",
+          items: {
+            type: "string",
+            enum: [
+              "clipboard-write"
+            ]
+          },
+          uniqueItems: !0
+        },
+        external: {
+          type: "array",
+          description: "External permissions",
+          items: {
+            type: "string"
+          },
+          uniqueItems: !0
+        }
+      },
+      additionalProperties: !1
+    },
+    slots: {
+      type: "object",
+      description: "Configuration for service slots",
+      minProperties: 1,
+      properties: {
+        tracker: {
+          type: "object",
+          description: "Tracker service slots",
+          minProperties: 1,
+          properties: {
+            "issue.action": {
+              type: "array",
+              description: "Issue Action slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            "issue.block": {
+              type: "array",
+              description: "Issue Block slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            "issue.tab": {
+              type: "array",
+              description: "Issue Tab slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            "issue.comment.action": {
+              type: "array",
+              description: "Issue Comment Action slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            navigation: {
+              type: "array",
+              description: "Navigation slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            "trigger.create.action": {
+              type: "array",
+              description: "Trigger Create Action slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            "trigger.edit.action": {
+              type: "array",
+              description: "Trigger Edit Action slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            "project.action": {
+              type: "array",
+              description: "Project Action slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            "portfolio.action": {
+              type: "array",
+              description: "Portfolio Action slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            "goal.action": {
+              type: "array",
+              description: "Goal Action slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            "issue.floatingbottom.action": {
+              type: "array",
+              description: "Issue Floatingbottom Action slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            },
+            "attachment.viewer.action": {
+              type: "array",
+              description: "Attachment Viewer Action slot configurations",
+              minItems: 1,
+              items: {
+                $ref: "#/definitions/SlotConfig"
+              }
+            }
+          },
+          additionalProperties: !1
+        }
+      },
+      additionalProperties: !1
+    }
+  },
+  additionalProperties: !1,
+  definitions: {
+    SlotConfig: {
+      type: "object",
+      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) + `
+`);
+  }
+};
+
+// 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_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 = {
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".txt": "text/plain",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".eot": "application/vnd.ms-fontobject"
+};
+
+// src/commands/debug/index.ts
+init_logger();
+
+// src/utils/registerCleanup.ts
+var registerCleanup = (cleanup) => {
+  process.on("SIGINT", () => {
+    cleanup(), process.exit(0);
+  }), process.on("SIGTERM", () => {
+    cleanup(), process.exit(0);
+  });
+};
+
+// src/commands/debug/utils/createDebugConfig.ts
+var import_fs4 = __toESM(require("fs")), import_path4 = __toESM(require("path"));
+
+// src/utils/convertManifestToConfig.ts
+function buildPluginDownloadUrl(baseUrl, id, version) {
+  return `${baseUrl.replace(/\/+$/, "")}/${id}/${version}`;
+}
+var convertManifestToConfig = (manifest, downloadBaseUrl) => {
+  let config = {};
+  if (!manifest.slots)
+    return config;
+  for (let service in manifest.slots) {
+    if (!Object.prototype.hasOwnProperty.call(manifest.slots, service))
+      continue;
+    let serviceSlots = manifest.slots[service];
+    if (serviceSlots)
+      for (let slotKey in serviceSlots) {
+        if (!Object.prototype.hasOwnProperty.call(serviceSlots, slotKey))
+          continue;
+        let slot = slotKey, slotConfigs = serviceSlots[slot];
+        if (!(!slotConfigs || !Array.isArray(slotConfigs))) {
+          config[slot] || (config[slot] = []);
+          for (let slotConfig of slotConfigs) {
+            let pluginConfig = {
+              slug: manifest.slug,
+              version: manifest.version,
+              permissions: manifest.permissions,
+              description: slotConfig.description,
+              entrypoint: slotConfig.entrypoint,
+              title: slotConfig.title,
+              downloadUrl: buildPluginDownloadUrl(
+                downloadBaseUrl,
+                manifest.slug,
+                manifest.version
+              )
+            };
+            config[slot].push(pluginConfig);
+          }
+        }
+      }
+  }
+  return config;
+};
+
+// 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);
+  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 = () => {
+  let lockPath = getLockFilePath();
+  if (!import_fs5.default.existsSync(lockPath))
+    return null;
+  try {
+    let pid = JSON.parse(import_fs5.default.readFileSync(lockPath, "utf-8")).pid;
+    return process.kill(pid, 0), pid;
+  } catch {
+    try {
+      import_fs5.default.unlinkSync(lockPath);
+    } catch {
+    }
+    return null;
+  }
+}, createLockFile = () => {
+  let lockPath = getLockFilePath(), lockData = {
+    pid: process.pid
+  }, fd = import_fs5.default.openSync(lockPath, "wx");
+  import_fs5.default.writeSync(fd, JSON.stringify(lockData, null, 2)), import_fs5.default.closeSync(fd);
+}, removeLockFile = () => {
+  let lockPath = getLockFilePath();
+  import_fs5.default.existsSync(lockPath) && import_fs5.default.unlinkSync(lockPath);
+};
+
+// src/commands/debug/utils/watchManifest.ts
+var import_fs6 = __toESM(require("fs")), import_path6 = __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) => {
+    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");
+      } catch (error2) {
+        logger_default.error(`Failed to regenerate debug config: ${error2.message}`);
+      }
+    }, 300));
+  }), originalClose = watcher.close.bind(watcher);
+  return watcher.close = () => {
+    debounceTimer && clearTimeout(debounceTimer), originalClose();
+  }, watcher;
+};
+
+// src/commands/debug/index.ts
+async function debug(options) {
+  let runningPid = getRunningDebugPid();
+  runningPid && (logger_default.error(
+    `Another instance of tracker-cli debug is already running.
+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);
+  options.lint && await manifestManager.validate(), await createDebugConfig();
+  let watcher = watchManifest(), cleanup = () => {
+    watcher.close(), import_fs7.default.existsSync(configPath) && import_fs7.default.unlinkSync(configPath), removeLockFile();
+  };
+  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/s3Manager.ts
+init_logger();
+
+// src/core/s3config/promptCredentials.ts
+var import_prompts4 = require("@inquirer/prompts"), promptS3Credentials = async () => {
+  let s3AccessKeyId = await (0, import_prompts4.input)({
+    message: "Enter S3_ACCESS_KEY_ID:",
+    required: !0
+  }), s3SecretAccessKey = await (0, import_prompts4.input)({
+    message: "Enter S3_SECRET_ACCESS_KEY:",
+    required: !0
+  });
+  return {
+    s3AccessKeyId: s3AccessKeyId?.trim(),
+    s3SecretAccessKey: s3SecretAccessKey?.trim()
+  };
+}, promptMdsCredentials = async () => {
+  let mdsAccessKeyId = await (0, import_prompts4.input)({
+    message: "Enter MDS_ACCESS_KEY_ID:",
+    required: !0
+  }), mdsSecretAccessKey = await (0, import_prompts4.input)({
+    message: "Enter MDS_SECRET_ACCESS_KEY:",
+    required: !0
+  });
+  return {
+    mdsAccessKeyId: mdsAccessKeyId?.trim(),
+    mdsSecretAccessKey: mdsSecretAccessKey?.trim()
+  };
+};
+
+// src/core/s3config/s3Manager.ts
+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;
+  }
+  getSettings() {
+    if (!this._settings)
+      throw new Error("Storage settings not loaded. Call s3Manager.setEnvironment() first.");
+    return this._settings;
+  }
+  async checkS3Auth() {
+    await this.checkAuth("s3");
+  }
+  async checkMdsAuth() {
+    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), {
+      mode: 384
+    });
+  }
+  get credentials() {
+    try {
+      if (!(0, import_fs8.existsSync)(this.credentialsFile))
+        return null;
+      let data = require("fs").readFileSync(this.credentialsFile, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async getPluginsConfig() {
+    let s3Client = this.createMdsS3Client(), bucket = this.getSettings().configBucket;
+    try {
+      let { Body } = 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);
+    } 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;
+    try {
+      await new import_lib_storage.Upload({
+        client: s3Client,
+        params: {
+          Bucket: bucket,
+          Key: CONFIG_FILE_NAME,
+          Body: Buffer.from(JSON.stringify(config), "utf8"),
+          ContentType: "application/json"
+        }
+      }).done();
+    } catch (error2) {
+      logger_default.error("Error writing plugins config to S3", error2), process.exit();
+    }
+  }
+  async uploadPluginFiles(manifest, files) {
+    if (files.length === 0) {
+      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;
+    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);
+        logger_default.info(`\u2B06\uFE0F  Uploading: ${relativePath}`), await new import_lib_storage.Upload({
+          client: s3Client,
+          params: {
+            Bucket: bucket,
+            Key: s3Key,
+            Body: fileContent,
+            ContentType: mimeType
+          }
+        }).done(), logger_default.success(`Uploaded: ${s3Key}`);
+      } catch (error2) {
+        logger_default.error(`Error uploading file ${filePath}`, error2), process.exit();
+      }
+    logger_default.success("Deployment completed successfully!");
+  }
+  /**
+   * Upload extra root-level files/directories to S3 under the same slug/version prefix.
+   * @param manifest  slug + version for the key prefix
+   * @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();
+    for (let rootPath of rootPaths) {
+      let absPath = import_path8.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);
+        logger_default.info(`\u2B06\uFE0F  Uploading: ${rootPath}`), await new import_lib_storage.Upload({
+          client: s3Client,
+          params: {
+            Bucket: bucket,
+            Key: s3Key,
+            Body: fileContent,
+            ContentType: mimeType
+          }
+        }).done(), logger_default.success(`Uploaded: ${s3Key}`);
+      } else {
+        let files = await (0, import_tinyglobby2.glob)(["**/*"], {
+          cwd: absPath,
+          onlyFiles: !0,
+          absolute: !0
+        });
+        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);
+            logger_default.info(`\u2B06\uFE0F  Uploading: ${relativePath}`), await new import_lib_storage.Upload({
+              client: s3Client,
+              params: {
+                Bucket: bucket,
+                Key: s3Key,
+                Body: fileContent,
+                ContentType: mimeType
+              }
+            }).done(), logger_default.success(`Uploaded: ${s3Key}`);
+          } catch (error2) {
+            logger_default.error(`Error uploading file ${filePath}`, error2), process.exit();
+          }
+      }
+    }
+  }
+  createAwsS3Client() {
+    let credentials = this.credentials, settings = this.getSettings();
+    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,
+      credentials: {
+        accessKeyId: credentials.s3AccessKeyId,
+        secretAccessKey: credentials.s3SecretAccessKey
+      }
+    });
+  }
+  async checkAuth(type) {
+    (type === "s3" ? await this.validateS3Credentials() : await this.validateMdsCredentials()) || (type === "s3" ? await this.promptS3CredentialsAndSave() : await this.promptMdsCredentialsAndSave());
+  }
+  async validateS3Credentials(credentials) {
+    let creds = credentials || this.credentials;
+    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,
+        credentials: {
+          accessKeyId: creds.s3AccessKeyId,
+          secretAccessKey: creds.s3SecretAccessKey
+        }
+      }).send(new import_client_s3.ListBucketsCommand({})), !0;
+    } catch (error2) {
+      return logger_default.error("AWS S3 credential validation failed:", error2), !1;
+    }
+  }
+  async validateMdsCredentials(credentials) {
+    let creds = credentials || this.credentials;
+    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;
+    } catch (error2) {
+      return logger_default.error("MDS credential validation failed:", error2), !1;
+    }
+  }
+  async promptS3CredentialsAndSave() {
+    await this.promptAndSaveCredentials(
+      "s3",
+      promptS3Credentials,
+      (creds) => this.validateS3Credentials(creds)
+    );
+  }
+  async promptMdsCredentialsAndSave() {
+    await this.promptAndSaveCredentials(
+      "mds",
+      promptMdsCredentials,
+      (creds) => this.validateMdsCredentials(creds)
+    );
+  }
+  async promptAndSaveCredentials(type, promptFn, validateFn) {
+    logger_default.info(`Please enter your ${type.toUpperCase()} credentials:`);
+    let newCreds = await promptFn(), updatedCreds = {
+      ...this.credentials || {},
+      ...newCreds
+    };
+    if (logger_default.info(`Validating ${type.toUpperCase()} credentials...`), !await validateFn(updatedCreds)) {
+      await this.promptAndSaveCredentials(type, promptFn, validateFn);
+      return;
+    }
+    await this.saveCredentials(updatedCreds), logger_default.success(`${type.toUpperCase()} credentials saved successfully.`);
+  }
+  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,
+      forcePathStyle: !0,
+      credentials: {
+        accessKeyId: credentials.mdsAccessKeyId,
+        secretAccessKey: credentials.mdsSecretAccessKey
+      }
+    });
+  }
+  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();
+    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
+  });
+  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
+init_logger();
+function mapTrackerStatusToPluginStatus(issue) {
+  let statusKey = issue.status.key, resolutionKey = issue.resolution?.key, resolutionDisplay = issue.resolution?.display;
+  switch (statusKey) {
+    case "open":
+      return "draft";
+    case "inProgress":
+      return "waiting_for_review";
+    case "need_info":
+      return "need_info";
+    case "waitingForApprove":
+      return "pending_approval";
+    case "closed":
+      switch (resolutionKey) {
+        case "agreed":
+          return "approved";
+        case "rejected":
+        case "declined":
+          return "rejected";
+        default:
+          return logger_default.warning(
+            `[tracker-status-debug] Unknown closed resolution for ${issue.key}: status.key=${statusKey}, status.display=${issue.status.display ?? "n/a"}, resolution.key=${resolutionKey ?? "n/a"}, resolution.display=${resolutionDisplay ?? "n/a"}`
+          ), "unknown";
+      }
+    default:
+      return logger_default.warning(
+        `[tracker-status-debug] Unknown tracker status for ${issue.key}: status.key=${statusKey}, status.display=${issue.status.display ?? "n/a"}, resolution.key=${resolutionKey ?? "n/a"}, resolution.display=${resolutionDisplay ?? "n/a"}`
+      ), "unknown";
+  }
+}
+
+// src/commands/info/index.ts
+init_logger();
+
+// src/utils/pluginDisplay.ts
+var import_picocolors3 = __toESM(require("picocolors"));
+init_logger();
+var printHeader = (title) => {
+  console.info(import_picocolors3.default.bold(import_picocolors3.default.white(title)));
+}, printSuccessHeader = (title) => {
+  console.info(import_picocolors3.default.bold(import_picocolors3.default.green(title)));
+}, getStatusBadge = (status) => {
+  let normalized = status.toLowerCase();
+  return normalized.includes("approved") ? import_picocolors3.default.black(import_picocolors3.default.bgGreen(` ${status} `)) : normalized.includes("pending") || normalized.includes("review") ? import_picocolors3.default.black(import_picocolors3.default.bgYellow(` ${status} `)) : normalized.includes("rejected") ? import_picocolors3.default.white(import_picocolors3.default.bgRed(` ${status} `)) : normalized.includes("draft") || normalized.includes("unknown") ? import_picocolors3.default.black(import_picocolors3.default.bgWhite(` ${status} `)) : import_picocolors3.default.black(import_picocolors3.default.bgBlue(` ${status} `));
+}, formatDate = (dateString) => dateString ? new Date(dateString).toLocaleString("ru-RU", {
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit"
+}) : "-", printField = (label, value, minWidth = 12) => {
+  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) => {
+  printField("Status", getStatusBadge(status.toUpperCase()));
+}, printCreated = (createdAt) => {
+  printField("Created", import_picocolors3.default.white(formatDate(createdAt)));
+}, printUpdated = (updatedAt) => {
+  printField("Updated", import_picocolors3.default.white(formatDate(updatedAt)));
+};
+function showPluginInfo(data) {
+  printHeader("\u{1F4E6} Plugin"), logger_default.newLine(), printPluginId(data.id), printField("Slug", import_picocolors3.default.magenta(data.slug)), printField("Name", import_picocolors3.default.white(data.name)), printStatus(data.status), data.createdAt && printCreated(data.createdAt), data.updatedAt && printUpdated(data.updatedAt);
+}
+function showPluginVersions(versions2) {
+  if (!versions2 || versions2.length === 0) {
+    console.info(import_picocolors3.default.dim("  No versions found")), logger_default.newLine();
+    return;
+  }
+  printHeader(`\u{1F9FE} Versions \xB7 ${versions2.length}`), logger_default.newLine(), versions2.forEach((version, index) => {
+    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();
+    return;
+  }
+  printHeader(`\u{1F4CB} Your Plugins \xB7 ${issues.length}`), logger_default.newLine(), issues.forEach((issue) => {
+    let slugMatch = issue.summary.match(/^Plugin:\s*(.+)$/), slug = slugMatch ? import_picocolors3.default.magenta(slugMatch[1].trim()) : import_picocolors3.default.dim(issue.summary), lifecycleStatus = mapStatus(issue), statusBadge = getStatusBadge(lifecycleStatus.toUpperCase());
+    console.info(
+      `  ${slug}  ${import_picocolors3.default.dim("\xB7")}  ${statusBadge}  ${import_picocolors3.default.dim("\xB7")}  ${import_picocolors3.default.dim(issue.key)}`
+    ), logger_default.newLine();
+  });
+}
+function showTrackerPluginInfo(issue, mapStatus) {
+  printHeader("\u{1F4E6} Plugin"), logger_default.newLine(), printField("Issue key", import_picocolors3.default.cyan(issue.key)), printField("Status", getStatusBadge(mapStatus(issue).toUpperCase())), printField("Summary", import_picocolors3.default.white(issue.summary)), issue.createdAt && printCreated(issue.createdAt), issue.updatedAt && printUpdated(issue.updatedAt);
+}
+
+// src/commands/info/index.ts
+async function info2(issueKey) {
+  let targetIssueKey = issueKey;
+  if (targetIssueKey || (targetIssueKey = (await pluginStateManager.load()).trackerIssueKey), !targetIssueKey) {
+    logger_default.warning(
+      'No issue key provided and plugin is not registered. Run "tracker-cli register" first.'
+    ), logger_default.suggest("tracker-cli register");
+    return;
+  }
+  logger_default.info(`\u23F3 Fetching plugin info for ${targetIssueKey}...`);
+  try {
+    let issue = await getIssue(targetIssueKey);
+    showTrackerPluginInfo(issue, mapTrackerStatusToPluginStatus);
+  } catch (error2) {
+    throw logger_default.error(`Failed to fetch plugin info for ${targetIssueKey}`), error2;
+  }
+}
+
+// src/commands/install/index.ts
+init_logger();
+
+// src/commands/install/utils/mergeConfigs.ts
+var mergeConfigs = (config, newConfig) => {
+  let result = { ...config };
+  for (let [key, newItems] of Object.entries(newConfig)) {
+    let slotKey = key;
+    if (!newItems || !Array.isArray(newItems))
+      continue;
+    let existingItems = result[slotKey];
+    if (!existingItems) {
+      result[slotKey] = [...newItems];
+      continue;
+    }
+    let mergedItems = [];
+    for (let existingItem of existingItems)
+      newItems.some(
+        (newItem) => newItem.slug === existingItem.slug
+      ) || mergedItems.push(existingItem);
+    mergedItems.push(...newItems), result[slotKey] = mergedItems;
+  }
+  return result;
+};
+
+// src/commands/install/index.ts
+async function install() {
+  let environment = await promptEnvironment2();
+  await s3Manager.setEnvironment(environment), await s3Manager.checkMdsAuth();
+  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);
+  await s3Manager.savePluginsConfig(mergedConfig), logger_default.info("\u{1F389} Installation completed successfully!");
+}
+
+// src/commands/lint.ts
+init_logger();
+async function lint() {
+  logger_default.info("\u{1F50D} Running manifest.json validation..."), await manifestManager.validate(), logger_default.info("\u{1F50D} Running code lint check..."), await execCommand(pluginCmd.lint);
+}
+
+// src/commands/list/index.ts
+init_logger();
+async function list() {
+  logger_default.info("\u23F3 Fetching my plugins from Tracker...");
+  try {
+    let issues = await getMyPluginIssues();
+    showTrackerPluginList(issues, mapTrackerStatusToPluginStatus);
+  } catch (error2) {
+    throw logger_default.error("Failed to fetch plugins list"), error2;
+  }
+}
+
+// src/api/apiRequest.ts
+async function apiRequest(endpoint, options = {}) {
+  let { method = "GET", body, headers = {}, token } = options, authHeader = token ? `OAuth ${token}` : authManager.authHeader;
+  if (!authHeader)
+    throw new Error('Not authenticated. Run "tracker-cli login" first.');
+  let requestHeaders = {
+    Authorization: authHeader,
+    "Content-Type": "application/json",
+    ...headers
+  }, requestOptions = {
+    method,
+    headers: requestHeaders
+  };
+  body && method !== "GET" && (requestOptions.body = JSON.stringify(body));
+  let url = `${await getTrackerApiUrl2()}${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");
+  return contentType && contentType.includes("application/json") ? await response.json() : await response.text();
+}
+
+// src/api/user.ts
+async function getMyself() {
+  return await apiRequest("/myself");
+}
+async function verifyToken(token) {
+  return await apiRequest("/myself", { token });
+}
+
+// src/commands/login/index.ts
+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("")), {
+    token: (await (0, import_prompts5.input)({
+      message: "Enter your OAuth token:",
+      required: !0
+    })).trim()
+  };
+};
+
+// src/commands/login/index.ts
+async function login() {
+  let authToken = (await promptForCredentials()).token;
+  try {
+    let userInfo = await verifyToken(authToken);
+    authManager.saveAuthData(authToken), logger_default.success(`Successfully logged in as ${userInfo.login}`);
+  } catch (error2) {
+    logger_default.error("Invalid token or API request failed", error2);
+  }
+}
+
+// src/commands/logout.ts
+init_logger();
+function logout() {
+  try {
+    if (!authManager.data) {
+      logger_default.warning("You are not logged in");
+      return;
+    }
+    authManager.removeAuthData(), logger_default.success("Successfully logged out");
+  } catch (error2) {
+    logger_default.error("Logout failed", error2);
+  }
+}
+
+// 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();
+
+// src/commands/uninstall/utils/removePluginFromConfig.ts
+var removePluginFromConfig = (config, pluginSlug) => {
+  let removedFromSlots = [], updatedConfig = {};
+  return Object.keys(config).forEach((slotName) => {
+    let slotPlugins = config[slotName];
+    if (!slotPlugins)
+      return;
+    let filteredPlugins = slotPlugins.filter((plugin) => plugin.slug !== pluginSlug);
+    filteredPlugins.length < slotPlugins.length && removedFromSlots.push(slotName), updatedConfig[slotName] = filteredPlugins;
+  }), { updatedConfig, removedFromSlots };
+};
+
+// src/commands/uninstall/index.ts
+async function uninstall() {
+  let environment = await promptEnvironment2();
+  await s3Manager.setEnvironment(environment), await s3Manager.checkMdsAuth();
+  let [config, manifest] = await Promise.all([
+    s3Manager.getPluginsConfig(),
+    manifestManager.load()
+  ]);
+  if (Object.keys(config).length === 0) {
+    logger_default.info("\u{1F50D} Config is empty. Nothing to uninstall.");
+    return;
+  }
+  let { updatedConfig, removedFromSlots } = removePluginFromConfig(config, manifest.slug);
+  if (removedFromSlots.length === 0) {
+    logger_default.info(
+      `\u{1F50D} Plugin ${manifest.slug} not found in config. It may have already been removed.`
+    );
+    return;
+  }
+  await s3Manager.savePluginsConfig(updatedConfig), logger_default.success(
+    `Plugin ${manifest.slug} successfully removed from slots: ${removedFromSlots.join(", ")}`
+  );
+}
+
+// src/commands/up/utils/copyTemplateFiles.ts
+var import_fs10 = require("fs"), import_promises5 = 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);
+    })
+  );
+};
+
+// src/commands/up/utils/updatePackageDependencies.ts
+var import_fs11 = require("fs"), import_promises6 = 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))
+    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;
+  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) + `
+`, "utf-8");
+};
+
+// src/commands/up/index.ts
+var templateFiles = ["manifest.schema.json", "vite.config.ts"], templateDeps = [
+  "@yandex-data-ui/tracker-plugin-sdk-react",
+  "@yandex-data-ui/tracker-pub-api-types"
+];
+async function up() {
+  await copyTemplateFiles(templateFiles), await updatePackageDependencies(templateDeps);
+}
+
+// src/utils/buildArchive.ts
+var import_path11 = __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"));
+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));
+};
+function validateMarketplaceAssets() {
+  let marketplaceDir = import_path10.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),
+    "Marketplace description not found. Add ./marketplace/index.md before publishing."
+  ), ensurePathExists(
+    import_path10.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),
+    "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),
+    "Source folder not found. Add ./src before publishing."
+  ), ensurePathExists(import_path10.default.resolve(MANIFEST_FILE), "manifest.json not found in plugin root."), validateMarketplaceAssets();
+}
+var marketplacePaths = {
+  distDir: DIST_DIR,
+  srcDir: SRC_DIR,
+  marketplaceDir: MARKETPLACE_DIR,
+  manifestFile: MANIFEST_FILE
+};
+
+// src/utils/buildArchive.ts
+async function buildArchive() {
+  return validateArchiveSources(), 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();
+  });
+}
+
+// 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"));
+function buildRequestHeaders(headers, formData) {
+  let authHeader = authManager.authHeader, requestHeaders = {
+    Accept: "*/*",
+    ...authHeader ? { Authorization: authHeader } : {},
+    ...headers
+  };
+  return formData || (requestHeaders["Content-Type"] = "application/json"), requestHeaders;
+}
+function buildRequestBody(method, body, formData) {
+  if (formData) {
+    let formHeaders = formData.getHeaders?.();
+    return {
+      body: formData,
+      headers: formHeaders || {}
+    };
+  }
+  return body && method !== "GET" ? { body: JSON.stringify(body) } : {};
+}
+function buildQueryString2(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 parseResponse2(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 platformApiRequest(endpoint, options = {}) {
+  let { method = "GET", body, headers = {}, formData, queryParams } = options, requestHeaders = buildRequestHeaders(headers, formData), { body: requestBody, headers: additionalHeaders } = buildRequestBody(
+    method,
+    body,
+    formData
+  ), requestOptions = {
+    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 {
+    }
+    throw new Error(errorMessage);
+  }
+  return parseResponse2(response);
+}
+
+// src/api/platform.ts
+async function createPlugin(manifestContent) {
+  let formData = new import_form_data2.default();
+  return formData.append("archive", manifestContent, {
+    filename: "manifest.json",
+    contentType: "application/json"
+  }), platformApiRequest("/api/v1/plugins", {
+    method: "POST",
+    formData
+  });
+}
+async function updatePluginArchive(pluginId, archiveBuffer, archiveName) {
+  let formData = new import_form_data2.default();
+  return formData.append("archive", archiveBuffer, {
+    filename: archiveName,
+    contentType: "application/zip"
+  }), platformApiRequest(`/api/v1/plugins/${pluginId}/archive`, {
+    method: "PUT",
+    formData
+  });
+}
+async function updateCatalogEntry(pluginId, catalogData) {
+  return platformApiRequest(`/api/v1/plugins/${pluginId}/catalog-entry`, {
+    method: "PUT",
+    body: catalogData
+  });
+}
+async function submitPlugin(pluginId, version) {
+  return platformApiRequest(`/api/v1/plugins/${pluginId}/submit`, {
+    method: "POST",
+    queryParams: {
+      version
+    }
+  });
+}
+async function getPluginInfo(pluginId) {
+  return platformApiRequest(`/api/v1/plugins/${pluginId}`, {
+    method: "GET"
+  });
+}
+async function getPluginVersions(pluginId) {
+  return platformApiRequest(`/api/v1/plugins/${pluginId}/versions`, {
+    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"
+  });
+}
+
+// src/utils/getPluginId.ts
+async function getPluginId(pluginId) {
+  if (pluginId)
+    return pluginId;
+  try {
+    let manifest = await manifestManager.load();
+    if (!manifest.id)
+      throw new Error("Plugin ID not found in manifest.json");
+    return manifest.id;
+  } catch {
+    throw new Error("Plugin ID must be provided as argument or present in manifest.json");
+  }
+}
+
+// src/commands/versions/index.ts
+init_logger();
+async function versions(pluginId) {
+  let actualPluginId = await getPluginId(pluginId);
+  logger_default.info(`\u23F3 Fetching versions for plugin ID: ${actualPluginId}...`);
+  try {
+    let pluginVersions = await getPluginVersions(actualPluginId);
+    if (!pluginVersions || pluginVersions.length === 0) {
+      logger_default.info("No versions found for this plugin.");
+      return;
+    }
+    showPluginVersions(pluginVersions), logger_default.newLine();
+  } catch (error2) {
+    throw logger_default.error(`Failed to fetch versions for plugin ID: ${actualPluginId}`), error2;
+  }
+}
+
+// src/commands/whoami.ts
+init_logger();
+async function whoami() {
+  if (!authManager.data) {
+    logger_default.warning("You are not logged in"), logger_default.suggest("tracker-cli login");
+    return;
+  }
+  try {
+    let userInfo = await getMyself();
+    logger_default.info(`Current user: ${userInfo.login}`);
+  } catch {
+    logger_default.warning("Failed to verify token with API");
+  }
+}
+
+// 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) {
+  let actualPluginId = await getPluginId(pluginId);
+  logger_default.info(`\u23F3 Fetching plugin info for ID: ${actualPluginId}...`);
+  try {
+    let pluginInfo = await getPluginInfo(actualPluginId);
+    showPluginInfo(pluginInfo), pluginInfo.versions && pluginInfo.versions.length > 0 && (logger_default.newLine(), showPluginVersions(pluginInfo.versions));
+  } catch (error2) {
+    throw logger_default.error(`Failed to fetch plugin info for ID: ${actualPluginId}`), error2;
+  }
+}
+
+// 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();
+
+// src/commands/submit/utils/validateSlug.ts
+var readline = __toESM(require("readline"));
+init_logger();
+function promptForSlug() {
+  return new Promise((resolve2) => {
+    let rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question("Enter a new slug: ", (answer) => {
+      rl.close(), resolve2(answer.trim());
+    });
+  });
+}
+async function validateAndGetUniqueSlug(currentSlug) {
+  let slugToCheck = currentSlug, isValid = !1;
+  for (; !isValid; )
+    try {
+      if ((await checkSlugAvailability(slugToCheck)).available)
+        return isValid = !0, slugToCheck;
+      logger_default.error(`\u274C Slug "${slugToCheck}" is already taken.`), logger_default.info("Please enter a different slug."), slugToCheck = await promptForSlug(), slugToCheck || (logger_default.error("Slug cannot be empty. Please try again."), slugToCheck = currentSlug);
+    } catch (error2) {
+      throw logger_default.error(`Failed to check slug availability: ${error2.message}`), error2;
+    }
+  return slugToCheck;
+}
+
+// src/commands/submit/platform.ts
+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 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();
+}
+
+// src/commands/upload/platform.ts
+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;
+  }
+  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!");
+}
+
+// src/utils/getVersion.ts
+var import_fs13 = require("fs"), import_path12 = 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;
+  } catch {
+    return null;
+  }
+}, getVersion = () => "0.1.0-dev";
+
+// src/index.ts
+init_logger();
+function withErrorHandling2(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 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(() => {
+    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(
+    "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(
+    "get detailed information about a plugin (uses manifest.id if plugin-id not provided)"
+  ).action(withErrorHandling2(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);
+}
+main();