@weavix/cli 0.1.0-dev → 0.3.0

package/build/index.js

@@ -40,6 +40,20 @@ var CLI_NAME, CLI_DESCRIPTION, CLI_HELP_TEXT, init_meta = __esm({
   }
 });
 
+// src/utils/verbose.ts
+function setVerboseEnabled(value) {
+  verboseEnabled = value;
+}
+function isVerboseEnabled() {
+  return verboseEnabled;
+}
+var verboseEnabled, init_verbose = __esm({
+  "src/utils/verbose.ts"() {
+    "use strict";
+    verboseEnabled = !1;
+  }
+});
+
 // src/utils/logger.ts
 function success(message) {
   console.info(import_picocolors.default.green(`\u2705 ${message}`)), newLine();
@@ -54,6 +68,9 @@ function warning(message) {
 function info(message) {
   console.info(message), newLine();
 }
+function verbose(message) {
+  isVerboseEnabled() && (console.info(import_picocolors.default.dim(message)), newLine());
+}
 function suggest(command) {
   console.info(`Run: ${command}`), newLine();
 }
@@ -73,11 +90,13 @@ var import_picocolors, logger, logger_default, init_logger = __esm({
   "src/utils/logger.ts"() {
     "use strict";
     import_picocolors = __toESM(require("picocolors"));
+    init_verbose();
     logger = {
       success,
       error,
       warning,
       info,
+      verbose,
       suggest,
       newLine,
       separator,
@@ -86,102 +105,95 @@ var import_picocolors, logger, logger_default, init_logger = __esm({
   }
 });
 
-// src/distributions/external/configStore.ts
-async function readConfig() {
+// src/core/cliConfig/manager.ts
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function readConfig() {
+  if (cached !== void 0)
+    return cached;
   if (!(0, import_fs.existsSync)(CONFIG_FILE))
-    return null;
-  let raw = await (0, import_promises.readFile)(CONFIG_FILE, "utf-8");
-  return JSON.parse(raw);
+    return cached = null, cached;
+  try {
+    cached = JSON.parse((0, import_fs.readFileSync)(CONFIG_FILE, "utf-8"));
+  } catch {
+    cached = null;
+  }
+  return cached;
 }
-async function writeConfig(config) {
-  (0, import_fs.existsSync)(CONFIG_DIR) || (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: !0, mode: 448 }), await (0, import_promises.writeFile)(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 });
+function writeConfig(config) {
+  (0, import_fs.existsSync)(CONFIG_DIR) || (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: !0, mode: 448 }), (0, import_fs.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 }), cached = config;
 }
-async function clearConfig() {
-  (0, import_fs.existsSync)(CONFIG_FILE) && await (0, import_promises.unlink)(CONFIG_FILE);
+function clearConfig() {
+  (0, import_fs.existsSync)(CONFIG_FILE) && (0, import_fs.rmSync)(CONFIG_FILE), cached = null;
 }
-var import_fs, import_promises, os, import_path, CONFIG_DIR, CONFIG_FILE, CONFIG_FILE_PATH, init_configStore = __esm({
-  "src/distributions/external/configStore.ts"() {
+var import_fs, os, import_path, CONFIG_DIR, CONFIG_FILE, cached, init_manager = __esm({
+  "src/core/cliConfig/manager.ts"() {
     "use strict";
-    import_fs = require("fs"), import_promises = require("fs/promises"), os = __toESM(require("os")), import_path = __toESM(require("path")), CONFIG_DIR = import_path.default.join(os.homedir(), ".tracker-cli"), CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json"), CONFIG_FILE_PATH = CONFIG_FILE;
+    import_fs = require("fs"), 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");
   }
 });
 
-// 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);
-    }
-  };
+// src/core/cliConfig/registerCommand.ts
+async function promptString(message, current) {
+  return (await (0, import_prompts.input)({
+    message: current ? `${message} (current: ${current})` : `${message} (optional)`,
+    default: current,
+    required: !1
+  }))?.trim() || void 0;
 }
-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 runConfigSet(cliName) {
+  let existing = readConfig() ?? {};
+  logger_default.info(
+    "Configure CLI overrides. Empty input clears the value (and falls back to defaults where applicable)."
+  );
+  let s3Endpoint = await promptString("S3 endpoint", existing.s3?.endpoint), s3Region = await promptString("S3 region", existing.s3?.region), mdsEndpoint = await promptString("MDS endpoint", existing.mds?.endpoint), productionStatic = await promptString(
+    "Production bucket (static)",
+    existing.buckets?.production?.static
+  ), productionConfig = await promptString(
+    "Production bucket (config)",
+    existing.buckets?.production?.config
+  ), pluginDownloadProduction = await promptString(
+    "Plugin download base URL",
+    existing.pluginDownloadBase?.production
+  ), platformBaseUrl = await promptString(
+    "Platform API base URL",
+    existing.api?.platformBaseUrl
+  ), oauthUrl = await promptString("OAuth token URL", existing.auth?.oauthUrl);
+  writeConfig({
+    s3: { endpoint: s3Endpoint, region: s3Region },
+    mds: { endpoint: mdsEndpoint },
+    buckets: {
+      production: { static: productionStatic, config: productionConfig }
+    },
+    pluginDownloadBase: { production: pluginDownloadProduction },
+    api: { platformBaseUrl },
+    auth: { oauthUrl }
+  }), logger_default.success(`Configuration saved \u2192 ${getConfigPath()}`), logger_default.info(`Inspect with "${cliName} config show" or revert with "${cliName} config clear".`);
 }
-async function configShow() {
-  let cfg = await readConfig();
+function runConfigShow(cliName) {
+  let cfg = readConfig();
   if (!cfg) {
-    logger_default.info("No configuration. Run: tracker-cli config set");
+    logger_default.info(
+      `No configuration found at ${getConfigPath()}. Run "${cliName} config set" to create one.`
+    );
     return;
   }
-  logger_default.info(JSON.stringify(cfg, null, 2));
+  logger_default.info(`Configuration at ${getConfigPath()}:`), logger_default.info(JSON.stringify(cfg, null, 2));
 }
-async function configClear() {
-  if (!await readConfig()) {
-    logger_default.info("No configuration to clear.");
-    return;
-  }
-  if (!await (0, import_prompts.confirm)({
-    message: `Remove configuration at ${CONFIG_FILE_PATH}?`,
-    default: !1
-  })) {
-    logger_default.info("Cancelled.");
-    return;
-  }
-  await clearConfig(), logger_default.success("Configuration removed.");
+function runConfigClear() {
+  clearConfig(), logger_default.success(`Configuration removed (${getConfigPath()})`);
 }
-function registerConfigCommand(program) {
-  let config = program.command("config").description("manage CLI configuration (S3 endpoints, buckets, API URLs)");
-  config.command("set").description("set configuration interactively").action(withErrorHandling(configSet)), config.command("show").description("show current configuration").action(withErrorHandling(configShow)), config.command("clear").description("remove configuration").action(withErrorHandling(configClear));
+function registerConfigCommand(program, cliName) {
+  let config = program.command("config").description("manage CLI configuration");
+  config.command("set").description("set CLI configuration values interactively").action(() => runConfigSet(cliName)), config.command("show").description("display current CLI configuration").action(() => runConfigShow(cliName)), config.command("clear").description("remove stored CLI configuration").action(runConfigClear);
 }
-var import_prompts, init_configCommand = __esm({
-  "src/distributions/external/configCommand.ts"() {
+var import_prompts, init_registerCommand = __esm({
+  "src/core/cliConfig/registerCommand.ts"() {
     "use strict";
     import_prompts = require("@inquirer/prompts");
     init_logger();
-    init_configStore();
+    init_manager();
   }
 });
 
@@ -191,97 +203,170 @@ __export(registerCommands_exports, {
   registerDistributionCommands: () => registerDistributionCommands
 });
 function registerDistributionCommands(program) {
-  registerConfigCommand(program);
+  registerConfigCommand(program, CLI_NAME);
 }
 var init_registerCommands = __esm({
   "src/distributions/external/registerCommands.ts"() {
     "use strict";
-    init_configCommand();
+    init_registerCommand();
+    init_meta();
   }
 });
 
-// src/distributions/external/auth.ts
-var auth_exports = {};
-__export(auth_exports, {
-  getNpmUpdateUrl: () => getNpmUpdateUrl,
-  getOAuthTokenUrl: () => getOAuthTokenUrl
+// src/distributions/external/hosts.ts
+var hosts_exports = {};
+__export(hosts_exports, {
+  getBuckets: () => getBuckets,
+  getMdsEndpoint: () => getMdsEndpoint,
+  getOAuthTokenUrl: () => getOAuthTokenUrl,
+  getPlatformBaseUrl: () => getPlatformBaseUrl,
+  getPluginDownloadBase: () => getPluginDownloadBase,
+  getS3Endpoint: () => getS3Endpoint,
+  getS3Region: () => getS3Region,
+  getTrackerBaseUrl: () => getTrackerBaseUrl,
+  getUpdateCheckInfo: () => getUpdateCheckInfo
 });
-async function getOAuthTokenUrl() {
+function requireConfig() {
+  let cfg = readConfig();
+  if (!cfg)
+    throw new Error('CLI is not configured. Run "weavix config set" to configure.');
+  return cfg;
+}
+function getS3Endpoint() {
+  let cfg = requireConfig();
+  if (!cfg.s3?.endpoint)
+    throw new Error('S3 endpoint is not configured. Run "weavix config set" to configure.');
+  return cfg.s3.endpoint;
+}
+function getMdsEndpoint() {
+  let cfg = requireConfig();
+  if (!cfg.mds?.endpoint)
+    throw new Error('MDS endpoint is not configured. Run "weavix config set" to configure.');
+  return cfg.mds.endpoint;
+}
+function getS3Region() {
+  let cfg = requireConfig();
+  if (!cfg.s3?.region)
+    throw new Error('S3 region is not configured. Run "weavix config set" to configure.');
+  return cfg.s3.region;
+}
+function getBuckets() {
+  let production = requireConfig().buckets?.production;
+  if (!production?.static || !production?.config)
+    throw new Error('S3 buckets are not configured. Run "weavix config set" to configure.');
+  let prod = { static: production.static, config: production.config };
+  return { testing: prod, production: prod };
+}
+function getPluginDownloadBase(env) {
+  if (env === "debug")
+    return "http://localhost:5173/plugins-debug";
+  let base = requireConfig().pluginDownloadBase?.production;
+  if (!base)
+    throw new Error(
+      'Plugin download base is not configured. Run "weavix config set" to configure.'
+    );
+  return base;
 }
-async function getNpmUpdateUrl() {
+function getPlatformBaseUrl() {
+  let cfg = requireConfig();
+  if (!cfg.api?.platformBaseUrl)
+    throw new Error(
+      'Platform API URL is not configured. Run "weavix config set" to configure.'
+    );
+  return cfg.api.platformBaseUrl;
 }
-var init_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;
+function getTrackerBaseUrl() {
+  return TRACKER_BASE_URL;
 }
-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;
+function getOAuthTokenUrl() {
+  let cfg = requireConfig();
+  if (!cfg.auth?.oauthUrl)
+    throw new Error('OAuth URL is not configured. Run "weavix config set" to configure.');
+  return cfg.auth.oauthUrl;
 }
-var init_apiUrls = __esm({
-  "src/distributions/external/apiUrls.ts"() {
+function getUpdateCheckInfo() {
+  return null;
+}
+var TRACKER_BASE_URL, init_hosts = __esm({
+  "src/distributions/external/hosts.ts"() {
     "use strict";
-    init_configStore();
+    init_manager();
+    TRACKER_BASE_URL = "https://tracker.yandex.ru";
   }
 });
 
-// src/distributions/external/promptEnvironment.ts
-var promptEnvironment_exports = {};
-__export(promptEnvironment_exports, {
-  promptEnvironment: () => promptEnvironment
+// src/distributions/external/templateSubstitution.ts
+var templateSubstitution_exports = {};
+__export(templateSubstitution_exports, {
+  applySubstitutions: () => applySubstitutions,
+  templateDeps: () => templateDeps
 });
-async function promptEnvironment() {
-  return "";
+function rewritePackageJson(content) {
+  let pkg = JSON.parse(content);
+  if (pkg.dependencies) {
+    let next = {};
+    for (let [name, version] of Object.entries(pkg.dependencies)) {
+      if (PACKAGE_DROP.has(name))
+        continue;
+      let renamed = PACKAGE_RENAME[name] ?? name;
+      next[renamed] = ADDED_DEPS[renamed] ?? version;
+    }
+    for (let [name, version] of Object.entries(ADDED_DEPS))
+      name in next || (next[name] = version);
+    pkg.dependencies = Object.fromEntries(
+      Object.entries(next).sort(([a], [b]) => a.localeCompare(b))
+    );
+  }
+  return JSON.stringify(pkg, null, 4) + `
+`;
 }
-var init_promptEnvironment = __esm({
-  "src/distributions/external/promptEnvironment.ts"() {
-    "use strict";
+function rewriteImports(content) {
+  let result = content;
+  for (let [from, to] of Object.entries(PACKAGE_RENAME)) {
+    let escaped = from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    result = result.replace(new RegExp(escaped, "g"), to);
   }
-});
-
-// 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
-  };
+  return result;
 }
-async function listEnvironments() {
-  return [];
+function rewriteScss(content) {
+  return content.split(`
+`).filter((line) => {
+    let trimmed = line.trim();
+    return trimmed.startsWith("@import") ? ![...PACKAGE_DROP].some((pkg) => trimmed.includes(pkg)) : !0;
+  }).join(`
+`);
+}
+function rewriteNpmrc(content) {
+  return content.split(`
+`).filter((line) => !/^registry\s*=\s*https?:\/\/npm\.yandex-team\.ru/.test(line.trim())).join(`
+`);
 }
-var DEFAULT_ENVIRONMENT, init_storage = __esm({
-  "src/distributions/external/storage.ts"() {
+function applySubstitutions(filePath, content) {
+  let name = import_path2.default.basename(filePath), ext = import_path2.default.extname(filePath);
+  if (name === "package.json")
+    return Buffer.from(rewritePackageJson(content.toString("utf8")), "utf8");
+  if (name === "npmrc.template" || name === ".npmrc")
+    return Buffer.from(rewriteNpmrc(content.toString("utf8")), "utf8");
+  if (ext === ".scss" || ext === ".css")
+    return Buffer.from(rewriteScss(content.toString("utf8")), "utf8");
+  if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
+    let text = content.toString("utf8"), rewritten = rewriteImports(text);
+    if (rewritten !== text)
+      return Buffer.from(rewritten, "utf8");
+  }
+  return content;
+}
+var import_path2, PACKAGE_RENAME, PACKAGE_DROP, ADDED_DEPS, templateDeps, init_templateSubstitution = __esm({
+  "src/distributions/external/templateSubstitution.ts"() {
     "use strict";
-    init_configStore();
-    DEFAULT_ENVIRONMENT = "";
+    import_path2 = __toESM(require("path")), PACKAGE_RENAME = {
+      "@yandex-data-ui/tracker-plugin-sdk-react": "@weavix/sdk-react",
+      "@yandex-data-ui/tracker-pub-api-types": "@weavix/tracker-api-types"
+    }, PACKAGE_DROP = /* @__PURE__ */ new Set(["@yandex-data-ui/gravity-themes"]), ADDED_DEPS = {
+      "@weavix/sdk-core": "latest",
+      "@weavix/sdk-react": "latest",
+      "@weavix/tracker-api-types": "latest"
+    }, templateDeps = ["@weavix/sdk-core", "@weavix/sdk-react", "@weavix/tracker-api-types"];
   }
 });
 
@@ -297,26 +382,35 @@ var impl2 = (init_registerCommands(), __toCommonJS(registerCommands_exports)), {
 // src/utils/checkUpdate.ts
 var import_node_fetch = __toESM(require("node-fetch"));
 
-// src/distribution/auth.ts
-var impl3 = (init_auth(), __toCommonJS(auth_exports)), { getOAuthTokenUrl: getOAuthTokenUrl2, getNpmUpdateUrl: getNpmUpdateUrl2 } = impl3;
+// src/distribution/hosts.ts
+var impl3 = (init_hosts(), __toCommonJS(hosts_exports)), {
+  getS3Endpoint: getS3Endpoint2,
+  getMdsEndpoint: getMdsEndpoint2,
+  getS3Region: getS3Region2,
+  getBuckets: getBuckets2,
+  getPluginDownloadBase: getPluginDownloadBase2,
+  getPlatformBaseUrl: getPlatformBaseUrl2,
+  getTrackerBaseUrl: getTrackerBaseUrl2,
+  getOAuthTokenUrl: getOAuthTokenUrl2,
+  getUpdateCheckInfo: getUpdateCheckInfo2
+} = impl3;
 
 // src/utils/checkUpdate.ts
 init_logger();
 var checkUpdate = async (version) => {
-  try {
-    let registryUrl = await getNpmUpdateUrl2();
-    if (!registryUrl)
-      return;
-    let response = await (0, import_node_fetch.default)(`${registryUrl}/@yandex-data-ui/tracker-cli/latest`);
-    if (!response.ok)
-      return;
-    let latest = await response.json();
-    latest.version !== version && (logger_default.newLine(), logger_default.info(
-      `\u{1F514} Update available ${version} \u2192 ${latest.version}
-Run: npm i -g @yandex-data-ui/tracker-cli@latest --registry=${registryUrl}`
-    ));
-  } catch {
-  }
+  let info2 = getUpdateCheckInfo2();
+  if (info2)
+    try {
+      let response = await (0, import_node_fetch.default)(`${info2.registryUrl}/${info2.packageName}/latest`);
+      if (!response.ok)
+        return;
+      let latest = await response.json();
+      latest.version !== version && (logger_default.newLine(), logger_default.info(
+        `\u{1F514} Update available ${version} \u2192 ${latest.version}
+Run: npm i -g ${info2.packageName}@latest --registry=${info2.registryUrl}`
+      ));
+    } catch {
+    }
 };
 
 // src/utils/execCommand.ts
@@ -346,180 +440,282 @@ var build = async ({ environment = "production" } = {}) => {
   );
 };
 
-// src/api/tracker.ts
-var import_form_data = __toESM(require("form-data"));
+// src/commands/create/index.ts
+var path8 = __toESM(require("path")), import_prompts2 = require("@inquirer/prompts");
+
+// src/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",
+  "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"],
+  "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"))}
 
-// src/api/trackerApiRequest.ts
-var import_node_fetch2 = __toESM(require("node-fetch"));
+${import_picocolors2.default.dim(`\u{1F4C1} Creating an app in your current directory: ${pwd}`)}
 
-// 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
+${import_picocolors2.default.dim("Press")} ${import_picocolors2.default.yellow("Ctrl+C")} ${import_picocolors2.default.dim("to cancel.")}
+`;
+
+// src/commands/create/utils/initManifest.ts
+var fs = __toESM(require("fs")), path2 = __toESM(require("path"));
+
+// src/commands/create/utils/generateManifest.ts
+function buildSlots(template, slotTitle) {
+  let slotNames = TEMPLATE_SLOTS[template];
+  if (slotNames.length === 0) return;
+  let slotEntry = {
+    entrypoint: "index.html",
+    title: { ru: slotTitle, en: slotTitle }
   };
-  fs.existsSync(authDir) || fs.mkdirSync(authDir, { recursive: !0, mode: 448 }), fs.writeFileSync(authFile, JSON.stringify(authData, null, 2), {
-    mode: 384
-  });
-}, removeAuthData = () => {
-  fs.existsSync(authFile) && fs.unlinkSync(authFile);
-}, authManager = {
-  get authHeader() {
-    return getAuthHeader();
+  return {
+    tracker: Object.fromEntries(slotNames.map((slotName) => [slotName, [slotEntry]]))
+  };
+}
+var generateManifest = (answers) => ({
+  $schema: "./manifest.schema.json",
+  manifest_version: 1,
+  supported_services: ["tracker"],
+  slug: answers.packageSlug,
+  version: answers.version,
+  name: {
+    ru: answers.pluginName,
+    en: answers.pluginName
   },
-  get data() {
-    return getData();
+  description: {
+    ru: answers.pluginDescription,
+    en: answers.pluginDescription
   },
-  saveAuthData,
-  removeAuthData
+  permissions: answers.permissions,
+  support: [{ type: "email", value: answers.supportEmail }],
+  slots: buildSlots(answers.template, answers.slotTitle)
+});
+
+// src/commands/create/utils/initManifest.ts
+var initManifest = ({ answers, targetDir }) => {
+  let generatedManifest = generateManifest(answers), manifestPath2 = path2.join(targetDir, "manifest.json");
+  fs.writeFileSync(manifestPath2, JSON.stringify(generatedManifest, null, 2), "utf-8");
 };
 
-// src/distribution/apiUrls.ts
-var impl4 = (init_apiUrls(), __toCommonJS(apiUrls_exports)), { getPlatformApiUrl: getPlatformApiUrl2, getTrackerApiUrl: getTrackerApiUrl2 } = impl4;
+// src/commands/create/utils/initTemplate.ts
+var fs4 = __toESM(require("fs")), path7 = __toESM(require("path"));
 
-// src/api/trackerApiRequest.ts
-function buildQueryString(queryParams) {
-  if (!queryParams || Object.keys(queryParams).length === 0)
-    return "";
-  let params = new URLSearchParams();
-  return Object.entries(queryParams).forEach(([key, value]) => {
-    params.append(key, String(value));
-  }), `?${params.toString()}`;
-}
-async function parseResponse(response) {
-  return response.status === 204 || response.headers.get("content-length") === "0" ? void 0 : response.headers.get("content-type")?.includes("application/json") ? await response.json() : await response.text();
-}
-async function trackerApiRequest(endpoint, options = {}) {
-  let { method = "GET", body, headers = {}, formData, queryParams } = options, authHeader = authManager.authHeader;
-  if (!authHeader)
-    throw new Error('Not authenticated. Run "tracker-cli login" first.');
-  let requestHeaders = {
-    Authorization: authHeader,
-    Accept: "application/json",
-    ...headers
-  }, requestBody;
-  if (formData) {
-    let formHeaders = formData.getHeaders?.();
-    Object.assign(requestHeaders, formHeaders), requestBody = formData;
-  } else body && method !== "GET" && (requestHeaders["Content-Type"] = "application/json", requestBody = JSON.stringify(body));
-  let queryString = buildQueryString(queryParams), url = `${await getTrackerApiUrl2()}${endpoint}${queryString}`, response = await (0, import_node_fetch2.default)(url, {
-    method,
-    headers: requestHeaders,
-    body: requestBody
-  });
-  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/utils/copyDirectory.ts
+var fs2 = __toESM(require("fs")), import_path3 = __toESM(require("path")), import_tinyglobby = require("tinyglobby");
 
-// 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/distribution/templateSubstitution.ts
+var impl4 = (init_templateSubstitution(), __toCommonJS(templateSubstitution_exports)), { applySubstitutions: applySubstitutions2, templateDeps: templateDeps2 } = impl4;
+
+// src/utils/copyDirectory.ts
+var 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_path3.default.join(sourceDir, file), targetFile = resolveTargetFileName(file), targetPath = import_path3.default.join(targetDir, targetFile);
+      await fs2.promises.mkdir(import_path3.default.dirname(targetPath), { recursive: !0 });
+      let content = await fs2.promises.readFile(sourcePath), rewritten = applySubstitutions2(file, content);
+      await fs2.promises.writeFile(targetPath, rewritten);
+    })
+  );
+};
 
-// 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/utils/getProjectPath.ts
+var import_path4 = __toESM(require("path")), isDevelopment = () => __dirname.includes("/src/"), getProjectPath = (relativePath) => {
+  let levelsUp = isDevelopment() ? "../.." : "..";
+  return import_path4.default.resolve(__dirname, levelsUp, relativePath);
+}, getTemplatesBaseDir = () => getProjectPath("templates"), getTemplatePath = (filename) => import_path4.default.join(getTemplatesBaseDir(), "_shared", filename);
 
-// src/core/manifest/formatValidationErrors.ts
-var priorityOrder = [
-  "required",
-  "type",
-  "minLength",
-  "format",
+// src/commands/create/utils/initTemplate.ts
+init_logger();
+
+// src/commands/create/utils/updatePackageJson.ts
+var fs3 = __toESM(require("fs")), path6 = __toESM(require("path")), updatePackageJson = (targetDir, packageSlug) => {
+  let packageJsonPath = path6.join(targetDir, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
+    let packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+    packageJson.name = packageSlug, fs3.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
+`);
+  }
+};
+
+// src/commands/create/utils/initTemplate.ts
+var initTemplate = async ({ answers, targetDir }) => {
+  fs4.existsSync(targetDir) || fs4.mkdirSync(targetDir, { recursive: !0 });
+  let templatesBaseDir = getTemplatesBaseDir(), templatesDir = path7.join(templatesBaseDir, answers.template), sharedDir = path7.join(templatesBaseDir, "_shared");
+  await copyDirectory(sharedDir, targetDir), await copyDirectory(templatesDir, targetDir), updatePackageJson(targetDir, answers.packageSlug), logger_default.info("Created template with marketplace publication requirements."), logger_default.info(
+    "Before publishing, add ./marketplace/index.md, ./marketplace/header-image.jpg (784:325), and ./public/logo.svg (square)."
+  );
+};
+
+// src/commands/create/index.ts
+var DEFAULT_VERSION = "0.0.1";
+async function create() {
+  logger_default.info(getWelcomeMessage(process.cwd()));
+  let packageSlug = await (0, import_prompts2.input)({
+    message: "Enter app slug (e.g., my-tracker-plugin):",
+    required: !0
+  }), pluginName = await (0, import_prompts2.input)({
+    message: "Enter plugin name:",
+    required: !0
+  }), pluginDescription = await (0, import_prompts2.input)({
+    message: "Enter plugin description:",
+    required: !0
+  }), supportEmail = await (0, import_prompts2.input)({
+    message: "Enter support email:",
+    required: !0,
+    validate: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) || "Please enter a valid email address"
+  }), template = await (0, import_prompts2.select)({
+    message: "Select a template:",
+    choices: TEMPLATES.map((templateName) => ({
+      name: templateName,
+      value: templateName
+    }))
+  }), dataPermissions = await (0, import_prompts2.checkbox)({
+    message: "Select data permissions (some popular options):",
+    choices: TOP_DATA_PERMISSIONS.map((permission) => ({
+      name: permission,
+      value: permission
+    }))
+  }), answers = {
+    packageSlug,
+    slotTitle: packageSlug,
+    pluginName,
+    pluginDescription,
+    supportEmail,
+    template,
+    permissions: {
+      data: dataPermissions
+    },
+    version: DEFAULT_VERSION
+  }, targetDir = path8.join(process.cwd(), answers.packageSlug);
+  await initTemplate({
+    answers,
+    targetDir
+  }), initManifest({
+    answers,
+    targetDir
+  }), logger_default.newLine(), logger_default.success("Package generated!"), logger_default.commands("To get started, run", [
+    `cd ${answers.packageSlug}`,
+    "npm install",
+    `${CLI_NAME2} debug`
+  ]);
+}
+
+// src/commands/debug/index.ts
+var import_fs6 = __toESM(require("fs")), import_path8 = __toESM(require("path"));
+
+// src/core/manifest/manifestManager.ts
+var import_fs2 = require("fs"), import_promises = require("fs/promises"), import_ajv = __toESM(require("ajv")), import_ajv_formats = __toESM(require("ajv-formats"));
+
+// src/core/manifest/formatValidationErrors.ts
+var priorityOrder = [
+  "required",
+  "type",
+  "minLength",
+  "format",
   "pattern",
   "enum",
   "additionalProperties",
@@ -539,14 +735,14 @@ var priorityOrder = [
 }, formatValidationErrors = (errors) => {
   let errorsByPath = {};
   for (let error2 of errors) {
-    let path17 = error2.instancePath || "root";
-    errorsByPath[path17] || (errorsByPath[path17] = []), errorsByPath[path17].push(error2);
+    let path13 = error2.instancePath || "root";
+    errorsByPath[path13] || (errorsByPath[path13] = []), errorsByPath[path13].push(error2);
   }
-  return Object.entries(errorsByPath).map(([path17, pathErrors]) => {
+  return Object.entries(errorsByPath).map(([path13, pathErrors]) => {
     let error2 = [...pathErrors].sort(
       (a, b) => getPriority(a.keyword) - getPriority(b.keyword)
     )[0], formatter = errorMessages[error2.keyword], message = formatter ? formatter(error2.params) : error2.message;
-    return `  - ${path17}: ${message}`;
+    return `  - ${path13}: ${message}`;
   }).join(`
 `);
 };
@@ -560,7 +756,10 @@ var manifest_schema_default = {
   required: [
     "slug",
     "version",
-    "permissions"
+    "permissions",
+    "name",
+    "description",
+    "support"
   ],
   properties: {
     $schema: {
@@ -573,6 +772,23 @@ var manifest_schema_default = {
       maxLength: 63,
       pattern: "^[a-z0-9-]+$"
     },
+    manifest_version: {
+      type: "number",
+      description: "Manifest format version",
+      minimum: 1
+    },
+    supported_services: {
+      type: "array",
+      description: "Supported services for this plugin",
+      items: {
+        type: "string",
+        enum: [
+          "tracker"
+        ]
+      },
+      minItems: 1,
+      uniqueItems: !0
+    },
     slug: {
       type: "string",
       description: "Unique identifier for the plugin (lowercase letters, numbers, hyphen)",
@@ -621,13 +837,13 @@ var manifest_schema_default = {
           type: "string",
           description: "Russian description",
           minLength: 1,
-          maxLength: 300
+          maxLength: 255
         },
         en: {
           type: "string",
           description: "English description",
           minLength: 1,
-          maxLength: 300
+          maxLength: 255
         }
       },
       additionalProperties: !1
@@ -901,14 +1117,6 @@ var manifest_schema_default = {
                 $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",
@@ -1007,7 +1215,7 @@ var validator = (() => {
   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");
+    return await (0, import_promises.readFile)(manifestPath, "utf8");
   } catch (error2) {
     throw error2 instanceof Error ? new Error(`Error reading manifest.json: ${error2.message}`) : new Error("Error loading manifest");
   }
@@ -1024,7 +1232,7 @@ ${errorMessages2}`);
 }, save = async (manifest) => {
   try {
     let content = JSON.stringify(manifest, null, 4);
-    await (0, import_promises2.writeFile)(manifestPath, content, "utf8");
+    await (0, import_promises.writeFile)(manifestPath, content, "utf8");
   } catch (error2) {
     throw error2 instanceof Error ? new Error(`Error saving manifest.json: ${error2.message}`) : new Error("Error saving manifest");
   }
@@ -1039,1507 +1247,196 @@ ${errorMessages2}`);
   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 {};
+// src/core/s3config/constants.ts
+var CONFIG_FILE_NAME = "config.json";
+
+// 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_fs3 = __toESM(require("fs")), import_path5 = __toESM(require("path"));
+
+// src/utils/convertManifestToConfig.ts
+function buildPluginDownloadUrl(env, id, version) {
+  return env === "debug" ? getPluginDownloadBase2(env) : `${getPluginDownloadBase2(env)}/${id}/${version}`;
+}
+var convertManifestToConfig = (manifest, environment) => {
+  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(
+                environment,
+                manifest.slug,
+                manifest.version
+              )
+            };
+            config[slot].push(pluginConfig);
+          }
+        }
+      }
   }
-}, save2 = async (state) => {
+  return config;
+};
+
+// src/commands/debug/utils/createDebugConfig.ts
+var createDebugConfig = async () => {
+  let manifest = await manifestManager.load(), config = convertManifestToConfig(manifest, "debug"), configPath = import_path5.default.join(process.cwd(), CONFIG_FILE_NAME);
+  import_fs3.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+};
+
+// src/commands/debug/utils/lockFile.ts
+var import_fs4 = __toESM(require("fs")), import_path6 = __toESM(require("path")), LOCK_FILE_NAME = ".tracker-cli-debug.lock", getLockFilePath = () => import_path6.default.join(process.cwd(), LOCK_FILE_NAME), getRunningDebugPid = () => {
+  let lockPath = getLockFilePath();
+  if (!import_fs4.default.existsSync(lockPath))
+    return null;
   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}`);
+    let pid = JSON.parse(import_fs4.default.readFileSync(lockPath, "utf-8")).pid;
+    return process.kill(pid, 0), pid;
+  } catch {
+    try {
+      import_fs4.default.unlinkSync(lockPath);
+    } catch {
+    }
+    return null;
   }
-}, update2 = async (updates) => {
-  let updated = { ...await load2(), ...updates };
-  return await save2(updated), updated;
-}, pluginStateManager = {
-  load: load2,
-  save: save2,
-  update: update2
+}, createLockFile = () => {
+  let lockPath = getLockFilePath(), lockData = {
+    pid: process.pid
+  }, fd = import_fs4.default.openSync(lockPath, "wx");
+  import_fs4.default.writeSync(fd, JSON.stringify(lockData, null, 2)), import_fs4.default.closeSync(fd);
+}, removeLockFile = () => {
+  let lockPath = getLockFilePath();
+  import_fs4.default.existsSync(lockPath) && import_fs4.default.unlinkSync(lockPath);
 };
 
-// src/commands/catalog/index.ts
+// src/commands/debug/utils/watchManifest.ts
+var import_fs5 = __toESM(require("fs")), import_path7 = __toESM(require("path"));
 init_logger();
+var watchManifest = () => {
+  let manifestPath2 = import_path7.default.join(process.cwd(), "manifest.json"), debounceTimer = null, watcher = import_fs5.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/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"
-  });
+// src/commands/debug/index.ts
+async function debug(options) {
+  let runningPid = getRunningDebugPid();
+  runningPid && (logger_default.error(
+    `Another instance of ${CLI_NAME2} 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_path8.default.join(process.cwd(), CONFIG_FILE_NAME);
+  options.lint && await manifestManager.validate(), await createDebugConfig();
+  let watcher = watchManifest(), cleanup = () => {
+    watcher.close(), import_fs6.default.existsSync(configPath) && import_fs6.default.unlinkSync(configPath), removeLockFile();
+  };
+  registerCleanup(cleanup), createLockFile(), await execCommand(pluginCmd.dev), cleanup();
 }
-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"
-  });
+
+// 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);
 }
-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/up/utils/copyTemplateFiles.ts
+var import_fs7 = require("fs"), import_promises2 = require("fs/promises");
+var copyTemplateFiles = async (filenames) => {
+  await Promise.all(
+    filenames.map(async (filename) => {
+      let templatePath = getTemplatePath(filename), targetPath = `./${filename}`;
+      if ((0, import_fs7.existsSync)(templatePath) && (0, import_fs7.existsSync)(targetPath)) {
+        let content = await (0, import_promises2.readFile)(templatePath), rewritten = applySubstitutions2(filename, content);
+        await (0, import_promises2.writeFile)(targetPath, rewritten);
+      }
+    })
+  );
+};
+
+// src/commands/up/utils/updateManifestCompatibility.ts
+async function updateManifestCompatibility() {
+  let manifest = await manifestManager.load(), updates = {};
+  "manifest_version" in manifest || (updates.manifest_version = 1), "supported_services" in manifest || (updates.supported_services = ["tracker"]), Object.keys(updates).length > 0 && await manifestManager.update(updates);
 }
 
-// src/commands/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");
+// src/commands/up/utils/updatePackageDependencies.ts
+var import_fs8 = require("fs"), import_promises3 = require("fs/promises");
+var updatePackageDependencies = async (dependencies) => {
+  let packageJsonPath = "./package.json", templatePackageJsonPath = getTemplatePath("package.json");
+  if (!(0, import_fs8.existsSync)(packageJsonPath) || !(0, import_fs8.existsSync)(templatePackageJsonPath))
     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!");
+  let packageJsonContent = await (0, import_promises3.readFile)(packageJsonPath, "utf-8"), templatePackageJsonRaw = await (0, import_promises3.readFile)(templatePackageJsonPath), templatePackageJsonContent = applySubstitutions2(
+    "package.json",
+    templatePackageJsonRaw
+  ).toString("utf8"), 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_promises3.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
+`, "utf-8");
+};
+
+// src/commands/up/index.ts
+var templateFiles = ["manifest.schema.json", "vite.config.ts"];
+async function up() {
+  await copyTemplateFiles(templateFiles), await updateManifestCompatibility(), await updatePackageDependencies(templateDeps2);
 }
 
-// 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/utils/getVersion.ts
+var import_fs9 = require("fs"), import_path9 = require("path"), UNKNOWN_VERSION = "unknown", getVersionFromPackageJson = () => {
+  try {
+    let packagePath = (0, import_path9.resolve)(__dirname, "../../package.json");
+    return (0, import_fs9.existsSync)(packagePath) && JSON.parse((0, import_fs9.readFileSync)(packagePath, "utf-8")).version || null;
+  } catch {
+    return null;
+  }
+}, getVersion = () => "0.3.0";
 
 // src/index.ts
+init_verbose();
+
+// src/utils/withErrorHandling.ts
 init_logger();
-function withErrorHandling2(fn) {
+function withErrorHandling(fn) {
   return async (...args) => {
     try {
       await fn(...args);
@@ -2548,21 +1445,14 @@ function withErrorHandling2(fn) {
     }
   };
 }
+
+// src/index.ts
 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(
+  await checkUpdate(version), program.name(CLI_NAME2).description(CLI_DESCRIPTION2).version(version), CLI_HELP_TEXT2 && program.addHelpText("before", CLI_HELP_TEXT2), program.hook("preAction", (thisCommand) => {
+    setVerboseEnabled(!!thisCommand.opts().verbose);
+  }), program.command("create").description("create your app").action(withErrorHandling(create)), program.command("up").description("update plugin from old template to latest version").action(withErrorHandling(up)), program.command("build").description("build your app").action(withErrorHandling(build)), program.command("debug").description(
     "start a tunnel to connect your local code with the app running in the development environment"
-  ).option("--no-lint", "skip lint validation").action((options) => withErrorHandling2(debug)(options)), program.command("lint").description("run TypeScript and ESLint checks").action(withErrorHandling2(lint)), program.command("login").description("authenticate with Yandex Tracker").action(withErrorHandling2(login)), program.command("logout").description("remove authentication credentials").action(withErrorHandling2(logout)), program.command("whoami").description("display current authentication status").action(withErrorHandling2(async () => await whoami())), process.env.USE_BACKEND_TO_PUBLISH ? (program.command("register").description("register a new plugin and upload archive").action(withErrorHandling2(registerPlatform)), program.command("upload").description("upload plugin archive").action(withErrorHandling2(uploadPlatform)), program.command("update-catalog").description("update plugin catalog entry").action(withErrorHandling2(catalogPlatform)), program.command("submit").description("submit plugin for review").action(withErrorHandling2(submitPlatform)), program.command("list").description("list my plugins").action(withErrorHandling2(listPlatform)), program.command("info [plugin-id]").description(
-    "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);
+  ).option("--no-lint", "skip lint validation").action((options) => withErrorHandling(debug)(options)), program.command("lint").description("run TypeScript and ESLint checks").action(withErrorHandling(lint)), registerDistributionCommands2(program), await program.parseAsync(), process.exit(0);
 }
 main();