@weavix/cli 0.2.0-dev → 0.4.0

package/build/index.js

@@ -47,14 +47,10 @@ function setVerboseEnabled(value) {
 function isVerboseEnabled() {
   return verboseEnabled;
 }
-function writeVerboseArtifact(relativePath, content) {
-  let targetPath = import_path.default.resolve(".tracker-cli-debug", relativePath);
-  return import_fs.default.mkdirSync(import_path.default.dirname(targetPath), { recursive: !0 }), import_fs.default.writeFileSync(targetPath, content), targetPath;
-}
-var import_fs, import_path, verboseEnabled, init_verbose = __esm({
+var verboseEnabled, init_verbose = __esm({
   "src/utils/verbose.ts"() {
     "use strict";
-    import_fs = __toESM(require("fs")), import_path = __toESM(require("path")), verboseEnabled = !1;
+    verboseEnabled = !1;
   }
 });
 
@@ -109,94 +105,77 @@ var import_picocolors, logger, logger_default, init_logger = __esm({
   }
 });
 
-// src/distributions/external/config/configManager.ts
+// src/core/cliConfig/manager.ts
 function getConfigPath() {
   return CONFIG_FILE;
 }
 function readConfig() {
   if (cached !== void 0)
     return cached;
-  if (!(0, import_fs2.existsSync)(CONFIG_FILE))
+  if (!(0, import_fs.existsSync)(CONFIG_FILE))
     return cached = null, cached;
   try {
-    cached = JSON.parse((0, import_fs2.readFileSync)(CONFIG_FILE, "utf-8"));
+    cached = JSON.parse((0, import_fs.readFileSync)(CONFIG_FILE, "utf-8"));
   } catch {
     cached = null;
   }
   return cached;
 }
 function writeConfig(config) {
-  (0, import_fs2.existsSync)(CONFIG_DIR) || (0, import_fs2.mkdirSync)(CONFIG_DIR, { recursive: !0, mode: 448 }), (0, import_fs2.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 }), cached = config;
+  (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;
 }
 function clearConfig() {
-  (0, import_fs2.existsSync)(CONFIG_FILE) && (0, import_fs2.rmSync)(CONFIG_FILE), cached = null;
+  (0, import_fs.existsSync)(CONFIG_FILE) && (0, import_fs.rmSync)(CONFIG_FILE), cached = null;
 }
-function requireConfig() {
-  let config = readConfig();
-  if (!config)
-    throw new Error('CLI is not configured. Run "weavix config set" to configure.');
-  return config;
-}
-var import_fs2, os, import_path2, CONFIG_DIR, CONFIG_FILE, cached, init_configManager = __esm({
-  "src/distributions/external/config/configManager.ts"() {
+var import_fs, os, import_path, CONFIG_DIR, CONFIG_FILE, cached, init_manager = __esm({
+  "src/core/cliConfig/manager.ts"() {
     "use strict";
-    import_fs2 = require("fs"), os = __toESM(require("os")), import_path2 = __toESM(require("path")), CONFIG_DIR = import_path2.default.join(os.homedir(), ".tracker-cli"), CONFIG_FILE = import_path2.default.join(CONFIG_DIR, "config.json");
+    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/config/index.ts
-async function promptString(message, current, required = !0) {
+// src/core/cliConfig/registerCommand.ts
+async function promptString(message, current) {
   return (await (0, import_prompts.input)({
-    message: current ? `${message} (current: ${current})` : message,
+    message: current ? `${message} (current: ${current})` : `${message} (optional)`,
     default: current,
-    required: required && !current
+    required: !1
   }))?.trim() || void 0;
 }
-async function runConfigSet() {
+async function runConfigSet(cliName) {
   let existing = readConfig() ?? {};
-  logger_default.info("Configure CLI endpoints. Empty input keeps the current value.");
-  let s3Endpoint = await promptString("S3 endpoint", existing.s3?.endpoint), s3Region = await promptString("S3 region", existing.s3?.region), mdsEndpoint = await promptString("MDS endpoint", existing.mds?.endpoint), testingStatic = await promptString(
-    "Testing bucket (static)",
-    existing.buckets?.testing?.static
-  ), testingConfig = await promptString(
-    "Testing bucket (config)",
-    existing.buckets?.testing?.config
-  ), productionStatic = await promptString(
+  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
-  ), pluginDownloadTesting = await promptString(
-    "Plugin download base URL (testing)",
-    existing.pluginDownloadBase?.testing
   ), pluginDownloadProduction = await promptString(
-    "Plugin download base URL (production)",
+    "Plugin download base URL",
     existing.pluginDownloadBase?.production
   ), platformBaseUrl = await promptString(
     "Platform API base URL",
     existing.api?.platformBaseUrl
-  ), trackerBaseUrl = await promptString("Tracker API base URL", existing.api?.trackerBaseUrl), oauthUrl = await promptString("OAuth token URL", existing.auth?.oauthUrl);
+  ), oauthUrl = await promptString("OAuth token URL", existing.auth?.oauthUrl);
   writeConfig({
     s3: { endpoint: s3Endpoint, region: s3Region },
     mds: { endpoint: mdsEndpoint },
     buckets: {
-      testing: { static: testingStatic, config: testingConfig },
       production: { static: productionStatic, config: productionConfig }
     },
-    pluginDownloadBase: {
-      testing: pluginDownloadTesting,
-      production: pluginDownloadProduction
-    },
-    api: { platformBaseUrl, trackerBaseUrl },
+    pluginDownloadBase: { production: pluginDownloadProduction },
+    api: { platformBaseUrl },
     auth: { oauthUrl }
-  }), logger_default.success(`Configuration saved \u2192 ${getConfigPath()}`);
+  }), logger_default.success(`Configuration saved \u2192 ${getConfigPath()}`), logger_default.info(`Inspect with "${cliName} config show" or revert with "${cliName} config clear".`);
 }
-function runConfigShow() {
+function runConfigShow(cliName) {
   let cfg = readConfig();
   if (!cfg) {
     logger_default.info(
-      `No configuration found at ${getConfigPath()}. Run "weavix config set" to create one.`
+      `No configuration found at ${getConfigPath()}. Run "${cliName} config set" to create one.`
     );
     return;
   }
@@ -205,16 +184,16 @@ function runConfigShow() {
 function runConfigClear() {
   clearConfig(), logger_default.success(`Configuration removed (${getConfigPath()})`);
 }
-function registerConfigCommand(program) {
+function registerConfigCommand(program, cliName) {
   let config = program.command("config").description("manage CLI configuration");
-  config.command("set").description("set CLI configuration values interactively").action(runConfigSet), config.command("show").description("display current CLI configuration").action(runConfigShow), config.command("clear").description("remove stored CLI configuration").action(runConfigClear);
+  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_config = __esm({
-  "src/distributions/external/config/index.ts"() {
+var import_prompts, init_registerCommand = __esm({
+  "src/core/cliConfig/registerCommand.ts"() {
     "use strict";
     import_prompts = require("@inquirer/prompts");
     init_logger();
-    init_configManager();
+    init_manager();
   }
 });
 
@@ -224,12 +203,13 @@ __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_config();
+    init_registerCommand();
+    init_meta();
   }
 });
 
@@ -246,6 +226,12 @@ __export(hosts_exports, {
   getTrackerBaseUrl: () => getTrackerBaseUrl,
   getUpdateCheckInfo: () => getUpdateCheckInfo
 });
+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)
@@ -265,19 +251,19 @@ function getS3Region() {
   return cfg.s3.region;
 }
 function getBuckets() {
-  let buckets = requireConfig().buckets, testing = buckets?.testing, production = buckets?.production;
-  if (!testing?.static || !testing?.config || !production?.static || !production?.config)
+  let production = requireConfig().buckets?.production;
+  if (!production?.static || !production?.config)
     throw new Error('S3 buckets are not configured. Run "weavix config set" to configure.');
-  return {
-    testing: { static: testing.static, config: testing.config },
-    production: { static: production.static, config: production.config }
-  };
+  let prod = { static: production.static, config: production.config };
+  return { testing: prod, production: prod };
 }
 function getPluginDownloadBase(env) {
-  let base = requireConfig().pluginDownloadBase?.[env];
+  if (env === "debug")
+    return "http://localhost:5173/plugins-debug";
+  let base = requireConfig().pluginDownloadBase?.production;
   if (!base)
     throw new Error(
-      `Plugin download base for "${env}" is not configured. Run "weavix config set" to configure.`
+      'Plugin download base is not configured. Run "weavix config set" to configure.'
     );
   return base;
 }
@@ -290,10 +276,7 @@ function getPlatformBaseUrl() {
   return cfg.api.platformBaseUrl;
 }
 function getTrackerBaseUrl() {
-  let cfg = requireConfig();
-  if (!cfg.api?.trackerBaseUrl)
-    throw new Error('Tracker API URL is not configured. Run "weavix config set" to configure.');
-  return cfg.api.trackerBaseUrl;
+  return TRACKER_BASE_URL;
 }
 function getOAuthTokenUrl() {
   let cfg = requireConfig();
@@ -304,10 +287,86 @@ function getOAuthTokenUrl() {
 function getUpdateCheckInfo() {
   return null;
 }
-var init_hosts = __esm({
+var TRACKER_BASE_URL, init_hosts = __esm({
   "src/distributions/external/hosts.ts"() {
     "use strict";
-    init_configManager();
+    init_manager();
+    TRACKER_BASE_URL = "https://tracker.yandex.ru";
+  }
+});
+
+// src/distributions/external/templateSubstitution.ts
+var templateSubstitution_exports = {};
+__export(templateSubstitution_exports, {
+  applySubstitutions: () => applySubstitutions,
+  templateDeps: () => templateDeps
+});
+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) + `
+`;
+}
+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);
+  }
+  return result;
+}
+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(`
+`);
+}
+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";
+    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"];
   }
 });
 
@@ -339,16 +398,16 @@ var impl3 = (init_hosts(), __toCommonJS(hosts_exports)), {
 // src/utils/checkUpdate.ts
 init_logger();
 var checkUpdate = async (version) => {
-  let info3 = getUpdateCheckInfo2();
-  if (info3)
+  let info2 = getUpdateCheckInfo2();
+  if (info2)
     try {
-      let response = await (0, import_node_fetch.default)(`${info3.registryUrl}/${info3.packageName}/latest`);
+      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 ${info3.packageName}@latest --registry=${info3.registryUrl}`
+Run: npm i -g ${info2.packageName}@latest --registry=${info2.registryUrl}`
       ));
     } catch {
     }
@@ -469,7 +528,6 @@ var TEMPLATES = [
   "project.action",
   "portfolio.action",
   "goal.action",
-  "issue.floatingbottom.action",
   "attachment.viewer.action"
 ];
 var TEMPLATE_SLOTS = {
@@ -483,7 +541,6 @@ var TEMPLATE_SLOTS = {
   "project.action": ["project.action"],
   "portfolio.action": ["portfolio.action"],
   "goal.action": ["goal.action"],
-  "issue.floatingbottom.action": ["issue.floatingbottom.action"],
   "attachment.viewer.action": ["attachment.viewer.action"]
 };
 
@@ -500,7 +557,7 @@ ${import_picocolors2.default.dim("Press")} ${import_picocolors2.default.yellow("
 `;
 
 // src/commands/create/utils/initManifest.ts
-var fs2 = __toESM(require("fs")), path3 = __toESM(require("path"));
+var fs = __toESM(require("fs")), path2 = __toESM(require("path"));
 
 // src/commands/create/utils/generateManifest.ts
 function buildSlots(template, slotTitle) {
@@ -535,15 +592,21 @@ var generateManifest = (answers) => ({
 
 // 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");
+  let generatedManifest = generateManifest(answers), manifestPath2 = path2.join(targetDir, "manifest.json");
+  fs.writeFileSync(manifestPath2, JSON.stringify(generatedManifest, null, 2), "utf-8");
 };
 
 // src/commands/create/utils/initTemplate.ts
-var fs5 = __toESM(require("fs")), path7 = __toESM(require("path"));
+var fs4 = __toESM(require("fs")), path7 = __toESM(require("path"));
+
+// src/utils/copyDirectory.ts
+var fs2 = __toESM(require("fs")), import_path3 = __toESM(require("path")), import_tinyglobby = require("tinyglobby");
+
+// src/distribution/templateSubstitution.ts
+var impl4 = (init_templateSubstitution(), __toCommonJS(templateSubstitution_exports)), { applySubstitutions: applySubstitutions2, templateDeps: templateDeps2 } = impl4;
 
 // src/utils/copyDirectory.ts
-var fs3 = __toESM(require("fs")), import_path3 = __toESM(require("path")), import_tinyglobby = require("tinyglobby"), resolveTargetFileName = (file) => file.endsWith(".template") ? "." + file.replace(".template", "") : file, copyDirectory = async (sourceDir, targetDir) => {
+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,
@@ -552,33 +615,32 @@ var fs3 = __toESM(require("fs")), import_path3 = __toESM(require("path")), impor
   await Promise.all(
     files.map(async (file) => {
       let sourcePath = import_path3.default.join(sourceDir, file), targetFile = resolveTargetFileName(file), targetPath = import_path3.default.join(targetDir, targetFile);
-      await fs3.promises.mkdir(import_path3.default.dirname(targetPath), { recursive: !0 }), await fs3.promises.copyFile(sourcePath, targetPath);
+      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/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);
+var import_path4 = __toESM(require("path")), isDevelopment = () => __dirname.includes("/src/"), getProjectPath = (relativePath) => isDevelopment() ? import_path4.default.resolve(__dirname, "..", "..", relativePath) : import_path4.default.resolve(__dirname, relativePath), getTemplatesBaseDir = () => getProjectPath("templates"), getTemplatePath = (filename) => import_path4.default.join(getTemplatesBaseDir(), "_shared", filename);
 
 // src/commands/create/utils/initTemplate.ts
 init_logger();
 
 // src/commands/create/utils/updatePackageJson.ts
-var fs4 = __toESM(require("fs")), path6 = __toESM(require("path")), updatePackageJson = (targetDir, packageSlug) => {
+var fs3 = __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) + `
+  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 }) => {
-  fs5.existsSync(targetDir) || fs5.mkdirSync(targetDir, { recursive: !0 });
+  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)."
@@ -635,15 +697,15 @@ async function create() {
   }), logger_default.newLine(), logger_default.success("Package generated!"), logger_default.commands("To get started, run", [
     `cd ${answers.packageSlug}`,
     "npm install",
-    "tracker-cli debug"
+    `${CLI_NAME2} debug`
   ]);
 }
 
 // src/commands/debug/index.ts
-var import_fs7 = __toESM(require("fs")), import_path8 = __toESM(require("path"));
+var import_fs6 = __toESM(require("fs")), import_path8 = __toESM(require("path"));
 
 // src/core/manifest/manifestManager.ts
-var import_fs3 = require("fs"), import_promises = require("fs/promises"), import_ajv = __toESM(require("ajv")), import_ajv_formats = __toESM(require("ajv-formats"));
+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 = [
@@ -670,14 +732,14 @@ var priorityOrder = [
 }, formatValidationErrors = (errors) => {
   let errorsByPath = {};
   for (let error2 of errors) {
-    let path18 = error2.instancePath || "root";
-    errorsByPath[path18] || (errorsByPath[path18] = []), errorsByPath[path18].push(error2);
+    let path13 = error2.instancePath || "root";
+    errorsByPath[path13] || (errorsByPath[path13] = []), errorsByPath[path13].push(error2);
   }
-  return Object.entries(errorsByPath).map(([path18, 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 `  - ${path18}: ${message}`;
+    return `  - ${path13}: ${message}`;
   }).join(`
 `);
 };
@@ -1052,14 +1114,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",
@@ -1155,7 +1209,7 @@ var validator = (() => {
   }
   return manifest;
 }, loadRaw = async () => {
-  if (!(0, import_fs3.existsSync)(manifestPath))
+  if (!(0, import_fs2.existsSync)(manifestPath))
     throw new Error(`File manifest.json not found at path: ${manifestPath}`);
   try {
     return await (0, import_promises.readFile)(manifestPath, "utf8");
@@ -1191,23 +1245,7 @@ ${errorMessages2}`);
 };
 
 // src/core/s3config/constants.ts
-var CONFIG_FILE_NAME = "config.json", DEFAULT_ENVIRONMENT = "production", 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"
-};
+var CONFIG_FILE_NAME = "config.json";
 
 // src/commands/debug/index.ts
 init_logger();
@@ -1222,11 +1260,11 @@ var registerCleanup = (cleanup) => {
 };
 
 // src/commands/debug/utils/createDebugConfig.ts
-var import_fs4 = __toESM(require("fs")), import_path5 = __toESM(require("path"));
+var import_fs3 = __toESM(require("fs")), import_path5 = __toESM(require("path"));
 
 // src/utils/convertManifestToConfig.ts
 function buildPluginDownloadUrl(env, id, version) {
-  return `${getPluginDownloadBase2(env)}/${id}/${version}`;
+  return env === "debug" ? getPluginDownloadBase2(env) : `${getPluginDownloadBase2(env)}/${id}/${version}`;
 }
 var convertManifestToConfig = (manifest, environment) => {
   let config = {};
@@ -1268,20 +1306,20 @@ var convertManifestToConfig = (manifest, environment) => {
 // 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_fs4.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  import_fs3.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
 };
 
 // src/commands/debug/utils/lockFile.ts
-var import_fs5 = __toESM(require("fs")), import_path6 = __toESM(require("path")), LOCK_FILE_NAME = ".tracker-cli-debug.lock", getLockFilePath = () => import_path6.default.join(process.cwd(), LOCK_FILE_NAME), getRunningDebugPid = () => {
+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_fs5.default.existsSync(lockPath))
+  if (!import_fs4.default.existsSync(lockPath))
     return null;
   try {
-    let pid = JSON.parse(import_fs5.default.readFileSync(lockPath, "utf-8")).pid;
+    let pid = JSON.parse(import_fs4.default.readFileSync(lockPath, "utf-8")).pid;
     return process.kill(pid, 0), pid;
   } catch {
     try {
-      import_fs5.default.unlinkSync(lockPath);
+      import_fs4.default.unlinkSync(lockPath);
     } catch {
     }
     return null;
@@ -1289,18 +1327,18 @@ var import_fs5 = __toESM(require("fs")), import_path6 = __toESM(require("path"))
 }, 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);
+  }, 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_fs5.default.existsSync(lockPath) && import_fs5.default.unlinkSync(lockPath);
+  import_fs4.default.existsSync(lockPath) && import_fs4.default.unlinkSync(lockPath);
 };
 
 // src/commands/debug/utils/watchManifest.ts
-var import_fs6 = __toESM(require("fs")), import_path7 = __toESM(require("path"));
+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_fs6.default.watch(manifestPath2, async (eventType) => {
+  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");
@@ -1318,7 +1356,7 @@ var watchManifest = () => {
 async function debug(options) {
   let runningPid = getRunningDebugPid();
   runningPid && (logger_default.error(
-    `Another instance of tracker-cli debug is already running.
+    `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:
@@ -1327,785 +1365,27 @@ If you lost the terminal tab, you can kill the process with:
   let configPath = import_path8.default.join(process.cwd(), CONFIG_FILE_NAME);
   options.lint && await manifestManager.validate(), await createDebugConfig();
   let watcher = watchManifest(), cleanup = () => {
-    watcher.close(), import_fs7.default.existsSync(configPath) && import_fs7.default.unlinkSync(configPath), removeLockFile();
+    watcher.close(), import_fs6.default.existsSync(configPath) && import_fs6.default.unlinkSync(configPath), removeLockFile();
   };
   registerCleanup(cleanup), createLockFile(), await execCommand(pluginCmd.dev), cleanup();
 }
 
-// src/core/s3config/promptEnvironment.ts
-var import_prompts3 = require("@inquirer/prompts");
-async function promptEnvironment() {
-  return await (0, import_prompts3.select)({
-    message: "Select environment:",
-    choices: [
-      { name: "Testing", value: "testing" },
-      { name: "Production", value: "production" }
-    ],
-    default: "testing"
-  });
-}
-
-// src/core/s3config/s3Manager.ts
-var import_fs8 = require("fs"), import_promises2 = require("fs/promises"), os2 = __toESM(require("os")), import_path9 = __toESM(require("path")), import_client_s3 = require("@aws-sdk/client-s3"), import_lib_storage = require("@aws-sdk/lib-storage"), import_tinyglobby2 = require("tinyglobby");
-init_logger();
-
-// src/core/s3config/promptCredentials.ts
-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
-async function streamToBuffer(body) {
-  if (!body)
-    return Buffer.alloc(0);
-  let chunks = [];
-  for await (let chunk of body)
-    chunks.push(Buffer.from(chunk));
-  return Buffer.concat(chunks);
-}
-var S3Manager = class {
-  constructor() {
-    this.credentialsDir = import_path9.default.join(os2.homedir(), ".tracker-cli");
-    this.credentialsFile = import_path9.default.join(this.credentialsDir, "s3-credentials.json");
-    this._environment = DEFAULT_ENVIRONMENT;
-  }
-  setEnvironment(environment) {
-    this._environment = environment, logger_default.info(`Environment set to: ${environment}`);
-  }
-  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_promises2.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.getConfigBucket();
-    try {
-      let response = await s3Client.send(
-        new import_client_s3.GetObjectCommand({ Bucket: bucket, Key: CONFIG_FILE_NAME })
-      ), body = await streamToBuffer(response.Body);
-      return body.length ? JSON.parse(body.toString("utf8")) : (logger_default.info("NO DATA"), {});
-    } catch (error2) {
-      return logger_default.error("Error getting plugins config from S3", error2), process.exit();
-    }
-  }
-  async savePluginsConfig(config) {
-    let s3Client = this.createMdsS3Client(), bucket = this.getConfigBucket();
-    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_path9.default.resolve("./dist"), bucket = this.getStaticBucket();
-    logger_default.info(`\u{1F4E6} Starting file upload from ${distPath} to S3 bucket: ${bucket}`);
-    for (let filePath of files)
-      try {
-        let fileContent = await (0, import_promises2.readFile)(filePath), relativePath = import_path9.default.relative(distPath, filePath), s3Key = keyPrefix + relativePath.replace(/\\/g, "/"), mimeType = this.getMimeType(filePath);
-        logger_default.info(`\u2B06\uFE0F  Uploading: ${relativePath}`), await new import_lib_storage.Upload({
-          client: s3Client,
-          params: {
-            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.getStaticBucket(), cwd = process.cwd();
-    for (let rootPath of rootPaths) {
-      let absPath = import_path9.default.resolve(cwd, rootPath);
-      if (!(0, import_fs8.existsSync)(absPath)) {
-        logger_default.warning(`Skipping "${rootPath}" \u2014 not found`);
-        continue;
-      }
-      if ((await import("fs")).statSync(absPath).isFile()) {
-        let fileContent = await (0, import_promises2.readFile)(absPath), s3Key = keyPrefix + import_path9.default.basename(absPath), mimeType = this.getMimeType(absPath);
-        logger_default.info(`\u2B06\uFE0F  Uploading: ${rootPath}`), await new import_lib_storage.Upload({
-          client: s3Client,
-          params: {
-            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_promises2.readFile)(filePath), relativePath = import_path9.default.relative(cwd, filePath), s3Key = keyPrefix + relativePath.replace(/\\/g, "/"), mimeType = this.getMimeType(filePath);
-            logger_default.info(`\u2B06\uFE0F  Uploading: ${relativePath}`), await new import_lib_storage.Upload({
-              client: s3Client,
-              params: {
-                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;
-    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: getS3Region2(),
-      endpoint: getS3Endpoint2(),
-      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 {
-      return await new import_client_s3.S3Client({
-        region: getS3Region2(),
-        endpoint: getS3Endpoint2(),
-        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 mdsClient = this.buildMdsS3Client(creds), bucket = this.getConfigBucket();
-      return await mdsClient.send(new import_client_s3.GetObjectCommand({ Bucket: bucket, Key: CONFIG_FILE_NAME })), !0;
-    } catch (error2) {
-      return logger_default.error("MDS credential validation failed:", error2), !1;
-    }
-  }
-  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.`);
-  }
-  getConfigBucket() {
-    return getBuckets2()[this._environment].config;
-  }
-  getStaticBucket() {
-    return getBuckets2()[this._environment].static;
-  }
-  createMdsS3Client() {
-    let credentials = this.credentials;
-    return (!credentials?.mdsAccessKeyId || !credentials?.mdsSecretAccessKey) && (logger_default.error("MdsS3 credentials not found. Please log in using: tracker-cli login"), process.exit()), this.buildMdsS3Client(credentials);
-  }
-  buildMdsS3Client(credentials) {
-    return new import_client_s3.S3Client({
-      region: getS3Region2(),
-      endpoint: getMdsEndpoint2(),
-      forcePathStyle: !0,
-      credentials: {
-        accessKeyId: credentials.mdsAccessKeyId,
-        secretAccessKey: credentials.mdsSecretAccessKey
-      }
-    });
-  }
-  getMimeType(filePath) {
-    let ext = import_path9.default.extname(filePath).toLowerCase();
-    return mimeTypes[ext] || "application/octet-stream";
-  }
-}, s3Manager = new S3Manager();
-
-// src/utils/getFiles.ts
-var import_fs9 = __toESM(require("fs")), import_path10 = __toESM(require("path")), import_tinyglobby3 = require("tinyglobby");
-init_logger();
-var getFiles = async () => {
-  let distPath = import_path10.default.resolve("./dist");
-  import_fs9.default.existsSync(distPath) || (logger_default.error("Dist folder not found. Build the project first"), process.exit());
-  let files = await (0, import_tinyglobby3.glob)(["**/*"], {
-    cwd: distPath,
-    onlyFiles: !0,
-    absolute: !0
-  });
-  return logger_default.info(`\u{1F4C1} Found ${files.length} files to upload`), files;
-};
-
-// src/commands/deploy/index.ts
-async function deploy() {
-  await s3Manager.checkS3Auth();
-  let environment = await promptEnvironment();
-  s3Manager.setEnvironment(environment);
-  let manifest = await manifestManager.load();
-  await build({ environment });
-  let files = await getFiles();
-  await s3Manager.uploadPluginFiles(manifest, files);
-}
-
-// src/api/tracker.ts
-var import_form_data = __toESM(require("form-data"));
-
-// src/api/trackerApiRequest.ts
-var import_node_fetch2 = __toESM(require("node-fetch"));
-
-// src/core/auth/authManager.ts
-var fs11 = __toESM(require("fs")), os3 = __toESM(require("os")), path15 = __toESM(require("path")), authDir = path15.join(os3.homedir(), ".tracker-cli"), authFile = path15.join(authDir, "auth.json"), getData = () => {
-  try {
-    if (!fs11.existsSync(authFile))
-      return null;
-    let data = fs11.readFileSync(authFile, "utf-8");
-    return JSON.parse(data);
-  } catch {
-    return null;
-  }
-}, getAuthHeader = () => {
-  let authData = getData();
-  return authData ? `OAuth ${authData.token}` : null;
-}, saveAuthData = (token) => {
-  let authData = {
-    token
-  };
-  fs11.existsSync(authDir) || fs11.mkdirSync(authDir, { recursive: !0, mode: 448 }), fs11.writeFileSync(authFile, JSON.stringify(authData, null, 2), {
-    mode: 384
-  });
-}, removeAuthData = () => {
-  fs11.existsSync(authFile) && fs11.unlinkSync(authFile);
-}, authManager = {
-  get authHeader() {
-    return getAuthHeader();
-  },
-  get data() {
-    return getData();
-  },
-  saveAuthData,
-  removeAuthData
-};
-
-// src/api/trackerApiRequest.ts
-function buildQueryString(queryParams) {
-  if (!queryParams || Object.keys(queryParams).length === 0)
-    return "";
-  let params = new URLSearchParams();
-  return Object.entries(queryParams).forEach(([key, value]) => {
-    params.append(key, String(value));
-  }), `?${params.toString()}`;
-}
-async function parseResponse(response) {
-  return response.status === 204 || response.headers.get("content-length") === "0" ? void 0 : response.headers.get("content-type")?.includes("application/json") ? await response.json() : await response.text();
-}
-async function trackerApiRequest(endpoint, options = {}) {
-  let { method = "GET", body, headers = {}, formData, queryParams } = options, authHeader = authManager.authHeader;
-  if (!authHeader)
-    throw new Error('Not authenticated. Run "tracker-cli login" first.');
-  let requestHeaders = {
-    Authorization: authHeader,
-    Accept: "application/json",
-    ...headers
-  }, requestBody;
-  if (formData) {
-    let formHeaders = formData.getHeaders?.();
-    Object.assign(requestHeaders, formHeaders), requestBody = formData;
-  } else body && method !== "GET" && (requestHeaders["Content-Type"] = "application/json", requestBody = JSON.stringify(body));
-  let queryString = buildQueryString(queryParams), url = `${getTrackerBaseUrl2()}${endpoint}${queryString}`, response = await (0, import_node_fetch2.default)(url, {
-    method,
-    headers: requestHeaders,
-    body: requestBody
-  });
-  if (!response.ok) {
-    let errorText = await response.text(), errorMessage = `Tracker API error ${response.status}: ${errorText}`;
-    try {
-      let errorJson = JSON.parse(errorText);
-      errorJson.message && (errorMessage = `Tracker API error ${response.status}: ${errorJson.message}`);
-    } catch {
-    }
-    throw new Error(errorMessage);
-  }
-  return parseResponse(response);
-}
-
-// src/api/tracker.ts
-var PLUGINMOD_QUEUE = "PLUGINMOD";
-function buildIssueSummary(slug) {
-  return `Plugin: ${slug}`;
-}
-function buildIssueDescription(params) {
-  let { pluginId, slug, version, manifestJson, catalogName, catalogDescription, catalogTags } = params, lines = [
-    `**Plugin UUID:** ${pluginId}`,
-    `**Slug:** ${slug}`,
-    `**Version:** ${version}`
-  ];
-  return catalogName && lines.push(`**Name:** ${catalogName}`), catalogDescription && lines.push(`**Description:** ${catalogDescription}`), catalogTags && catalogTags.length > 0 && lines.push(`**Tags:** ${catalogTags.join(", ")}`), lines.push("", "**Manifest:**", "```json", manifestJson, "```"), lines.join(`
-`);
-}
-async function createPluginIssue(params) {
-  let { slug, pluginId, version, manifestJson } = params, body = {
-    queue: PLUGINMOD_QUEUE,
-    summary: buildIssueSummary(slug),
-    description: buildIssueDescription({ pluginId, slug, version, manifestJson }),
-    tags: ["tracker-plugin"]
-  };
-  return trackerApiRequest("/issues", {
-    method: "POST",
-    body
-  });
-}
-async function updatePluginIssue(issueKey, params) {
-  return trackerApiRequest(`/issues/${issueKey}`, {
-    method: "PATCH",
-    body: params
-  });
-}
-async function attachFileToIssue(issueKey, fileBuffer, fileName) {
-  let formData = new import_form_data.default();
-  return formData.append("file", fileBuffer, {
-    filename: fileName,
-    contentType: "application/zip"
-  }), trackerApiRequest(`/issues/${issueKey}/attachments`, {
-    method: "POST",
-    formData
-  });
-}
-async function getIssueTransitions(issueKey) {
-  return trackerApiRequest(`/issues/${issueKey}/transitions`, {
-    method: "GET"
-  });
-}
-async function executeIssueTransition(issueKey, transitionId) {
-  await trackerApiRequest(`/issues/${issueKey}/transitions/${transitionId}/_execute`, {
-    method: "POST",
-    body: {}
-  });
-}
-async function getIssue(issueKey) {
-  return trackerApiRequest(`/issues/${issueKey}`, {
-    method: "GET"
-  });
-}
-async function getMyPluginIssues() {
-  return trackerApiRequest("/issues/_search", {
-    method: "POST",
-    body: {
-      filter: {
-        queue: PLUGINMOD_QUEUE,
-        createdBy: "me()"
-      }
-    }
-  });
-}
-async function addIssueComment(issueKey, text) {
-  await trackerApiRequest(`/issues/${issueKey}/comments`, {
-    method: "POST",
-    body: { text }
-  });
-}
-
-// 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/core/pluginState/pluginStateManager.ts
-var import_fs10 = require("fs"), import_promises3 = require("fs/promises"), STATE_FILE = ".tracker-plugin", load2 = async () => {
-  if (!(0, import_fs10.existsSync)(STATE_FILE))
-    return {};
-  try {
-    let content = await (0, import_promises3.readFile)(STATE_FILE, "utf8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}, save2 = async (state) => {
-  try {
-    let content = JSON.stringify(state, null, 4);
-    await (0, import_promises3.writeFile)(STATE_FILE, content, "utf8");
-  } catch (error2) {
-    throw error2 instanceof Error ? new Error(`Error saving ${STATE_FILE}: ${error2.message}`) : new Error(`Error saving ${STATE_FILE}`);
-  }
-}, update2 = async (updates) => {
-  let updated = { ...await load2(), ...updates };
-  return await save2(updated), updated;
-}, pluginStateManager = {
-  load: load2,
-  save: save2,
-  update: update2
-};
-
-// src/commands/info/index.ts
-init_logger();
-
-// 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));
-};
-var 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 showPluginCreated(data) {
-  printSuccessHeader("\u2705 Plugin Created"), logger_default.newLine(), printPluginId(data.id);
-}
-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() {
-  await s3Manager.checkMdsAuth();
-  let environment = await promptEnvironment();
-  s3Manager.setEnvironment(environment);
-  let [config, manifest] = await Promise.all([
-    s3Manager.getPluginsConfig(),
-    manifestManager.load()
-  ]), pluginConfig = convertManifestToConfig(manifest, environment), 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 = `${getTrackerBaseUrl2()}${endpoint}`, response = await fetch(url, requestOptions);
-  if (!response.ok)
-    throw new Error([response.status, response.statusText].join(" ").trim());
-  let contentType = response.headers.get("content-type");
-  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 ESC = "\x1B", BEL = "\x07", promptForCredentials = async () => {
-  let tokenUrl = getOAuthTokenUrl2();
-  return console.info(
-    import_picocolors4.default.dim("Get your OAuth token at: ") + import_picocolors4.default.cyan(`${ESC}]8;;${tokenUrl}${BEL}${tokenUrl}${ESC}]8;;${BEL}`)
-  ), console.info(""), {
-    token: (await (0, import_prompts5.input)({
-      message: "Enter your Yandex Tracker 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
-init_logger();
-
-// src/commands/submit/index.ts
-init_logger();
-
-// 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() {
-  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_fs11 = require("fs"), import_promises4 = require("fs/promises");
+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}`;
-      (0, import_fs11.existsSync)(templatePath) && (0, import_fs11.existsSync)(targetPath) && await (0, import_promises4.copyFile)(templatePath, targetPath);
+      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);
+      }
     })
   );
 };
@@ -2117,481 +1397,42 @@ async function updateManifestCompatibility() {
 }
 
 // src/commands/up/utils/updatePackageDependencies.ts
-var import_fs12 = require("fs"), import_promises5 = require("fs/promises");
+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_fs12.existsSync)(packageJsonPath) || !(0, import_fs12.existsSync)(templatePackageJsonPath))
+  if (!(0, import_fs8.existsSync)(packageJsonPath) || !(0, import_fs8.existsSync)(templatePackageJsonPath))
     return;
-  let packageJsonContent = await (0, import_promises5.readFile)(packageJsonPath, "utf-8"), templatePackageJsonContent = await (0, import_promises5.readFile)(templatePackageJsonPath, "utf-8"), packageJson = JSON.parse(packageJsonContent), templatePackageJson = JSON.parse(templatePackageJsonContent), updated = !1;
+  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_promises5.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
+  }), 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"], templateDeps = [
-  "@yandex-data-ui/tracker-plugin-sdk-react",
-  "@yandex-data-ui/tracker-pub-api-types"
-];
+var templateFiles = ["manifest.schema.json", "vite.config.ts"];
 async function up() {
-  await copyTemplateFiles(templateFiles), await updateManifestCompatibility(), await updatePackageDependencies(templateDeps);
-}
-
-// src/utils/buildArchive.ts
-var import_path12 = __toESM(require("path")), import_archiver = __toESM(require("archiver"));
-init_logger();
-
-// src/utils/marketplace.ts
-var import_fs13 = __toESM(require("fs")), import_path11 = __toESM(require("path"));
-init_logger();
-var MARKETPLACE_DIR = "marketplace", MARKETPLACE_INDEX_FILE = "index.md", MARKETPLACE_HEADER_IMAGE_FILE = "header-image.jpg", PUBLIC_DIR = "public", PUBLIC_LOGO_FILE = "logo.svg", MANIFEST_FILE = "manifest.json", DIST_DIR = "dist", SRC_DIR = "src", ensurePathExists = (targetPath, errorMessage) => {
-  import_fs13.default.existsSync(targetPath) || (logger_default.error(errorMessage), process.exit(1));
-}, ensureManifestCatalogFields = (manifest) => {
-  (!manifest.name?.ru || !manifest.name?.en) && (logger_default.error(
-    'Manifest field "name" is required for publishing. Add localized "name.ru" and "name.en" to ./manifest.json.'
-  ), process.exit(1)), (!manifest.description?.ru || !manifest.description?.en) && (logger_default.error(
-    'Manifest field "description" is required for publishing. Add localized "description.ru" and "description.en" to ./manifest.json.'
-  ), process.exit(1));
-};
-function validateMarketplaceAssets() {
-  let marketplaceDir = import_path11.default.resolve(MARKETPLACE_DIR);
-  ensurePathExists(
-    marketplaceDir,
-    "Marketplace folder not found. Create ./marketplace and add index.md and header-image.jpg before publishing."
-  ), ensurePathExists(
-    import_path11.default.join(marketplaceDir, MARKETPLACE_INDEX_FILE),
-    "Marketplace description not found. Add ./marketplace/index.md before publishing."
-  ), ensurePathExists(
-    import_path11.default.join(marketplaceDir, MARKETPLACE_HEADER_IMAGE_FILE),
-    "Marketplace header image not found. Add ./marketplace/header-image.jpg before publishing."
-  ), ensurePathExists(
-    import_path11.default.resolve(PUBLIC_DIR, PUBLIC_LOGO_FILE),
-    "Plugin logo not found. Add ./public/logo.svg before publishing."
-  );
-}
-function validateArchiveSources() {
-  ensurePathExists(import_path11.default.resolve(DIST_DIR), "Dist folder not found. Build the project first."), ensurePathExists(
-    import_path11.default.resolve(SRC_DIR),
-    "Source folder not found. Add ./src before publishing."
-  ), ensurePathExists(import_path11.default.resolve(MANIFEST_FILE), "manifest.json not found in plugin root."), validateMarketplaceAssets();
-}
-async function getMarketplaceCatalogEntry() {
-  let indexPath = import_path11.default.resolve(MARKETPLACE_DIR, MARKETPLACE_INDEX_FILE);
-  ensurePathExists(
-    indexPath,
-    "Marketplace description not found. Add ./marketplace/index.md before uploading."
-  );
-  let manifest = await manifestManager.load();
-  ensureManifestCatalogFields(manifest);
-  let longDescription = import_fs13.default.readFileSync(indexPath, "utf-8").trim();
-  return {
-    name: manifest.name.ru,
-    description: manifest.description.ru,
-    longDescription,
-    tags: manifest.keywords ?? []
-  };
-}
-function getMarketplaceHeaderImage() {
-  let imagePath = import_path11.default.resolve(MARKETPLACE_DIR, MARKETPLACE_HEADER_IMAGE_FILE);
-  return ensurePathExists(
-    imagePath,
-    "Marketplace header image not found. Add ./marketplace/header-image.jpg before uploading."
-  ), {
-    buffer: import_fs13.default.readFileSync(imagePath),
-    filename: MARKETPLACE_HEADER_IMAGE_FILE
-  };
-}
-var marketplacePaths = {
-  distDir: DIST_DIR,
-  srcDir: SRC_DIR,
-  marketplaceDir: MARKETPLACE_DIR,
-  manifestFile: MANIFEST_FILE
-};
-
-// src/utils/buildArchive.ts
-init_verbose();
-async function buildArchive() {
-  return validateArchiveSources(), (await manifestManager.load()).manifest_version === void 0 && (logger_default.error(
-    'manifest_version is missing in manifest.json. Run "tracker-cli up" or add "manifest_version": 1 manually before uploading.'
-  ), process.exit(1)), new Promise((resolve2, reject) => {
-    let archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } }), chunks = [];
-    archive.on("data", (chunk) => chunks.push(chunk)), archive.on("end", () => {
-      let buffer = Buffer.concat(chunks);
-      if (logger_default.info(`\u{1F4E6} Archive created (${buffer.length} bytes)`), isVerboseEnabled()) {
-        let debugPath = writeVerboseArtifact("archive/latest-upload.zip", buffer);
-        logger_default.info(`[platform-api-debug] Saved archive copy to ${debugPath}`);
-      }
-      resolve2(buffer);
-    }), archive.on("error", reject), archive.file(import_path12.default.resolve(marketplacePaths.manifestFile), { name: "manifest.json" }), archive.glob(
-      "**/*",
-      {
-        cwd: import_path12.default.resolve(marketplacePaths.distDir),
-        ignore: ["**/.DS_Store"]
-      },
-      { prefix: "dist/" }
-    ), archive.glob(
-      "**/*",
-      {
-        cwd: import_path12.default.resolve(marketplacePaths.srcDir),
-        ignore: ["**/.DS_Store"]
-      },
-      { prefix: "src/" }
-    ), archive.finalize();
-  });
-}
-
-// src/commands/upload/index.ts
-init_logger();
-
-// src/api/platform.ts
-var import_form_data2 = __toESM(require("form-data"));
-
-// src/api/platformApiRequest.ts
-var import_node_fetch3 = __toESM(require("node-fetch"));
-init_logger();
-init_verbose();
-var PLATFORM_API_TIMEOUT_MS = Number(process.env.TRACKER_CLI_PLATFORM_TIMEOUT_MS || 3e4);
-function buildRequestHeaders(headers, formData) {
-  let authHeader = authManager.authHeader;
-  if (!authHeader)
-    throw new Error('Not authenticated. Run "tracker-cli login" first.');
-  let requestHeaders = {
-    Accept: "*/*",
-    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 = `${getPlatformBaseUrl2()}${endpoint}${queryString}`, controller = new AbortController(), timeout = setTimeout(() => controller.abort(), PLATFORM_API_TIMEOUT_MS);
-  if (isVerboseEnabled() && (logger_default.info(
-    `[platform-api-debug] Request: method=${method} url=${url} hasBody=${!!body} hasFormData=${!!formData} timeoutMs=${PLATFORM_API_TIMEOUT_MS}`
-  ), body !== void 0 && logger_default.info(`[platform-api-debug] Request body: ${JSON.stringify(body)}`), formData)) {
-    let debugPath = writeVerboseArtifact(
-      "requests/latest-form-data.txt",
-      `method=${method}
-url=${url}
-headers=${JSON.stringify({ ...requestHeaders, ...additionalHeaders }, null, 2)}
-formData=present
-`
-    );
-    logger_default.info(`[platform-api-debug] Saved form-data request metadata to ${debugPath}`);
-  }
-  try {
-    let response = await (0, import_node_fetch3.default)(url, {
-      ...requestOptions,
-      signal: controller.signal
-    });
-    if (isVerboseEnabled() && logger_default.info(
-      `[platform-api-debug] Response: method=${method} url=${url} status=${response.status} contentType=${response.headers.get("content-type") ?? "n/a"}`
-    ), !response.ok) {
-      let errorText = await response.text(), errorMessage = errorText;
-      try {
-        let errorJson = JSON.parse(errorText);
-        errorJson.message && (errorMessage = errorJson.message);
-      } catch {
-      }
-      throw new Error(errorMessage);
-    }
-    return parseResponse2(response);
-  } catch (error2) {
-    throw error2 instanceof Error && error2.name === "AbortError" ? new Error(
-      `Platform API request timed out after ${PLATFORM_API_TIMEOUT_MS}ms: ${method} ${url}`
-    ) : error2;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-// src/api/platform.ts
-async function createPlugin(archiveBuffer, archiveName) {
-  let formData = new import_form_data2.default();
-  return formData.append("archive", archiveBuffer, {
-    filename: archiveName,
-    contentType: "application/zip"
-  }), 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 updateCatalogImage(pluginId, imageBuffer, imageName) {
-  let formData = new import_form_data2.default();
-  return formData.append("image", imageBuffer, {
-    filename: imageName,
-    contentType: "image/jpeg"
-  }), platformApiRequest(`/api/v1/plugins/${pluginId}/catalog-image`, {
-    method: "PUT",
-    formData
-  });
-}
-async function submitPlugin(pluginId, version) {
-  return platformApiRequest(`/api/v1/plugins/${pluginId}/submit`, {
-    method: "POST",
-    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 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/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/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
-var SUBMIT_TRANSITION_DISPLAY = "waiting for approve";
-async function submitPlatform() {
-  let manifest = await manifestManager.load(), state = await pluginStateManager.load();
-  validateMarketplaceAssets(), await build(), logger_default.info("\u{1F4E6} Creating archive...");
-  let archiveBuffer = await buildArchive(), archiveName = `${manifest.slug}-${manifest.version}.zip`, pluginId = manifest.id;
-  if (pluginId)
-    logger_default.info("\u{1F4E4} Updating plugin archive..."), await updatePluginArchive(pluginId, archiveBuffer, archiveName);
-  else {
-    logger_default.info("\u23F3 Creating plugin...");
-    let createdPlugin = await createPlugin(archiveBuffer, archiveName);
-    showPluginCreated(createdPlugin), pluginId = createdPlugin.id, await manifestManager.update({ id: pluginId });
-  }
-  let manifestContent = await manifestManager.loadRaw(), issueKey = state.trackerIssueKey;
-  if (!issueKey) {
-    logger_default.info("\u23F3 Creating plugin issue in Tracker...");
-    let issue = await createPluginIssue({
-      pluginId,
-      slug: manifest.slug,
-      version: manifest.version,
-      manifestJson: manifestContent
-    });
-    await pluginStateManager.update({ trackerIssueKey: issue.key }), issueKey = issue.key;
-  }
-  let catalogEntry = await getMarketplaceCatalogEntry();
-  logger_default.info("\u{1F4DD} Updating catalog entry from ./marketplace/index.md..."), await updateCatalogEntry(pluginId, catalogEntry);
-  let headerImage = getMarketplaceHeaderImage();
-  logger_default.info("\u{1F5BC}\uFE0F Uploading catalog image from ./marketplace/header-image.jpg..."), await updateCatalogImage(pluginId, headerImage.buffer, headerImage.filename);
-  let validatedSlug = await validateAndGetUniqueSlug(manifest.slug);
-  validatedSlug !== manifest.slug && await manifestManager.update({ slug: validatedSlug }), await submitPlugin(pluginId, manifest.version);
-  let transitions = await getIssueTransitions(issueKey), submitTransition = transitions.find(
-    (t) => t.display?.toLowerCase().includes(SUBMIT_TRANSITION_DISPLAY) || t.id?.toLowerCase().includes("waitingforapprove") || t.id?.toLowerCase().includes("waiting")
-  );
-  if (!submitTransition) {
-    let available = transitions.map((t) => `"${t.display ?? t.id}"`).join(", ");
-    logger_default.error(
-      `Could not find a "Waiting for approve" transition on ${issueKey}. Available: ${available}`
-    );
-    return;
-  }
-  logger_default.info("\u{1F680} Submitting for review..."), await executeIssueTransition(issueKey, submitTransition.id), await addIssueComment(issueKey, `Submitted version \`${manifest.version}\` for review.`), logger_default.success("Plugin submitted for review!"), logger_default.info(`  Tracker issue : ${issueKey}`), logger_default.info(`  Version       : ${manifest.version}`), logger_default.newLine();
-}
-
-// src/commands/submit/tracker.ts
-var import_crypto = require("crypto");
-init_logger();
-var SUBMIT_TRANSITION_DISPLAY2 = "waiting for approve";
-async function submitTracker() {
-  let manifest = await manifestManager.load(), issueKey = (await pluginStateManager.load()).trackerIssueKey;
-  if (issueKey)
-    try {
-      await getIssue(issueKey);
-    } catch {
-      issueKey = void 0;
-    }
-  let pluginId = manifest.id ?? (0, import_crypto.randomUUID)();
-  manifest.id || await manifestManager.update({ id: pluginId });
-  let manifestJson = await manifestManager.loadRaw();
-  if (issueKey) {
-    logger_default.verbose(`\u23F3 Updating issue ${issueKey} with latest manifest...`);
-    let issueDescription = buildIssueDescription({
-      pluginId,
-      slug: manifest.slug,
-      version: manifest.version,
-      manifestJson
-    });
-    await updatePluginIssue(issueKey, { description: issueDescription });
-  } else {
-    logger_default.info("\u23F3 Creating plugin issue in Tracker...");
-    let issue = await createPluginIssue({
-      pluginId,
-      slug: manifest.slug,
-      version: manifest.version,
-      manifestJson
-    });
-    await pluginStateManager.update({ trackerIssueKey: issue.key }), issueKey = issue.key, logger_default.info(`  Tracker issue : ${issueKey}`);
-  }
-  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.verbose(`\u2B06\uFE0F  Attaching ${archiveName} to ${issueKey}...`), await attachFileToIssue(issueKey, archiveBuffer, archiveName), await addIssueComment(
-    issueKey,
-    `Updated bundle: \`${archiveName}\` (${archiveBuffer.length} bytes)`
-  ), logger_default.verbose(`\u23F3 Fetching available transitions for ${issueKey}...`);
-  let transitions = await getIssueTransitions(issueKey), submitTransition = transitions.find(
-    (t) => t.display?.toLowerCase().includes(SUBMIT_TRANSITION_DISPLAY2) || t.id?.toLowerCase().includes("waitingforapprove") || t.id?.toLowerCase().includes("waiting")
-  );
-  if (!submitTransition) {
-    let available = transitions.map((t) => `"${t.display ?? t.id}"`).join(", ");
-    logger_default.error(
-      `Could not find a "Waiting for approve" transition on ${issueKey}. Available: ${available}`
-    );
-    return;
-  }
-  logger_default.info("\u{1F680} Submitting plugin for review..."), await executeIssueTransition(issueKey, submitTransition.id), await addIssueComment(issueKey, `Submitted version \`${manifest.version}\` for review.`), logger_default.success("Plugin submitted for review!"), logger_default.info(`  Tracker issue : ${issueKey}`), logger_default.info(`  Version       : ${manifest.version}`), logger_default.newLine();
+  await copyTemplateFiles(templateFiles), await updateManifestCompatibility(), await updatePackageDependencies(templateDeps2);
 }
 
 // src/utils/getVersion.ts
-var import_fs14 = require("fs"), import_path13 = require("path"), UNKNOWN_VERSION = "unknown", getVersionFromPackageJson = () => {
+var import_fs9 = require("fs"), import_path9 = require("path"), UNKNOWN_VERSION = "unknown", getVersionFromPackageJson = () => {
   try {
-    let packagePath = (0, import_path13.resolve)(__dirname, "../../package.json");
-    return (0, import_fs14.existsSync)(packagePath) && JSON.parse((0, import_fs14.readFileSync)(packagePath, "utf-8")).version || null;
+    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.2.0-dev";
+}, getVersion = () => "0.4.0";
 
 // src/index.ts
-init_logger();
 init_verbose();
+
+// src/utils/withErrorHandling.ts
+init_logger();
 function withErrorHandling(fn) {
   return async (...args) => {
     try {
@@ -2601,23 +1442,14 @@ function withErrorHandling(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.hook("preAction", (thisCommand) => {
     setVerboseEnabled(!!thisCommand.opts().verbose);
-  }), registerDistributionCommands2(program), program.command("feedback").description("Let us know what you think about Yandex Tracker plugins").action(() => {
-    logger_default.info(
-      `Help us make Yandex Tracker even better.
-To report bugs or issues, go to: https://forms.yandex.ru/surveys/6767/`
-    );
   }), program.command("create").description("create your app").action(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) => withErrorHandling(debug)(options)), program.command("lint").description("run TypeScript and ESLint checks").action(withErrorHandling(lint)), program.command("login").description("authenticate with Yandex Tracker").action(withErrorHandling(login)), program.command("logout").description("remove authentication credentials").action(withErrorHandling(logout)), program.command("whoami").description("display current authentication status").action(withErrorHandling(async () => await whoami())), process.env.USE_TRACKER_TO_PUBLISH ? (program.command("submit").description("build, attach archive to Tracker issue, and submit for review").action(withErrorHandling(submitTracker)), program.command("list").description("list my plugins").action(withErrorHandling(list)), program.command("info [issue-key]").description(
-    "get detailed information about a plugin (uses manifest.trackerIssueKey if issue-key not provided)"
-  ).action(withErrorHandling(info2))) : (program.command("submit").description("create plugin, upload data, and submit for review").action(withErrorHandling(submitPlatform)), program.command("list").description("list my plugins").action(withErrorHandling(list)), program.command("info [plugin-id]").description(
-    "get detailed information about a plugin (uses manifest.id if plugin-id not provided)"
-  ).action(withErrorHandling(infoPlatform)), program.command("versions [plugin-id]").description(
-    "list all versions of a plugin (uses manifest.id if plugin-id not provided)"
-  ).action(withErrorHandling(versions))), process.env.TRACKER_CLI_ADMIN && (program.command("deploy").description("build and upload plugin bundle to S3 for production").action(withErrorHandling(deploy)), program.command("install").description("manage app installations").action(withErrorHandling(install)), program.command("uninstall").description("uninstall app from all slots").action(withErrorHandling(uninstall))), await program.parseAsync(), process.exit(0);
+  ).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();