@weavix/cli 0.5.0 → 0.5.1

package/build/index.js

@@ -38,101 +38,22 @@ var meta_exports = {};
 __export(meta_exports, {
   CLI_DESCRIPTION: () => CLI_DESCRIPTION,
   CLI_HELP_TEXT: () => CLI_HELP_TEXT,
-  CLI_NAME: () => CLI_NAME
+  CLI_NAME: () => CLI_NAME,
+  CREATE_SERVICES: () => CREATE_SERVICES
 });
-var CLI_NAME, CLI_DESCRIPTION, CLI_HELP_TEXT, init_meta = __esm({
+var CLI_NAME, CLI_DESCRIPTION, CLI_HELP_TEXT, CREATE_SERVICES, init_meta = __esm({
   "src/distributions/external/meta.ts"() {
     "use strict";
-    CLI_NAME = "weavix", CLI_DESCRIPTION = "Weavix CLI", CLI_HELP_TEXT = "";
+    CLI_NAME = "weavix", CLI_DESCRIPTION = "Weavix CLI", CLI_HELP_TEXT = "", CREATE_SERVICES = ["tracker"];
   }
 });
 
 // src/distribution/meta.ts
-var impl, CLI_NAME2, CLI_DESCRIPTION2, CLI_HELP_TEXT2, init_meta2 = __esm({
+var impl, CLI_NAME2, CLI_DESCRIPTION2, CLI_HELP_TEXT2, CREATE_SERVICES2, init_meta2 = __esm({
   "src/distribution/meta.ts"() {
     "use strict";
     init_flag();
-    impl = (init_meta(), __toCommonJS(meta_exports)), { CLI_NAME: CLI_NAME2, CLI_DESCRIPTION: CLI_DESCRIPTION2, CLI_HELP_TEXT: CLI_HELP_TEXT2 } = impl;
-  }
-});
-
-// src/commands/submit/options.ts
-var import_commander, skipChecksOption, init_options = __esm({
-  "src/commands/submit/options.ts"() {
-    "use strict";
-    import_commander = require("commander"), skipChecksOption = new import_commander.Option(
-      "--skip-checks",
-      "skip pre-submit validation (manifest, assets, lint, typecheck, tests, audit)"
-    );
-  }
-});
-
-// src/utils/verbose.ts
-function setVerboseEnabled(value) {
-  verboseEnabled = value;
-}
-function isVerboseEnabled() {
-  return verboseEnabled;
-}
-function writeVerboseArtifact(relativePath, content) {
-  let targetPath = import_path.default.resolve(".tracker-cli-debug", relativePath);
-  return import_fs.default.mkdirSync(import_path.default.dirname(targetPath), { recursive: !0 }), import_fs.default.writeFileSync(targetPath, content), targetPath;
-}
-var import_fs, import_path, verboseEnabled, init_verbose = __esm({
-  "src/utils/verbose.ts"() {
-    "use strict";
-    import_fs = __toESM(require("fs")), import_path = __toESM(require("path")), verboseEnabled = !1;
-  }
-});
-
-// src/utils/logger.ts
-function success(message) {
-  console.info(import_picocolors.default.green(`\u2705 ${message}`)), newLine();
-}
-function error(messageOrErr, err) {
-  let message = messageOrErr instanceof Error ? messageOrErr.message : messageOrErr;
-  console.error(import_picocolors.default.red(`\u274C ${message}`)), err instanceof Error && console.error(import_picocolors.default.red(err.message)), newLine();
-}
-function warning(message) {
-  console.warn(import_picocolors.default.yellow(`\u26A0\uFE0F  ${message}`)), newLine();
-}
-function info(message) {
-  console.info(message), newLine();
-}
-function verbose(message) {
-  isVerboseEnabled() && (console.info(import_picocolors.default.dim(message)), newLine());
-}
-function suggest(command) {
-  console.info(`Run: ${command}`), newLine();
-}
-function newLine(count = 1) {
-  console.info(`
-`.repeat(count - 1));
-}
-function separator(char = "\u2500", length = 60) {
-  console.info(import_picocolors.default.dim(char.repeat(length))), newLine();
-}
-function commands(title, data) {
-  newLine(), console.info(import_picocolors.default.bold(import_picocolors.default.cyan(`${title}:`))), newLine(), data.forEach((cmd) => {
-    console.info(import_picocolors.default.dim("  $ ") + import_picocolors.default.white(cmd));
-  }), newLine();
-}
-var import_picocolors, logger, logger_default, init_logger = __esm({
-  "src/utils/logger.ts"() {
-    "use strict";
-    import_picocolors = __toESM(require("picocolors"));
-    init_verbose();
-    logger = {
-      success,
-      error,
-      warning,
-      info,
-      verbose,
-      suggest,
-      newLine,
-      separator,
-      commands
-    }, logger_default = logger;
+    impl = (init_meta(), __toCommonJS(meta_exports)), { CLI_NAME: CLI_NAME2, CLI_DESCRIPTION: CLI_DESCRIPTION2, CLI_HELP_TEXT: CLI_HELP_TEXT2, CREATE_SERVICES: CREATE_SERVICES2 } = impl;
   }
 });
 
@@ -143,256 +64,278 @@ function getConfigPath() {
 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;
 }
-var import_fs2, os, import_path2, CONFIG_DIR, CONFIG_FILE, cached, init_manager = __esm({
+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(), ".yaweavix"), CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
   }
 });
 
-// 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 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".`);
-}
-function runConfigShow(cliName) {
-  let cfg = readConfig();
-  if (!cfg) {
-    logger_default.info(
-      `No configuration found at ${getConfigPath()}. Run "${cliName} config set" to create one.`
-    );
-    return;
-  }
-  logger_default.info(`Configuration at ${getConfigPath()}:`), logger_default.info(JSON.stringify(cfg, null, 2));
-}
-function runConfigClear() {
-  clearConfig(), logger_default.success(`Configuration removed (${getConfigPath()})`);
-}
-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);
+// src/core/doctor/policy.ts
+function createDoctorPolicy(options) {
+  let publish = !!options.publish, publishOnlyStatus = publish ? "fail" : "warn";
+  return {
+    mode: publish ? "publish" : "debug",
+    marketplaceAssetsStatus: publishOnlyStatus,
+    manifestPermissionsStatus: publishOnlyStatus,
+    manifestSupportStatus: publishOnlyStatus,
+    distMissingStatus: publishOnlyStatus,
+    authMissingStatus: publishOnlyStatus
+  };
 }
-var import_prompts, init_registerCommand = __esm({
-  "src/core/cliConfig/registerCommand.ts"() {
+var init_policy = __esm({
+  "src/core/doctor/policy.ts"() {
     "use strict";
-    import_prompts = require("@inquirer/prompts");
-    init_logger();
-    init_manager();
   }
 });
 
-// src/utils/withErrorHandling.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/doctor/report.ts
+function createDoctorReport() {
+  return {
+    ok: !1,
+    summary: {
+      passed: 0,
+      warnings: 0,
+      failures: 0
+    },
+    checks: []
   };
 }
-var init_withErrorHandling = __esm({
-  "src/utils/withErrorHandling.ts"() {
+function addCheck(report, check) {
+  report.checks.push({
+    ...check,
+    status: check.status || "pass"
+  });
+}
+function updateSummary(report) {
+  let passed = report.checks.filter((check) => check.status === "pass").length, warnings = report.checks.filter((check) => check.status === "warn").length, failures = report.checks.filter((check) => check.status === "fail").length;
+  report.summary = {
+    passed,
+    warnings,
+    failures
+  }, report.ok = failures === 0;
+}
+function statusBadge(status) {
+  let display = STATUS_DISPLAY[status];
+  return `${display.icon} [${display.label}]`;
+}
+function formatReport(report) {
+  let lines = ["Tracker Plugin Doctor", ""];
+  report.distribution && lines.push(`Distribution: ${report.distribution}`), report.mode && lines.push(`Mode: ${report.mode}`), report.projectRoot && lines.push(`Project root: ${report.projectRoot}`), report.manifestPath && lines.push(`Manifest path: ${report.manifestPath}`), report.manifest && lines.push(`Manifest: ${report.manifest.slug}@${report.manifest.version}`), report.packageManager && lines.push(`Package manager: ${report.packageManager}`), lines.push("", "Checks:");
+  for (let check of report.checks)
+    lines.push(`  ${statusBadge(check.status)} ${check.title}: ${check.message}`), check.action && lines.push(`      Action: ${check.action}`);
+  return lines.push(
+    "",
+    `Summary: \u2713 ${report.summary.passed} passed, \u26A0 ${report.summary.warnings} warning(s), \u2717 ${report.summary.failures} failure(s).`
+  ), lines.push(
+    report.ok ? report.summary.warnings > 0 ? "\u26A0 Doctor finished with warnings." : "\u2713 Doctor finished successfully." : report.mode === "publish" ? "\u2717 Doctor failed. Fix failed checks before publishing." : "\u2717 Doctor failed. Fix failed checks before local debug or build."
+  ), `${lines.join(`
+`)}
+`;
+}
+function writeStdout(content) {
+  return new Promise((resolve2, reject) => {
+    process.stdout.write(content, (error2) => {
+      if (error2) {
+        reject(error2);
+        return;
+      }
+      resolve2();
+    });
+  });
+}
+async function finishDoctor(report, options) {
+  updateSummary(report), await writeStdout(options.json ? `${JSON.stringify(report, null, 4)}
+` : formatReport(report)), report.ok || (process.exitCode = 1);
+}
+var STATUS_DISPLAY, init_report = __esm({
+  "src/core/doctor/report.ts"() {
     "use strict";
-    init_logger();
+    STATUS_DISPLAY = {
+      pass: { icon: "\u2713", label: "PASS" },
+      warn: { icon: "\u26A0", label: "WARN" },
+      fail: { icon: "\u2717", label: "FAIL" }
+    };
   }
 });
 
-// src/core/pluginState/pluginStateManager.ts
-var import_fs3, import_promises, STATE_FILE, load, save, update, pluginStateManager, init_pluginStateManager = __esm({
-  "src/core/pluginState/pluginStateManager.ts"() {
+// src/core/auth/keyringAuthStorage.ts
+var fs, import_keyring, parseAuthData, readLegacyAuthData, removeLegacyAuthData, createKeyringAuthStorage, init_keyringAuthStorage = __esm({
+  "src/core/auth/keyringAuthStorage.ts"() {
     "use strict";
-    import_fs3 = require("fs"), import_promises = require("fs/promises"), STATE_FILE = ".tracker-plugin", load = async () => {
-      if (!(0, import_fs3.existsSync)(STATE_FILE))
-        return {};
+    fs = __toESM(require("fs")), import_keyring = require("@napi-rs/keyring"), parseAuthData = (value) => !value || typeof value != "object" || !("token" in value) || typeof value.token != "string" || !value.token ? null : {
+      token: value.token
+    }, readLegacyAuthData = (legacyAuthFile) => {
       try {
-        let content = await (0, import_promises.readFile)(STATE_FILE, "utf8");
-        return JSON.parse(content);
+        if (!fs.existsSync(legacyAuthFile))
+          return null;
+        let data = fs.readFileSync(legacyAuthFile, "utf-8");
+        return parseAuthData(JSON.parse(data));
       } catch {
-        return {};
+        return null;
       }
-    }, save = async (state) => {
+    }, removeLegacyAuthData = (legacyAuthFile) => {
       try {
-        let content = JSON.stringify(state, null, 4);
-        await (0, import_promises.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}`);
+        fs.existsSync(legacyAuthFile) && fs.unlinkSync(legacyAuthFile);
+      } catch {
       }
-    }, update = async (updates) => {
-      let updated = { ...await load(), ...updates };
-      return await save(updated), updated;
-    }, pluginStateManager = {
-      load,
-      save,
-      update
+    }, createKeyringAuthStorage = ({
+      service,
+      account,
+      legacyAuthFile
+    }) => {
+      let createEntry = () => new import_keyring.Entry(service, account);
+      return {
+        getData: () => {
+          try {
+            let token = createEntry().getPassword();
+            if (token)
+              return { token };
+          } catch {
+            return null;
+          }
+          let legacyAuthData = readLegacyAuthData(legacyAuthFile);
+          if (!legacyAuthData)
+            return null;
+          try {
+            createEntry().setPassword(legacyAuthData.token), removeLegacyAuthData(legacyAuthFile);
+          } catch {
+            return null;
+          }
+          return legacyAuthData;
+        },
+        saveAuthData: (token) => {
+          createEntry().setPassword(token), removeLegacyAuthData(legacyAuthFile);
+        },
+        removeAuthData: () => {
+          try {
+            createEntry().deletePassword();
+          } catch {
+          }
+          removeLegacyAuthData(legacyAuthFile);
+        }
+      };
     };
   }
 });
 
-// src/api/utils.ts
-function getIssueStatusLabel(issue) {
-  let { key: statusKey, display: statusDisplay } = issue.status;
-  return statusKey === "closed" && issue.resolution?.display ? issue.resolution.display : statusDisplay ?? statusKey;
-}
-function getIssueStatusCategory(issue) {
-  let statusKey = issue.status.key, resolutionKey = issue.resolution?.key;
-  if (statusKey === "closed")
-    return resolutionKey === "agreed" ? "approved" : resolutionKey === "rejected" || resolutionKey === "declined" ? "rejected" : "neutral";
-  switch (statusKey) {
-    case "waitingForApprove":
-    case "inProgress":
-      return "pending";
-    case "resultAcceptance":
-      return "acceptance";
-    case "testing":
-      return "testing";
-    case "need_info":
-      return "need_info";
-    default:
-      return "neutral";
-  }
-}
-var init_utils = __esm({
-  "src/api/utils.ts"() {
+// src/distributions/external/authManager.ts
+var os2, path2, authFile, authStorage, getToken, externalAuthManager, init_authManager = __esm({
+  "src/distributions/external/authManager.ts"() {
     "use strict";
+    os2 = __toESM(require("os")), path2 = __toESM(require("path"));
+    init_keyringAuthStorage();
+    authFile = path2.join(os2.homedir(), ".weavix", "auth.json"), authStorage = createKeyringAuthStorage({
+      service: "weavix",
+      account: "oauth-token",
+      legacyAuthFile: authFile
+    }), getToken = () => authStorage.getData()?.token ?? null, externalAuthManager = {
+      get token() {
+        return getToken();
+      },
+      get data() {
+        return authStorage.getData();
+      },
+      saveAuthData: authStorage.saveAuthData,
+      removeAuthData: authStorage.removeAuthData
+    };
   }
 });
 
-// src/utils/pluginDisplay.ts
-function showTrackerPluginList(issues) {
-  if (!issues || issues.length === 0) {
-    console.info(import_picocolors2.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_picocolors2.default.magenta(slugMatch[1].trim()) : import_picocolors2.default.dim(issue.summary), statusBadge = getTrackerIssueBadge(issue);
-    console.info(
-      `  ${slug}  ${import_picocolors2.default.dim("\xB7")}  ${statusBadge}  ${import_picocolors2.default.dim("\xB7")}  ${import_picocolors2.default.dim(issue.key)}`
-    ), logger_default.newLine();
-  });
+// 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
+});
+function requireConfig() {
+  let cfg = readConfig();
+  if (!cfg)
+    throw new Error('CLI is not configured. Run "weavix config set" to configure.');
+  return cfg;
 }
-function showTrackerPluginInfo(issue) {
-  printHeader("\u{1F4E6} Plugin"), logger_default.newLine(), printField("Issue key", import_picocolors2.default.cyan(issue.key)), printField("Status", getTrackerIssueBadge(issue)), printField("Summary", import_picocolors2.default.white(issue.summary)), issue.createdAt && printCreated(issue.createdAt), issue.updatedAt && printUpdated(issue.updatedAt);
+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;
 }
-var import_picocolors2, printHeader, getTrackerIssueBadge, formatDate, printField, printCreated, printUpdated, init_pluginDisplay = __esm({
-  "src/utils/pluginDisplay.ts"() {
-    "use strict";
-    import_picocolors2 = __toESM(require("picocolors"));
-    init_utils();
-    init_logger();
-    printHeader = (title) => {
-      console.info(import_picocolors2.default.bold(import_picocolors2.default.white(title)));
-    }, getTrackerIssueBadge = (issue) => {
-      let label = getIssueStatusLabel(issue);
-      switch (getIssueStatusCategory(issue)) {
-        case "approved":
-          return import_picocolors2.default.black(import_picocolors2.default.bgGreen(` ${label} `));
-        case "rejected":
-          return import_picocolors2.default.white(import_picocolors2.default.bgRed(` ${label} `));
-        case "pending":
-          return import_picocolors2.default.black(import_picocolors2.default.bgYellow(` ${label} `));
-        case "acceptance":
-          return import_picocolors2.default.black(import_picocolors2.default.bgCyan(` ${label} `));
-        case "testing":
-          return import_picocolors2.default.black(import_picocolors2.default.bgMagenta(` ${label} `));
-        case "need_info":
-          return import_picocolors2.default.black(import_picocolors2.default.bgBlue(` ${label} `));
-        default:
-          return import_picocolors2.default.black(import_picocolors2.default.bgWhite(` ${label} `));
-      }
-    }, 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_picocolors2.default.dim(label.padEnd(minWidth))} ${value}`);
-    }, printCreated = (createdAt) => {
-      printField("Created", import_picocolors2.default.white(formatDate(createdAt)));
-    }, printUpdated = (updatedAt) => {
-      printField("Updated", import_picocolors2.default.white(formatDate(updatedAt)));
-    };
-  }
-});
-
-// src/distributions/external/authManager.ts
-var fs2, os2, path3, authDir, authFile, getData, getToken, saveAuthData, removeAuthData, externalAuthManager, init_authManager = __esm({
-  "src/distributions/external/authManager.ts"() {
+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;
+}
+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;
+}
+function getTrackerBaseUrl() {
+  return TRACKER_BASE_URL;
+}
+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;
+}
+function getUpdateCheckInfo() {
+  return null;
+}
+var TRACKER_BASE_URL, init_hosts = __esm({
+  "src/distributions/external/hosts.ts"() {
     "use strict";
-    fs2 = __toESM(require("fs")), os2 = __toESM(require("os")), path3 = __toESM(require("path")), authDir = path3.join(os2.homedir(), ".weavix"), authFile = path3.join(authDir, "auth.json"), getData = () => {
-      try {
-        if (!fs2.existsSync(authFile))
-          return null;
-        let data = fs2.readFileSync(authFile, "utf-8");
-        return JSON.parse(data);
-      } catch {
-        return null;
-      }
-    }, getToken = () => getData()?.token ?? null, saveAuthData = (token) => {
-      let authData = { token };
-      fs2.existsSync(authDir) || fs2.mkdirSync(authDir, { recursive: !0, mode: 448 }), fs2.writeFileSync(authFile, JSON.stringify(authData, null, 2), {
-        mode: 384
-      });
-    }, removeAuthData = () => {
-      fs2.existsSync(authFile) && fs2.unlinkSync(authFile);
-    }, externalAuthManager = {
-      get token() {
-        return getToken();
-      },
-      get data() {
-        return getData();
-      },
-      saveAuthData,
-      removeAuthData
-    };
+    init_manager();
+    TRACKER_BASE_URL = "https://api.tracker.yandex.net/v3";
   }
 });
 
@@ -422,7 +365,7 @@ async function externalTrackerApiRequest(endpoint, options = {}) {
     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 = `${TRACKER_BASE_URL}${endpoint}${queryString}`, response = await (0, import_node_fetch.default)(url, {
+  let queryString = buildQueryString(queryParams), url = `${TRACKER_BASE_URL2}${endpoint}${queryString}`, response = await (0, import_node_fetch.default)(url, {
     method,
     headers: requestHeaders,
     body: requestBody
@@ -438,227 +381,433 @@ async function externalTrackerApiRequest(endpoint, options = {}) {
   }
   return parseResponse(response);
 }
-var import_node_fetch, TRACKER_BASE_URL, ORG_ID, init_trackerApiRequest = __esm({
+var import_node_fetch, TRACKER_BASE_URL2, ORG_ID, init_trackerApiRequest = __esm({
   "src/distributions/external/trackerApiRequest.ts"() {
     "use strict";
     import_node_fetch = __toESM(require("node-fetch"));
     init_authManager();
     init_meta();
-    TRACKER_BASE_URL = "https://api.tracker.yandex.net/v3", ORG_ID = "8470884";
+    TRACKER_BASE_URL2 = "https://api.tracker.yandex.net/v3", ORG_ID = "8470884";
   }
 });
 
-// src/distributions/external/tracker.ts
-function buildIssueSummary(slug) {
-  return `Plugin: ${slug}`;
-}
-function buildIssueDescription(params) {
-  let { pluginId, slug, version, manifestJson } = params;
-  return [
-    `**Plugin UUID:** ${pluginId}`,
-    `**Slug:** ${slug}`,
-    `**Version:** ${version}`,
-    "",
-    "**Manifest:**",
-    "```json",
-    manifestJson,
-    "```"
-  ].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 externalTrackerApiRequest("/issues", {
-    method: "POST",
-    body
-  });
-}
-async function updatePluginIssue(issueKey, params) {
-  return externalTrackerApiRequest(`/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"
-  }), externalTrackerApiRequest(`/issues/${issueKey}/attachments`, {
-    method: "POST",
-    formData
-  });
-}
-async function getIssueTransitions(issueKey) {
-  return externalTrackerApiRequest(`/issues/${issueKey}/transitions`, {
-    method: "GET"
-  });
-}
-async function executeIssueTransition(issueKey, transitionId) {
-  await externalTrackerApiRequest(
-    `/issues/${issueKey}/transitions/${transitionId}/_execute`,
-    {
-      method: "POST",
-      body: {}
+// src/distributions/external/doctorChecks.ts
+var doctorChecks_exports = {};
+__export(doctorChecks_exports, {
+  checkDistribution: () => checkDistribution
+});
+function checkCliConfig(report) {
+  let config = readConfig(), configPath = getConfigPath();
+  if (config) {
+    addCheck(report, {
+      id: "distribution.config",
+      title: "CLI config",
+      message: `External CLI config is readable at ${configPath}.`,
+      data: {
+        configPath
+      }
+    });
+    return;
+  }
+  addCheck(report, {
+    id: "distribution.config",
+    title: "CLI config",
+    status: "fail",
+    message: `External CLI config is missing at ${configPath}.`,
+    action: "Run weavix config set before using external distribution commands.",
+    data: {
+      configPath
     }
-  );
-}
-async function getIssue(issueKey) {
-  return externalTrackerApiRequest(`/issues/${issueKey}`, {
-    method: "GET"
   });
 }
-async function addIssueComment(issueKey, text) {
-  await externalTrackerApiRequest(`/issues/${issueKey}/comments`, {
-    method: "POST",
-    body: { text }
-  });
+function checkHostResolution(report) {
+  try {
+    let data = {
+      trackerBaseUrl: getTrackerBaseUrl(),
+      platformBaseUrl: getPlatformBaseUrl(),
+      s3Endpoint: getS3Endpoint(),
+      mdsEndpoint: getMdsEndpoint(),
+      s3Region: getS3Region(),
+      buckets: getBuckets(),
+      pluginDownloadBase: getPluginDownloadBase("production")
+    };
+    addCheck(report, {
+      id: "distribution.hosts",
+      title: "External host configuration",
+      message: "External host configuration resolved.",
+      data
+    });
+  } catch (error2) {
+    addCheck(report, {
+      id: "distribution.hosts",
+      title: "External host configuration",
+      status: "fail",
+      message: error2 instanceof Error ? error2.message : String(error2),
+      action: "Run weavix config set and fill required endpoints."
+    });
+  }
 }
-async function getMyPluginIssues() {
-  return externalTrackerApiRequest("/issues/_search", {
-    method: "POST",
-    body: {
-      filter: {
-        queue: "PLUGINMOD",
-        createdBy: "me()"
+async function checkExternalAuth(report, {
+  required,
+  useNetwork
+}) {
+  let authData = externalAuthManager.data, authStatus = required || useNetwork ? "fail" : "warn";
+  if (!authData) {
+    addCheck(report, {
+      id: "auth.tracker",
+      title: "Tracker auth",
+      status: authStatus,
+      message: "External Tracker auth token is missing in the system credential store.",
+      action: "Run weavix login before submit or network diagnostics.",
+      data: {
+        storage: "system credential store"
       }
+    });
+    return;
+  }
+  if (addCheck(report, {
+    id: "auth.tracker",
+    title: "Tracker auth",
+    message: "External Tracker auth token is available in the system credential store.",
+    data: {
+      storage: "system credential store"
+    }
+  }), !!useNetwork)
+    try {
+      await externalTrackerApiRequest("/myself"), addCheck(report, {
+        id: "auth.tracker.network",
+        title: "Tracker auth network",
+        message: "Verified external Tracker auth with /myself."
+      });
+    } catch (error2) {
+      addCheck(report, {
+        id: "auth.tracker.network",
+        title: "Tracker auth network",
+        status: "fail",
+        message: error2 instanceof Error ? error2.message : String(error2),
+        action: "Check network access, org access, and rerun weavix login."
+      });
     }
+}
+async function checkDistribution(report, _projectRoot, options, policy = createDoctorPolicy(options)) {
+  report.distribution = DISTRIBUTION, checkCliConfig(report), checkHostResolution(report), await checkExternalAuth(report, {
+    required: policy.authMissingStatus === "fail",
+    useNetwork: !!options.network
   });
 }
-var import_form_data, PLUGINMOD_QUEUE, init_tracker = __esm({
-  "src/distributions/external/tracker.ts"() {
+var DISTRIBUTION, init_doctorChecks = __esm({
+  "src/distributions/external/doctorChecks.ts"() {
     "use strict";
-    import_form_data = __toESM(require("form-data"));
+    init_manager();
+    init_policy();
+    init_report();
+    init_authManager();
+    init_hosts();
     init_trackerApiRequest();
-    PLUGINMOD_QUEUE = "PLUGINMOD";
+    DISTRIBUTION = "external";
   }
 });
 
-// src/distributions/external/info.ts
-async function infoExternal(issueKey) {
-  let targetIssueKey = issueKey;
-  if (targetIssueKey || (targetIssueKey = (await pluginStateManager.load()).trackerIssueKey), !targetIssueKey) {
-    logger_default.warning(
-      `No issue key provided and plugin has not been submitted yet. Run "${CLI_NAME} submit" first.`
-    ), logger_default.suggest(`${CLI_NAME} submit`);
+// src/distribution/doctorChecks.ts
+var impl2, checkDistribution2, init_doctorChecks2 = __esm({
+  "src/distribution/doctorChecks.ts"() {
+    "use strict";
+    init_flag();
+    impl2 = (init_doctorChecks(), __toCommonJS(doctorChecks_exports)), { checkDistribution: checkDistribution2 } = impl2;
+  }
+});
+
+// src/core/doctor/distChecks.ts
+function resolveDistEntrypoint(distDir, entrypoint) {
+  if (import_path2.default.isAbsolute(entrypoint))
+    return {
+      error: `${entrypoint} is absolute`
+    };
+  let filePath = import_path2.default.resolve(distDir, import_path2.default.normalize(entrypoint)), relative = import_path2.default.relative(distDir, filePath);
+  return relative.startsWith("..") || import_path2.default.isAbsolute(relative) ? {
+    error: `${entrypoint} escapes dist`
+  } : {
+    filePath
+  };
+}
+async function checkDist(report, projectRoot, entries, policy) {
+  let distDir = import_path2.default.join(projectRoot, "dist");
+  if (!import_fs2.default.existsSync(distDir)) {
+    addCheck(report, {
+      id: "dist.exists",
+      title: "dist directory",
+      status: policy.distMissingStatus,
+      message: "dist directory is missing.",
+      action: "Run the plugin build before publishing."
+    });
     return;
   }
-  logger_default.info(`\u23F3 Fetching plugin info for ${targetIssueKey}...`);
-  try {
-    let issue = await getIssue(targetIssueKey);
-    showTrackerPluginInfo(issue);
-  } catch (error2) {
-    throw logger_default.error(`Failed to fetch plugin info for ${targetIssueKey}`), error2;
+  if (!import_fs2.default.statSync(distDir).isDirectory()) {
+    addCheck(report, {
+      id: "dist.exists",
+      title: "dist directory",
+      status: "fail",
+      message: `${distDir} exists but is not a directory.`,
+      action: "Remove it and run the plugin build."
+    });
+    return;
+  }
+  let files = await (0, import_tinyglobby.glob)(["**/*"], {
+    cwd: distDir,
+    onlyFiles: !0,
+    absolute: !0
+  });
+  files.length === 0 ? addCheck(report, {
+    id: "dist.files",
+    title: "dist files",
+    status: "fail",
+    message: "dist directory is empty.",
+    action: "Run the plugin build and verify generated files."
+  }) : addCheck(report, {
+    id: "dist.files",
+    title: "dist files",
+    message: `dist contains ${files.length} file(s).`
+  });
+  let entrypoints = [...new Set(entries.map((entry) => entry.entrypoint))], invalidEntrypoints = [], missingEntrypoints = [];
+  for (let entrypoint of entrypoints) {
+    let resolved = resolveDistEntrypoint(distDir, entrypoint);
+    if (resolved.error || !resolved.filePath) {
+      invalidEntrypoints.push(
+        resolved.error ? `${entrypoint} (${resolved.error})` : entrypoint
+      );
+      continue;
+    }
+    (!import_fs2.default.existsSync(resolved.filePath) || !import_fs2.default.statSync(resolved.filePath).isFile()) && missingEntrypoints.push(entrypoint);
   }
+  invalidEntrypoints.length > 0 ? addCheck(report, {
+    id: "dist.entrypoints.valid",
+    title: "Built entrypoint paths",
+    status: "fail",
+    message: `Invalid entrypoint path(s): ${invalidEntrypoints.join(", ")}.`,
+    action: "Use relative entrypoint paths inside dist, for example index.html."
+  }) : entrypoints.length > 0 && addCheck(report, {
+    id: "dist.entrypoints.valid",
+    title: "Built entrypoint paths",
+    message: "Manifest entrypoint paths stay inside dist."
+  }), missingEntrypoints.length > 0 ? addCheck(report, {
+    id: "dist.entrypoints.exist",
+    title: "Built entrypoints",
+    status: "fail",
+    message: `Missing built entrypoint file(s): ${missingEntrypoints.join(", ")}.`,
+    action: "Run the plugin build and keep manifest entrypoint values in sync."
+  }) : entrypoints.length > 0 && invalidEntrypoints.length === 0 && addCheck(report, {
+    id: "dist.entrypoints.exist",
+    title: "Built entrypoints",
+    message: "All manifest entrypoints exist in dist."
+  });
 }
-var init_info = __esm({
-  "src/distributions/external/info.ts"() {
+var import_fs2, import_path2, import_tinyglobby, init_distChecks = __esm({
+  "src/core/doctor/distChecks.ts"() {
     "use strict";
-    init_pluginStateManager();
-    init_logger();
-    init_pluginDisplay();
-    init_meta();
-    init_tracker();
+    import_fs2 = __toESM(require("fs")), import_path2 = __toESM(require("path")), import_tinyglobby = require("tinyglobby");
+    init_report();
   }
 });
 
-// src/distributions/external/list.ts
-async function listExternal() {
-  logger_default.info("\u23F3 Fetching my plugins from Tracker...");
-  try {
-    let issues = await getMyPluginIssues();
-    showTrackerPluginList(issues);
-  } catch (error2) {
-    throw logger_default.error("Failed to fetch plugins list"), error2;
+// ../tracker-core/src/types/slots.ts
+var TRACKER_SLOTS, init_slots = __esm({
+  "../tracker-core/src/types/slots.ts"() {
+    "use strict";
+    TRACKER_SLOTS = [
+      "issue.action",
+      "issue.block",
+      "issue.tab",
+      "issue.comment.action",
+      "issue.editor.action",
+      "queue.action",
+      "queue.tab",
+      "navigation",
+      "trigger.create.action",
+      "trigger.edit.action",
+      "project.action",
+      "project.block",
+      "project.tab",
+      "project.editor.action",
+      "portfolio.action",
+      "portfolio.block",
+      "portfolio.tab",
+      "portfolio.editor.action",
+      "goal.action",
+      "goal.block",
+      "goal.tab",
+      "goal.editor.action",
+      "attachment.viewer.action",
+      "board.tab"
+    ];
   }
-}
-var init_list = __esm({
-  "src/distributions/external/list.ts"() {
+});
+
+// ../tracker-core/src/index.ts
+var init_src = __esm({
+  "../tracker-core/src/index.ts"() {
     "use strict";
-    init_logger();
-    init_pluginDisplay();
-    init_tracker();
+    init_slots();
   }
 });
 
-// src/distributions/external/login.ts
-async function loginExternal() {
-  console.info(
-    import_picocolors3.default.dim(
-      "To get an OAuth token for Yandex Tracker, please contact Tracker support and request one."
-    )
-  ), console.info("");
-  let trimmed = (await (0, import_prompts2.input)({
-    message: "Enter your OAuth token:",
-    required: !0
-  })).trim();
-  externalAuthManager.saveAuthData(trimmed), logger_default.success("OAuth token saved successfully."), logger_default.info('You can now use "weavix submit" to submit your plugin for review.');
-}
-function logoutExternal() {
-  if (!externalAuthManager.data) {
-    logger_default.warning("You are not logged in.");
-    return;
-  }
-  externalAuthManager.removeAuthData(), logger_default.success("Successfully logged out.");
-}
-var import_prompts2, import_picocolors3, init_login = __esm({
-  "src/distributions/external/login.ts"() {
-    "use strict";
-    import_prompts2 = require("@inquirer/prompts"), import_picocolors3 = __toESM(require("picocolors"));
-    init_logger();
-    init_authManager();
-  }
-});
-
-// src/utils/execCommand.ts
-var import_execa, execCommand, init_execCommand = __esm({
-  "src/utils/execCommand.ts"() {
-    "use strict";
-    import_execa = require("execa"), execCommand = async (command, cwd = process.cwd(), env) => {
-      await (0, import_execa.execa)(command, {
-        cwd,
-        shell: !0,
-        stdio: "inherit",
-        env: env ? { ...process.env, ...env } : void 0
-      });
-    };
-  }
-});
-
-// src/commands/constants/templateCommands.ts
-var pluginCmd, init_templateCommands = __esm({
-  "src/commands/constants/templateCommands.ts"() {
-    "use strict";
-    pluginCmd = {
-      install: "npm install",
-      build: "npm run build",
-      dev: "npm run dev",
-      lint: "npm run lint",
-      typecheck: "npm run typecheck",
-      test: "npm test",
-      audit: "npm audit --audit-level=critical"
-    };
-  }
-});
-
-// src/commands/build.ts
-var build, init_build = __esm({
-  "src/commands/build.ts"() {
+// src/core/manifest/constants.ts
+var DATA_PERMISSIONS, TOP_DATA_PERMISSIONS, SERVICES, TEMPLATES, CLI_ONLY_TRACKER_SLOTS, TRACKER_SERVICE_SLOTS, MESSENGER_SERVICE_SLOTS, SERVICE_SLOTS, TEMPLATE_SLOTS, TEMPLATE_SERVICE, init_constants = __esm({
+  "src/core/manifest/constants.ts"() {
     "use strict";
-    init_execCommand();
-    init_logger();
-    init_templateCommands();
-    build = async ({ environment = "production" } = {}) => {
-      logger_default.info("\u{1F528} Building project..."), await execCommand(pluginCmd.install), await execCommand(
-        pluginCmd.build,
-        process.cwd(),
-        environment ? { VITE_DEPLOY_ENV: environment } : void 0
-      );
+    init_src();
+    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), SERVICES = ["tracker", "messenger"], TEMPLATES = [
+      "default",
+      "issue.action",
+      "issue.block",
+      "issue.tab",
+      "issue.comment.action",
+      "issue.editor.action",
+      "queue.action",
+      "queue.tab",
+      "navigation",
+      "trigger.action",
+      "project.action",
+      "project.block",
+      "project.tab",
+      "project.editor.action",
+      "portfolio.action",
+      "portfolio.block",
+      "portfolio.tab",
+      "portfolio.editor.action",
+      "goal.action",
+      "goal.block",
+      "goal.tab",
+      "goal.editor.action",
+      "attachment.viewer.action",
+      "board.tab",
+      "user-card-info",
+      "user-card-calendar"
+    ], CLI_ONLY_TRACKER_SLOTS = ["dock"], TRACKER_SERVICE_SLOTS = [...TRACKER_SLOTS, ...CLI_ONLY_TRACKER_SLOTS], MESSENGER_SERVICE_SLOTS = ["user.card.info"], SERVICE_SLOTS = [...TRACKER_SERVICE_SLOTS, ...MESSENGER_SERVICE_SLOTS], TEMPLATE_SLOTS = {
+      default: [],
+      "issue.action": ["issue.action"],
+      "issue.block": ["issue.block"],
+      "issue.tab": ["issue.tab"],
+      "issue.comment.action": ["issue.comment.action"],
+      "issue.editor.action": ["issue.editor.action"],
+      "queue.action": ["queue.action"],
+      "queue.tab": ["queue.tab"],
+      navigation: ["navigation"],
+      "trigger.action": ["trigger.create.action", "trigger.edit.action"],
+      "project.action": ["project.action"],
+      "project.block": ["project.block"],
+      "project.tab": ["project.tab"],
+      "project.editor.action": ["project.editor.action"],
+      "portfolio.action": ["portfolio.action"],
+      "portfolio.block": ["portfolio.block"],
+      "portfolio.tab": ["portfolio.tab"],
+      "portfolio.editor.action": ["portfolio.editor.action"],
+      "goal.action": ["goal.action"],
+      "goal.block": ["goal.block"],
+      "goal.tab": ["goal.tab"],
+      "goal.editor.action": ["goal.editor.action"],
+      "attachment.viewer.action": ["attachment.viewer.action"],
+      "board.tab": ["board.tab"],
+      "user-card-info": ["user.card.info"],
+      "user-card-calendar": ["user.card.info"]
+    }, TEMPLATE_SERVICE = {
+      default: "tracker",
+      "issue.action": "tracker",
+      "issue.block": "tracker",
+      "issue.tab": "tracker",
+      "issue.comment.action": "tracker",
+      "issue.editor.action": "tracker",
+      "queue.action": "tracker",
+      "queue.tab": "tracker",
+      navigation: "tracker",
+      "trigger.action": "tracker",
+      "project.action": "tracker",
+      "project.block": "tracker",
+      "project.tab": "tracker",
+      "project.editor.action": "tracker",
+      "portfolio.action": "tracker",
+      "portfolio.block": "tracker",
+      "portfolio.tab": "tracker",
+      "portfolio.editor.action": "tracker",
+      "goal.action": "tracker",
+      "goal.block": "tracker",
+      "goal.tab": "tracker",
+      "goal.editor.action": "tracker",
+      "attachment.viewer.action": "tracker",
+      "board.tab": "tracker",
+      "user-card-info": "messenger",
+      "user-card-calendar": "messenger"
     };
   }
 });
@@ -676,11 +825,11 @@ var permissionsSchemaExtensions, init_manifestPermissionsSchema = __esm({
 });
 
 // src/distribution/manifestPermissionsSchema.ts
-var impl2, permissionsSchemaExtensions2, init_manifestPermissionsSchema2 = __esm({
+var impl3, permissionsSchemaExtensions2, init_manifestPermissionsSchema2 = __esm({
   "src/distribution/manifestPermissionsSchema.ts"() {
     "use strict";
     init_flag();
-    impl2 = (init_manifestPermissionsSchema(), __toCommonJS(manifestPermissionsSchema_exports)), { permissionsSchemaExtensions: permissionsSchemaExtensions2 } = impl2;
+    impl3 = (init_manifestPermissionsSchema(), __toCommonJS(manifestPermissionsSchema_exports)), { permissionsSchemaExtensions: permissionsSchemaExtensions2 } = impl3;
   }
 });
 
@@ -712,14 +861,14 @@ var priorityOrder, errorMessages, getPriority, formatValidationErrors, init_form
     }, formatValidationErrors = (errors) => {
       let errorsByPath = {};
       for (let error2 of errors) {
-        let path18 = error2.instancePath || "root";
-        errorsByPath[path18] || (errorsByPath[path18] = []), errorsByPath[path18].push(error2);
+        let path24 = error2.instancePath || "root";
+        errorsByPath[path24] || (errorsByPath[path24] = []), errorsByPath[path24].push(error2);
       }
-      return Object.entries(errorsByPath).map(([path18, pathErrors]) => {
+      return Object.entries(errorsByPath).map(([path24, 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 `  - ${path24}: ${message}`;
       }).join(`
 `);
     };
@@ -764,7 +913,8 @@ var manifest_schema_default, init_manifest_schema = __esm({
           items: {
             type: "string",
             enum: [
-              "tracker"
+              "tracker",
+              "messenger"
             ]
           },
           minItems: 1,
@@ -992,7 +1142,12 @@ var manifest_schema_default, init_manifest_schema = __esm({
               items: {
                 type: "string",
                 enum: [
-                  "clipboard-write"
+                  "clipboard-write",
+                  "microphone",
+                  "camera",
+                  "geolocation",
+                  "web-share",
+                  "allow-downloads"
                 ]
               },
               uniqueItems: !0
@@ -1050,6 +1205,30 @@ var manifest_schema_default, init_manifest_schema = __esm({
                     $ref: "#/definitions/SlotConfig"
                   }
                 },
+                "issue.editor.action": {
+                  type: "array",
+                  description: "Issue Editor Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "queue.action": {
+                  type: "array",
+                  description: "Queue Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "queue.tab": {
+                  type: "array",
+                  description: "Queue Tab slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
                 navigation: {
                   type: "array",
                   description: "Navigation slot configurations",
@@ -1098,6 +1277,14 @@ var manifest_schema_default, init_manifest_schema = __esm({
                     $ref: "#/definitions/SlotConfig"
                   }
                 },
+                "project.editor.action": {
+                  type: "array",
+                  description: "Project Editor Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
                 "portfolio.action": {
                   type: "array",
                   description: "Portfolio Action slot configurations",
@@ -1122,6 +1309,14 @@ var manifest_schema_default, init_manifest_schema = __esm({
                     $ref: "#/definitions/SlotConfig"
                   }
                 },
+                "portfolio.editor.action": {
+                  type: "array",
+                  description: "Portfolio Editor Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
                 "goal.action": {
                   type: "array",
                   description: "Goal Action slot configurations",
@@ -1146,6 +1341,14 @@ var manifest_schema_default, init_manifest_schema = __esm({
                     $ref: "#/definitions/SlotConfig"
                   }
                 },
+                "goal.editor.action": {
+                  type: "array",
+                  description: "Goal Editor Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
                 "attachment.viewer.action": {
                   type: "array",
                   description: "Attachment Viewer Action slot configurations",
@@ -1172,6 +1375,22 @@ var manifest_schema_default, init_manifest_schema = __esm({
                 }
               },
               additionalProperties: !1
+            },
+            messenger: {
+              type: "object",
+              description: "Messenger service slots",
+              minProperties: 1,
+              properties: {
+                "user.card.info": {
+                  type: "array",
+                  description: "User Card Info slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                }
+              },
+              additionalProperties: !1
             }
           },
           additionalProperties: !1
@@ -1362,110 +1581,1269 @@ var manifest_schema_default, init_manifest_schema = __esm({
   }
 });
 
-// src/core/manifest/manifestManager.ts
-var import_fs4, import_promises2, import_ajv, import_ajv_formats, validator, manifestPath, parseManifest, loadRaw, load2, validate, save2, update2, manifestManager, init_manifestManager = __esm({
-  "src/core/manifest/manifestManager.ts"() {
+// src/core/manifest/manifestManager.ts
+var import_fs3, import_promises, import_ajv, import_ajv_formats, validator, defaultManifestPath, parseManifest, loadRaw, load, validate, save, update, manifestManager, init_manifestManager = __esm({
+  "src/core/manifest/manifestManager.ts"() {
+    "use strict";
+    import_fs3 = require("fs"), import_promises = require("fs/promises"), import_ajv = __toESM(require("ajv")), import_ajv_formats = __toESM(require("ajv-formats"));
+    init_manifestPermissionsSchema2();
+    init_formatValidationErrors();
+    init_manifest_schema();
+    validator = (() => {
+      let schema = {
+        ...manifest_schema_default,
+        properties: {
+          ...manifest_schema_default.properties,
+          permissions: {
+            ...manifest_schema_default.properties.permissions,
+            properties: {
+              ...manifest_schema_default.properties.permissions.properties,
+              ...permissionsSchemaExtensions2
+            }
+          }
+        }
+      }, ajv = new import_ajv.default({ allErrors: !0, strict: !1 });
+      return (0, import_ajv_formats.default)(ajv), ajv.compile(schema);
+    })(), defaultManifestPath = "./manifest.json", parseManifest = (content) => {
+      let manifest;
+      try {
+        manifest = JSON.parse(content);
+      } catch (error2) {
+        throw error2 instanceof SyntaxError ? new Error(`File manifest.json contains invalid JSON: ${error2.message}`) : new Error(`Error reading manifest.json: ${error2.message}`);
+      }
+      return manifest;
+    }, loadRaw = async (manifestPath = defaultManifestPath) => {
+      if (!(0, import_fs3.existsSync)(manifestPath))
+        throw new Error(`File manifest.json not found at path: ${manifestPath}`);
+      try {
+        return await (0, import_promises.readFile)(manifestPath, "utf8");
+      } catch (error2) {
+        throw error2 instanceof Error ? new Error(`Error reading manifest.json: ${error2.message}`) : new Error("Error loading manifest");
+      }
+    }, load = async (manifestPath = defaultManifestPath) => {
+      let manifestContent = await loadRaw(manifestPath);
+      return parseManifest(manifestContent);
+    }, validate = async (manifestPath = defaultManifestPath) => {
+      let manifest = await load(manifestPath);
+      if (!validator(manifest) && validator.errors) {
+        let errorMessages2 = formatValidationErrors(validator.errors);
+        throw new Error(
+          `\u274C Manifest validation failed:
+${errorMessages2}
+
+\u{1F4A1} Ensure all required fields are filled according to the plugin documentation.`
+        );
+      }
+    }, save = async (manifest, manifestPath = defaultManifestPath) => {
+      try {
+        let content = JSON.stringify(manifest, null, 4);
+        await (0, import_promises.writeFile)(manifestPath, content, "utf8");
+      } catch (error2) {
+        throw error2 instanceof Error ? new Error(`Error saving manifest.json: ${error2.message}`) : new Error("Error saving manifest");
+      }
+    }, update = async (updates, manifestPath = defaultManifestPath) => {
+      let updatedManifest = { ...await load(manifestPath), ...updates };
+      return await save(updatedManifest, manifestPath), updatedManifest;
+    }, manifestManager = {
+      load,
+      loadRaw,
+      validate,
+      save,
+      update
+    };
+  }
+});
+
+// src/core/doctor/helpers.ts
+function getErrorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+var init_helpers = __esm({
+  "src/core/doctor/helpers.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/doctor/manifestChecks.ts
+function isNonEmptyString(value) {
+  return typeof value == "string" && !!value.trim();
+}
+function isSafeRelativePath(value) {
+  if (import_path3.default.isAbsolute(value))
+    return !1;
+  let normalized = import_path3.default.normalize(value);
+  return normalized !== ".." && !normalized.startsWith(`..${import_path3.default.sep}`);
+}
+function getManifestEntries(manifest) {
+  let result = [];
+  for (let service of SERVICES) {
+    let serviceSlots = manifest.slots?.[service];
+    if (serviceSlots) {
+      for (let [slot, slotConfigs] of Object.entries(serviceSlots))
+        if (!(!SERVICE_SLOTS.includes(slot) || !Array.isArray(slotConfigs)))
+          for (let slotConfig of slotConfigs) {
+            let slotRecord = slotConfig;
+            result.push({
+              service,
+              slot,
+              entrypoint: slotConfig.entrypoint,
+              title: slotConfig.title,
+              description: slotConfig.description,
+              contextLevel: slotConfig.contextLevel,
+              iconUrl: slotRecord.icon?.url
+            });
+          }
+    }
+  }
+  return result;
+}
+function checkLocalizedString(missingValues, name, value) {
+  isNonEmptyString(value?.ru) || missingValues.push(`${name}.ru`), isNonEmptyString(value?.en) || missingValues.push(`${name}.en`);
+}
+function checkManifestDetails(report, manifest, policy) {
+  let entries = getManifestEntries(manifest);
+  entries.length > 0 ? addCheck(report, {
+    id: "manifest.entries",
+    title: "Manifest slot entries",
+    message: `Found ${entries.length} plugin slot entry(s).`,
+    data: entries.map((entry) => ({
+      service: entry.service,
+      slot: entry.slot,
+      entrypoint: entry.entrypoint,
+      contextLevel: entry.contextLevel
+    }))
+  }) : addCheck(report, {
+    id: "manifest.entries",
+    title: "Manifest slot entries",
+    status: "fail",
+    message: "Manifest does not define any supported service slot entries.",
+    action: `Add at least one slots.${SERVICES[0]} entry to manifest.json.`
+  });
+  let missingLocalizedStrings = [];
+  checkLocalizedString(missingLocalizedStrings, "name", manifest.name), checkLocalizedString(missingLocalizedStrings, "description", manifest.description);
+  for (let entry of entries)
+    checkLocalizedString(
+      missingLocalizedStrings,
+      `slots.${entry.service}.${entry.slot}.title`,
+      entry.title
+    ), entry.description && checkLocalizedString(
+      missingLocalizedStrings,
+      `slots.${entry.service}.${entry.slot}.description`,
+      entry.description
+    );
+  missingLocalizedStrings.length === 0 ? addCheck(report, {
+    id: "manifest.localized-strings",
+    title: "Localized strings",
+    message: "Manifest localized strings are non-empty."
+  }) : addCheck(report, {
+    id: "manifest.localized-strings",
+    title: "Localized strings",
+    status: "fail",
+    message: `Empty localized value(s): ${missingLocalizedStrings.join(", ")}.`,
+    action: "Fill ru and en values before publishing."
+  });
+  let invalidEntrypoints = entries.map((entry) => entry.entrypoint).filter((entrypoint) => !isSafeRelativePath(entrypoint));
+  return invalidEntrypoints.length > 0 ? addCheck(report, {
+    id: "manifest.entrypoints.valid",
+    title: "Manifest entrypoint paths",
+    status: "fail",
+    message: `Invalid entrypoint path(s): ${invalidEntrypoints.join(", ")}.`,
+    action: "Use relative entrypoint paths inside dist, for example index.html."
+  }) : entries.length > 0 && addCheck(report, {
+    id: "manifest.entrypoints.valid",
+    title: "Manifest entrypoint paths",
+    message: "All manifest entrypoint paths are relative."
+  }), manifest.permissions?.data?.length ? addCheck(report, {
+    id: "manifest.permissions",
+    title: "Manifest permissions",
+    message: `Manifest declares ${manifest.permissions.data.length} data permission(s).`,
+    data: manifest.permissions
+  }) : addCheck(report, {
+    id: "manifest.permissions",
+    title: "Manifest permissions",
+    status: policy.manifestPermissionsStatus,
+    message: "Manifest permissions.data is empty.",
+    action: "Add the data permissions required by the plugin before publishing."
+  }), manifest.support?.length ? addCheck(report, {
+    id: "manifest.support",
+    title: "Support contacts",
+    message: `Manifest declares ${manifest.support.length} support contact(s).`
+  }) : addCheck(report, {
+    id: "manifest.support",
+    title: "Support contacts",
+    status: policy.manifestSupportStatus,
+    message: "Manifest support contacts are missing.",
+    action: "Add at least one support contact to manifest.json before publishing."
+  }), entries;
+}
+async function checkManifest(report, manifestPath, policy) {
+  try {
+    await manifestManager.validate(manifestPath);
+    let manifest = await manifestManager.load(manifestPath);
+    return report.manifest = {
+      slug: manifest.slug,
+      version: manifest.version
+    }, addCheck(report, {
+      id: "manifest.valid",
+      title: "Manifest schema",
+      message: "manifest.json is valid."
+    }), {
+      manifest,
+      entries: checkManifestDetails(report, manifest, policy)
+    };
+  } catch (error2) {
+    return addCheck(report, {
+      id: "manifest.valid",
+      title: "Manifest schema",
+      status: "fail",
+      message: getErrorMessage(error2),
+      action: "Fix manifest.json before running build, debug, or submit."
+    }), {
+      entries: []
+    };
+  }
+}
+var import_path3, init_manifestChecks = __esm({
+  "src/core/doctor/manifestChecks.ts"() {
+    "use strict";
+    import_path3 = __toESM(require("path"));
+    init_constants();
+    init_manifestManager();
+    init_helpers();
+    init_report();
+  }
+});
+
+// src/core/doctor/marketplaceChecks.ts
+function getMissingOrInvalidStatus(requiredPath, policy) {
+  return requiredPath.path === "src" ? "fail" : policy.marketplaceAssetsStatus;
+}
+function checkMarketplaceAssets(report, projectRoot, policy) {
+  for (let requiredPath of REQUIRED_PATHS) {
+    let fullPath = import_path4.default.join(projectRoot, requiredPath.path), status = getMissingOrInvalidStatus(requiredPath, policy);
+    if (!import_fs4.default.existsSync(fullPath)) {
+      addCheck(report, {
+        id: `marketplace.${requiredPath.path}`,
+        title: requiredPath.title,
+        status,
+        message: `${requiredPath.path} is missing.`,
+        action: `Add ${requiredPath.path} before publishing.`
+      });
+      continue;
+    }
+    let stat = import_fs4.default.statSync(fullPath), validKind = requiredPath.kind === "directory" ? stat.isDirectory() : stat.isFile();
+    addCheck(report, {
+      id: `marketplace.${requiredPath.path}`,
+      title: requiredPath.title,
+      status: validKind ? "pass" : status,
+      message: validKind ? `Found ${requiredPath.path}.` : `${requiredPath.path} exists but is not a ${requiredPath.kind}.`,
+      action: validKind ? void 0 : `Replace ${requiredPath.path} with a ${requiredPath.kind}.`
+    });
+  }
+}
+var import_fs4, import_path4, REQUIRED_PATHS, init_marketplaceChecks = __esm({
+  "src/core/doctor/marketplaceChecks.ts"() {
+    "use strict";
+    import_fs4 = __toESM(require("fs")), import_path4 = __toESM(require("path"));
+    init_report();
+    REQUIRED_PATHS = [
+      { path: "src", title: "Source directory", kind: "directory" },
+      { path: "marketplace", title: "Marketplace directory", kind: "directory" },
+      { path: "marketplace/index.md", title: "Marketplace description", kind: "file" },
+      { path: "marketplace/header-image.jpg", title: "Marketplace header image", kind: "file" },
+      { path: "public/logo.svg", title: "Plugin logo", kind: "file" }
+    ];
+  }
+});
+
+// src/core/doctor/nodeChecks.ts
+function checkNodeVersion(report) {
+  let version = process.versions.node, major = Number(version.split(".")[0]);
+  if (Number.isInteger(major) && major >= REQUIRED_NODE_MAJOR) {
+    addCheck(report, {
+      id: "node.version",
+      title: "Node.js version",
+      message: `Node.js ${version} satisfies >=${REQUIRED_NODE_MAJOR}.`,
+      data: {
+        version,
+        requiredMajor: REQUIRED_NODE_MAJOR
+      }
+    });
+    return;
+  }
+  addCheck(report, {
+    id: "node.version",
+    title: "Node.js version",
+    status: "fail",
+    message: `Node.js ${version} does not satisfy >=${REQUIRED_NODE_MAJOR}.`,
+    action: `Switch to Node.js ${REQUIRED_NODE_MAJOR} or newer.`,
+    data: {
+      version,
+      requiredMajor: REQUIRED_NODE_MAJOR
+    }
+  });
+}
+var REQUIRED_NODE_MAJOR, init_nodeChecks = __esm({
+  "src/core/doctor/nodeChecks.ts"() {
+    "use strict";
+    init_report();
+    REQUIRED_NODE_MAJOR = 22;
+  }
+});
+
+// src/utils/packageManager.ts
+function defaultCommandExists(command) {
+  if (!/^[a-zA-Z0-9_-]+$/.test(command))
+    return !1;
+  let result = (0, import_child_process.spawnSync)("sh", ["-c", `command -v ${command}`], {
+    stdio: "ignore"
+  });
+  return !result.error && result.status === 0;
+}
+function detectFromPackageJson(projectRoot) {
+  let packageJsonPath = import_path5.default.join(projectRoot, "package.json");
+  if (import_fs5.default.existsSync(packageJsonPath))
+    try {
+      let raw = import_fs5.default.readFileSync(packageJsonPath, "utf8"), packageManager = JSON.parse(raw).packageManager;
+      if (typeof packageManager != "string")
+        return;
+      if (packageManager.startsWith("pnpm@"))
+        return "pnpm";
+      if (packageManager.startsWith("npm@"))
+        return "npm";
+    } catch {
+      return;
+    }
+}
+function detectPackageManager(projectRoot = process.cwd()) {
+  return import_fs5.default.existsSync(import_path5.default.join(projectRoot, "pnpm-lock.yaml")) ? "pnpm" : detectFromPackageJson(projectRoot) || "npm";
+}
+function resolvePackageManagerExecutable(packageManager, options = {}) {
+  let commandExists = options.commandExists || defaultCommandExists;
+  if (commandExists(packageManager))
+    return {
+      command: packageManager,
+      argsPrefix: []
+    };
+  if (packageManager !== "npm" && commandExists("corepack"))
+    return {
+      command: "corepack",
+      argsPrefix: [packageManager]
+    };
+  throw packageManager === "npm" ? new Error(
+    "npm is not available in PATH. Install Node.js and npm, then rerun this command."
+  ) : new Error(
+    `${packageManager} is not available in PATH, and Corepack is not available either. Install Node.js >= 22 with Corepack, or run npm install -g corepack@latest && corepack enable once, then rerun this command.`
+  );
+}
+function truncateOutput(value) {
+  let normalized = value.trim();
+  return normalized.length <= MAX_RUNTIME_OUTPUT_LENGTH ? normalized : `${normalized.slice(0, MAX_RUNTIME_OUTPUT_LENGTH)}...`;
+}
+function getRuntimeOutput(result) {
+  return truncateOutput(
+    [result.stdout?.toString(), result.stderr?.toString()].filter(Boolean).join(`
+`)
+  );
+}
+function isCorepackKeyIdError(output) {
+  return /Cannot find matching keyid/i.test(output);
+}
+function getPackageManagerRuntimeAction(output, packageManager) {
+  return isCorepackKeyIdError(output) ? `Corepack cannot verify the pinned package manager signature. Update Corepack from the same registry used for global CLI installs: npm install -g corepack@latest && corepack enable. Then rerun: ${packageManager === "npm" ? "npm install" : `corepack ${packageManager} install`}. Do not use COREPACK_INTEGRITY_KEYS=0 because it disables signature checks.` : packageManager === "npm" ? "Fix the npm runtime, then rerun doctor. For freshly generated plugins, install Node.js >= 22 and run npm install from the plugin directory." : `Fix the ${packageManager} runtime, then rerun doctor. For Corepack-managed package managers, try: npm install -g corepack@latest && corepack enable.`;
+}
+function runPackageManagerRuntimeCheck(projectRoot, packageManager, executable) {
+  let args = [...executable.argsPrefix, "--version"], commandLabel = [executable.command, ...args].join(" "), result = (0, import_child_process.spawnSync)(executable.command, args, {
+    cwd: projectRoot,
+    encoding: "utf8",
+    timeout: PACKAGE_MANAGER_RUNTIME_TIMEOUT_MS
+  }), output = getRuntimeOutput(result);
+  if (!result.error && result.status === 0)
+    return {
+      ok: !0,
+      packageManager,
+      command: executable.command,
+      args,
+      commandLabel,
+      message: `${commandLabel} returned ${output || "success"}.`,
+      version: output || void 0,
+      status: result.status,
+      signal: result.signal,
+      output: output || null
+    };
+  let message = result.error ? result.error.message : output || `${commandLabel} exited with code ${result.status}.`;
+  return {
+    ok: !1,
+    packageManager,
+    command: executable.command,
+    args,
+    commandLabel,
+    message,
+    action: getPackageManagerRuntimeAction(output || message, packageManager),
+    status: result.status,
+    signal: result.signal,
+    output: output || null
+  };
+}
+var import_child_process, import_fs5, import_path5, PACKAGE_MANAGER_RUNTIME_TIMEOUT_MS, MAX_RUNTIME_OUTPUT_LENGTH, PackageManagerRuntimeError, init_packageManager = __esm({
+  "src/utils/packageManager.ts"() {
+    "use strict";
+    import_child_process = require("child_process"), import_fs5 = __toESM(require("fs")), import_path5 = __toESM(require("path")), PACKAGE_MANAGER_RUNTIME_TIMEOUT_MS = 15e3, MAX_RUNTIME_OUTPUT_LENGTH = 1e3, PackageManagerRuntimeError = class extends Error {
+      constructor(check) {
+        super(check.message), this.name = "PackageManagerRuntimeError", this.action = check.action, this.check = check;
+      }
+    };
+  }
+});
+
+// src/core/doctor/packageChecks.ts
+function readPackageJson(projectRoot) {
+  let packageJsonPath = import_path6.default.join(projectRoot, "package.json");
+  if (!import_fs6.default.existsSync(packageJsonPath))
+    return {
+      path: packageJsonPath,
+      error: "package.json not found"
+    };
+  try {
+    let raw = import_fs6.default.readFileSync(packageJsonPath, "utf8");
+    return {
+      path: packageJsonPath,
+      packageJson: JSON.parse(raw)
+    };
+  } catch (error2) {
+    return {
+      path: packageJsonPath,
+      error: getErrorMessage(error2)
+    };
+  }
+}
+function getScript(packageJson, name) {
+  if (typeof packageJson.scripts != "object" || packageJson.scripts === null)
+    return;
+  let value = packageJson.scripts[name];
+  return typeof value == "string" && value.trim() ? value : void 0;
+}
+function getDependencyVersion(packageJson, name) {
+  let dependencySources = [packageJson.dependencies, packageJson.devDependencies];
+  for (let source of dependencySources) {
+    if (typeof source != "object" || source === null)
+      continue;
+    let value = source[name];
+    if (typeof value == "string" && value.trim())
+      return value;
+  }
+}
+function addPackageManagerRuntimeCheck(report, runtimeCheck) {
+  if (runtimeCheck.ok) {
+    addCheck(report, {
+      id: "package-manager.runtime",
+      title: "Package manager runtime",
+      message: runtimeCheck.message,
+      data: {
+        packageManager: runtimeCheck.packageManager,
+        command: runtimeCheck.command,
+        args: runtimeCheck.args,
+        version: runtimeCheck.version || null
+      }
+    });
+    return;
+  }
+  addCheck(report, {
+    id: "package-manager.runtime",
+    title: "Package manager runtime",
+    status: "fail",
+    message: runtimeCheck.message,
+    action: runtimeCheck.action,
+    data: {
+      packageManager: runtimeCheck.packageManager,
+      command: runtimeCheck.command,
+      args: runtimeCheck.args,
+      status: runtimeCheck.status,
+      signal: runtimeCheck.signal,
+      output: runtimeCheck.output
+    }
+  });
+}
+function getPackageManagerInstallAction(packageManager) {
+  return packageManager === "npm" ? "Install Node.js >= 22 with npm, then rerun npm install." : `Install and enable Corepack once: npm install -g corepack@latest && corepack enable. Then rerun corepack ${packageManager} install.`;
+}
+function checkScript(report, packageJson, script, required) {
+  let value = getScript(packageJson, script);
+  if (value) {
+    addCheck(report, {
+      id: `package-json.script.${script}`,
+      title: `${script} script`,
+      message: `${script} script is "${value}".`
+    });
+    return;
+  }
+  addCheck(report, {
+    id: `package-json.script.${script}`,
+    title: `${script} script`,
+    status: required ? "fail" : "warn",
+    message: `Missing package.json scripts.${script}.`,
+    action: required ? `Add scripts.${script}; CLI commands expect it.` : `Add scripts.${script} if this plugin should support this check.`
+  });
+}
+function checkPluginSdkDependency(report, packageJson) {
+  let detectedPackages = COMMON_SDK_PACKAGES.filter(
+    (packageName) => getDependencyVersion(packageJson, packageName)
+  ), detectedGenericPackages = GENERIC_SDK_PACKAGES.filter(
+    (packageName) => getDependencyVersion(packageJson, packageName)
+  ), missingGenericPackages = GENERIC_SDK_PACKAGES.filter(
+    (packageName) => !getDependencyVersion(packageJson, packageName)
+  );
+  if (detectedPackages.length > 0) {
+    addCheck(report, {
+      id: "package-json.sdk-dependency",
+      title: "Plugin SDK dependency",
+      message: `Uses common plugin SDK package(s): ${detectedPackages.join(", ")}.`,
+      data: detectedPackages
+    }), detectedGenericPackages.length > 0 && missingGenericPackages.length > 0 && addCheck(report, {
+      id: "package-json.sdk-generic-pair",
+      title: "Generic SDK dependency pair",
+      status: "warn",
+      message: `Generic SDK dependency set is incomplete. Missing: ${missingGenericPackages.join(", ")}.`,
+      action: "Generated generic React templates depend on both @weavix/sdk-core and @weavix/sdk-react.",
+      data: {
+        detected: detectedGenericPackages,
+        missing: missingGenericPackages
+      }
+    });
+    return;
+  }
+  addCheck(report, {
+    id: "package-json.sdk-dependency",
+    title: "Plugin SDK dependency",
+    status: "warn",
+    message: "No common plugin SDK package was found in dependencies.",
+    action: "Add @weavix/sdk-core + @weavix/sdk-react for generic plugins, or @weavix/tracker-plugin-sdk-react for Tracker plugins."
+  });
+}
+function checkPackageJson(report, projectRoot) {
+  let result = readPackageJson(projectRoot);
+  if (!result.packageJson) {
+    addCheck(report, {
+      id: "package-json.valid",
+      title: "package.json",
+      status: "fail",
+      message: result.error || "package.json cannot be read.",
+      action: `Create a valid package.json at ${result.path}.`
+    });
+    return;
+  }
+  return addCheck(report, {
+    id: "package-json.valid",
+    title: "package.json",
+    message: `Found valid package.json at ${result.path}.`
+  }), typeof result.packageJson.packageManager == "string" ? addCheck(report, {
+    id: "package-json.package-manager",
+    title: "Pinned package manager",
+    message: `packageManager is ${result.packageJson.packageManager}.`
+  }) : addCheck(report, {
+    id: "package-json.package-manager",
+    title: "Pinned package manager",
+    status: "warn",
+    message: "packageManager is missing. CLI will fall back to lockfiles or npm.",
+    action: 'Add packageManager, for example "npm@11.6.4".'
+  }), checkScript(report, result.packageJson, "build", !0), checkScript(report, result.packageJson, "lint", !0), checkScript(report, result.packageJson, "dev", !1), checkScript(report, result.packageJson, "typecheck", !1), checkScript(report, result.packageJson, "test", !1), checkPluginSdkDependency(report, result.packageJson), result.packageJson;
+}
+function checkPackageManager(report, projectRoot) {
+  let projectPackageManager = detectPackageManager(projectRoot);
+  report.packageManager = projectPackageManager, projectPackageManager !== CLI_PACKAGE_MANAGER && addCheck(report, {
+    id: "package-manager.cli-compat",
+    title: "CLI package manager compatibility",
+    status: "warn",
+    message: `Detected ${projectPackageManager}, but existing CLI build/debug/submit commands run ${CLI_PACKAGE_MANAGER}.`,
+    action: "Use npm for generated plugins until CLI command execution is made package-manager aware.",
+    data: {
+      packageManager: projectPackageManager,
+      cliPackageManager: CLI_PACKAGE_MANAGER
+    }
+  });
+  try {
+    let executable = resolvePackageManagerExecutable(CLI_PACKAGE_MANAGER);
+    addCheck(report, {
+      id: "package-manager.executable",
+      title: "CLI package manager executable",
+      message: `CLI commands run ${[executable.command, ...executable.argsPrefix].join(
+        " "
+      )}.`,
+      data: {
+        packageManager: projectPackageManager,
+        cliPackageManager: CLI_PACKAGE_MANAGER,
+        executable
+      }
+    }), addPackageManagerRuntimeCheck(
+      report,
+      runPackageManagerRuntimeCheck(projectRoot, CLI_PACKAGE_MANAGER, executable)
+    );
+  } catch (error2) {
+    addCheck(report, {
+      id: "package-manager.executable",
+      title: "CLI package manager executable",
+      status: "fail",
+      message: getErrorMessage(error2),
+      action: getPackageManagerInstallAction(CLI_PACKAGE_MANAGER),
+      data: {
+        packageManager: projectPackageManager,
+        cliPackageManager: CLI_PACKAGE_MANAGER
+      }
+    });
+  }
+}
+var import_fs6, import_path6, CLI_PACKAGE_MANAGER, COMMON_SDK_PACKAGES, GENERIC_SDK_PACKAGES, init_packageChecks = __esm({
+  "src/core/doctor/packageChecks.ts"() {
+    "use strict";
+    import_fs6 = __toESM(require("fs")), import_path6 = __toESM(require("path"));
+    init_packageManager();
+    init_helpers();
+    init_report();
+    CLI_PACKAGE_MANAGER = "npm", COMMON_SDK_PACKAGES = [
+      "@weavix/sdk-core",
+      "@weavix/sdk-react",
+      "@weavix/tracker-plugin-sdk",
+      "@weavix/tracker-plugin-sdk-react",
+      "@yandex-weavix/tracker-plugin-sdk-core",
+      "@yandex-weavix/tracker-plugin-sdk-react"
+    ], GENERIC_SDK_PACKAGES = ["@weavix/sdk-core", "@weavix/sdk-react"];
+  }
+});
+
+// src/utils/project.ts
+function resolveProjectRoot(startDir = process.cwd()) {
+  let current = import_path7.default.resolve(startDir);
+  for (; ; ) {
+    if (import_fs7.default.existsSync(import_path7.default.join(current, MANIFEST_FILE)))
+      return current;
+    let parent = import_path7.default.dirname(current);
+    if (parent === current)
+      throw new Error(
+        `Could not find ${MANIFEST_FILE}. Run this command inside a plugin project.`
+      );
+    current = parent;
+  }
+}
+function getManifestPath(projectRoot = process.cwd()) {
+  return import_path7.default.join(resolveProjectRoot(projectRoot), MANIFEST_FILE);
+}
+var import_fs7, import_path7, MANIFEST_FILE, init_project = __esm({
+  "src/utils/project.ts"() {
+    "use strict";
+    import_fs7 = __toESM(require("fs")), import_path7 = __toESM(require("path")), MANIFEST_FILE = "manifest.json";
+  }
+});
+
+// src/core/doctor/projectChecks.ts
+function checkProjectRoot(report) {
+  try {
+    let projectRoot = resolveProjectRoot();
+    return report.projectRoot = projectRoot, report.manifestPath = getManifestPath(projectRoot), addCheck(report, {
+      id: "project-root.resolved",
+      title: "Project root",
+      message: `Found plugin project root at ${projectRoot}.`
+    }), projectRoot;
+  } catch (error2) {
+    addCheck(report, {
+      id: "project-root.resolved",
+      title: "Project root",
+      status: "fail",
+      message: getErrorMessage(error2),
+      action: "Run doctor inside a generated plugin project."
+    });
+    return;
+  }
+}
+var init_projectChecks = __esm({
+  "src/core/doctor/projectChecks.ts"() {
+    "use strict";
+    init_project();
+    init_helpers();
+    init_report();
+  }
+});
+
+// src/core/doctor/checks.ts
+async function runDoctorChecks(options) {
+  let report = createDoctorReport(), policy = createDoctorPolicy(options);
+  report.mode = policy.mode, checkNodeVersion(report);
+  let projectRoot = checkProjectRoot(report);
+  if (!projectRoot)
+    return await checkDistribution2(report, void 0, options, policy), report;
+  let { manifest, entries } = await checkManifest(report, report.manifestPath, policy);
+  return checkPackageJson(report, projectRoot) && checkPackageManager(report, projectRoot), manifest && await checkDist(report, projectRoot, entries, policy), checkMarketplaceAssets(report, projectRoot, policy), await checkDistribution2(report, projectRoot, options, policy), report;
+}
+var init_checks = __esm({
+  "src/core/doctor/checks.ts"() {
+    "use strict";
+    init_doctorChecks2();
+    init_distChecks();
+    init_manifestChecks();
+    init_marketplaceChecks();
+    init_nodeChecks();
+    init_packageChecks();
+    init_policy();
+    init_projectChecks();
+    init_report();
+  }
+});
+
+// src/commands/doctor/index.ts
+async function doctor(options = {}) {
+  let report = await runDoctorChecks(options);
+  await finishDoctor(report, options);
+}
+var init_doctor = __esm({
+  "src/commands/doctor/index.ts"() {
+    "use strict";
+    init_checks();
+    init_report();
+  }
+});
+
+// src/commands/submit/options.ts
+var import_commander, skipChecksOption, init_options = __esm({
+  "src/commands/submit/options.ts"() {
+    "use strict";
+    import_commander = require("commander"), skipChecksOption = new import_commander.Option(
+      "--skip-checks",
+      "skip pre-submit validation (manifest, assets, lint, typecheck, tests, audit)"
+    );
+  }
+});
+
+// src/utils/verbose.ts
+function setVerboseEnabled(value) {
+  verboseEnabled = value;
+}
+function isVerboseEnabled() {
+  return verboseEnabled;
+}
+function writeVerboseArtifact(relativePath, content) {
+  let targetPath = import_path8.default.resolve(".yaweavix-debug", relativePath);
+  return import_fs8.default.mkdirSync(import_path8.default.dirname(targetPath), { recursive: !0 }), import_fs8.default.writeFileSync(targetPath, content), targetPath;
+}
+var import_fs8, import_path8, verboseEnabled, init_verbose = __esm({
+  "src/utils/verbose.ts"() {
+    "use strict";
+    import_fs8 = __toESM(require("fs")), import_path8 = __toESM(require("path")), verboseEnabled = !1;
+  }
+});
+
+// src/utils/logger.ts
+function success(message) {
+  console.info(import_picocolors.default.green(`\u2705 ${message}`)), newLine();
+}
+function error(messageOrErr, err) {
+  let message = messageOrErr instanceof Error ? messageOrErr.message : messageOrErr;
+  console.error(import_picocolors.default.red(`\u274C ${message}`)), err instanceof Error && console.error(import_picocolors.default.red(err.message)), newLine();
+}
+function warning(message) {
+  console.warn(import_picocolors.default.yellow(`\u26A0\uFE0F  ${message}`)), newLine();
+}
+function info(message) {
+  console.info(message), newLine();
+}
+function verbose(message) {
+  isVerboseEnabled() && (console.info(import_picocolors.default.dim(message)), newLine());
+}
+function suggest(command) {
+  console.info(`Run: ${command}`), newLine();
+}
+function newLine(count = 1) {
+  console.info(`
+`.repeat(count - 1));
+}
+function separator(char = "\u2500", length = 60) {
+  console.info(import_picocolors.default.dim(char.repeat(length))), newLine();
+}
+function commands(title, data) {
+  newLine(), title && (console.info(import_picocolors.default.bold(import_picocolors.default.cyan(`${title}:`))), newLine()), data.forEach((cmd) => {
+    console.info(import_picocolors.default.dim("  $ ") + import_picocolors.default.white(cmd));
+  }), newLine();
+}
+var import_picocolors, logger, logger_default, init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    import_picocolors = __toESM(require("picocolors"));
+    init_verbose();
+    logger = {
+      success,
+      error,
+      warning,
+      info,
+      verbose,
+      suggest,
+      newLine,
+      separator,
+      commands
+    }, logger_default = logger;
+  }
+});
+
+// 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 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".`);
+}
+function runConfigShow(cliName) {
+  let cfg = readConfig();
+  if (!cfg) {
+    logger_default.info(
+      `No configuration found at ${getConfigPath()}. Run "${cliName} config set" to create one.`
+    );
+    return;
+  }
+  logger_default.info(`Configuration at ${getConfigPath()}:`), logger_default.info(JSON.stringify(cfg, null, 2));
+}
+function runConfigClear() {
+  clearConfig(), logger_default.success(`Configuration removed (${getConfigPath()})`);
+}
+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_registerCommand = __esm({
+  "src/core/cliConfig/registerCommand.ts"() {
+    "use strict";
+    import_prompts = require("@inquirer/prompts");
+    init_logger();
+    init_manager();
+  }
+});
+
+// src/utils/withErrorHandling.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), printErrorHints(error2), process.exit(1);
+    }
+  };
+}
+function getErrorMessage2(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function printErrorHints(error2) {
+  if (error2 instanceof PackageManagerRuntimeError) {
+    error2.action && logger_default.info(`Action: ${error2.action}`), logger_default.info(`Run ${CLI_NAME2} doctor from the plugin directory for full local diagnostics.`);
+    return;
+  }
+  let message = getErrorMessage2(error2);
+  if (isCorepackKeyIdError(message)) {
+    logger_default.info(`Action: ${getPackageManagerRuntimeAction(message, "pnpm")}`);
+    return;
+  }
+  /\b(manifest\.json|manifest validation|package manager|corepack|pnpm|npm|build|dist)\b/i.test(
+    message
+  ) && logger_default.info(`Run ${CLI_NAME2} doctor from the plugin directory for local diagnostics.`);
+}
+var init_withErrorHandling = __esm({
+  "src/utils/withErrorHandling.ts"() {
+    "use strict";
+    init_meta2();
+    init_logger();
+    init_packageManager();
+  }
+});
+
+// src/core/pluginState/pluginStateManager.ts
+var import_fs9, import_promises2, STATE_FILE, load2, save2, update2, pluginStateManager, init_pluginStateManager = __esm({
+  "src/core/pluginState/pluginStateManager.ts"() {
+    "use strict";
+    import_fs9 = require("fs"), import_promises2 = require("fs/promises"), STATE_FILE = ".tracker-plugin", load2 = async () => {
+      if (!(0, import_fs9.existsSync)(STATE_FILE))
+        return {};
+      try {
+        let content = await (0, import_promises2.readFile)(STATE_FILE, "utf8");
+        return JSON.parse(content);
+      } catch {
+        return {};
+      }
+    }, save2 = async (state) => {
+      try {
+        let content = JSON.stringify(state, null, 4);
+        await (0, import_promises2.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/api/utils.ts
+function getIssueStatusLabel(issue) {
+  let { key: statusKey, display: statusDisplay } = issue.status;
+  return statusKey === "closed" && issue.resolution?.display ? issue.resolution.display : statusDisplay ?? statusKey;
+}
+function getIssueStatusCategory(issue) {
+  let statusKey = issue.status.key, resolutionKey = issue.resolution?.key;
+  if (statusKey === "closed")
+    return resolutionKey === "agreed" ? "approved" : resolutionKey === "rejected" || resolutionKey === "declined" ? "rejected" : "neutral";
+  switch (statusKey) {
+    case "waitingForApprove":
+    case "inProgress":
+      return "pending";
+    case "resultAcceptance":
+      return "acceptance";
+    case "testing":
+      return "testing";
+    case "need_info":
+      return "need_info";
+    default:
+      return "neutral";
+  }
+}
+var init_utils = __esm({
+  "src/api/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/pluginDisplay.ts
+function showTrackerPluginList(issues) {
+  if (!issues || issues.length === 0) {
+    console.info(import_picocolors2.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_picocolors2.default.magenta(slugMatch[1].trim()) : import_picocolors2.default.dim(issue.summary), statusBadge2 = getTrackerIssueBadge(issue);
+    console.info(
+      `  ${slug}  ${import_picocolors2.default.dim("\xB7")}  ${statusBadge2}  ${import_picocolors2.default.dim("\xB7")}  ${import_picocolors2.default.dim(issue.key)}`
+    ), logger_default.newLine();
+  });
+}
+function showTrackerPluginInfo(issue) {
+  printHeader("\u{1F4E6} Plugin"), logger_default.newLine(), printField("Issue key", import_picocolors2.default.cyan(issue.key)), printField("Status", getTrackerIssueBadge(issue)), printField("Summary", import_picocolors2.default.white(issue.summary)), issue.createdAt && printCreated(issue.createdAt), issue.updatedAt && printUpdated(issue.updatedAt);
+}
+var import_picocolors2, printHeader, getTrackerIssueBadge, formatDate, printField, printCreated, printUpdated, init_pluginDisplay = __esm({
+  "src/utils/pluginDisplay.ts"() {
+    "use strict";
+    import_picocolors2 = __toESM(require("picocolors"));
+    init_utils();
+    init_logger();
+    printHeader = (title) => {
+      console.info(import_picocolors2.default.bold(import_picocolors2.default.white(title)));
+    }, getTrackerIssueBadge = (issue) => {
+      let label = getIssueStatusLabel(issue);
+      switch (getIssueStatusCategory(issue)) {
+        case "approved":
+          return import_picocolors2.default.black(import_picocolors2.default.bgGreen(` ${label} `));
+        case "rejected":
+          return import_picocolors2.default.white(import_picocolors2.default.bgRed(` ${label} `));
+        case "pending":
+          return import_picocolors2.default.black(import_picocolors2.default.bgYellow(` ${label} `));
+        case "acceptance":
+          return import_picocolors2.default.black(import_picocolors2.default.bgCyan(` ${label} `));
+        case "testing":
+          return import_picocolors2.default.black(import_picocolors2.default.bgMagenta(` ${label} `));
+        case "need_info":
+          return import_picocolors2.default.black(import_picocolors2.default.bgBlue(` ${label} `));
+        default:
+          return import_picocolors2.default.black(import_picocolors2.default.bgWhite(` ${label} `));
+      }
+    }, 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_picocolors2.default.dim(label.padEnd(minWidth))} ${value}`);
+    }, printCreated = (createdAt) => {
+      printField("Created", import_picocolors2.default.white(formatDate(createdAt)));
+    }, printUpdated = (updatedAt) => {
+      printField("Updated", import_picocolors2.default.white(formatDate(updatedAt)));
+    };
+  }
+});
+
+// src/distributions/external/tracker.ts
+function buildIssueSummary(slug) {
+  return `Plugin: ${slug}`;
+}
+function buildIssueDescription(params) {
+  let { pluginId, slug, version, manifestJson } = params;
+  return [
+    `**Plugin UUID:** ${pluginId}`,
+    `**Slug:** ${slug}`,
+    `**Version:** ${version}`,
+    "",
+    "**Manifest:**",
+    "```json",
+    manifestJson,
+    "```"
+  ].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 externalTrackerApiRequest("/issues", {
+    method: "POST",
+    body
+  });
+}
+async function updatePluginIssue(issueKey, params) {
+  return externalTrackerApiRequest(`/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"
+  }), externalTrackerApiRequest(`/issues/${issueKey}/attachments`, {
+    method: "POST",
+    formData
+  });
+}
+async function getIssueTransitions(issueKey) {
+  return externalTrackerApiRequest(`/issues/${issueKey}/transitions`, {
+    method: "GET"
+  });
+}
+async function executeIssueTransition(issueKey, transitionId) {
+  await externalTrackerApiRequest(
+    `/issues/${issueKey}/transitions/${transitionId}/_execute`,
+    {
+      method: "POST",
+      body: {}
+    }
+  );
+}
+async function getIssue(issueKey) {
+  return externalTrackerApiRequest(`/issues/${issueKey}`, {
+    method: "GET"
+  });
+}
+async function addIssueComment(issueKey, text) {
+  await externalTrackerApiRequest(`/issues/${issueKey}/comments`, {
+    method: "POST",
+    body: { text }
+  });
+}
+async function getMyPluginIssues() {
+  return externalTrackerApiRequest("/issues/_search", {
+    method: "POST",
+    body: {
+      filter: {
+        queue: "PLUGINMOD",
+        createdBy: "me()"
+      }
+    }
+  });
+}
+var import_form_data, PLUGINMOD_QUEUE, init_tracker = __esm({
+  "src/distributions/external/tracker.ts"() {
+    "use strict";
+    import_form_data = __toESM(require("form-data"));
+    init_trackerApiRequest();
+    PLUGINMOD_QUEUE = "PLUGINMOD";
+  }
+});
+
+// src/distributions/external/info.ts
+async function infoExternal(issueKey) {
+  let targetIssueKey = issueKey;
+  if (targetIssueKey || (targetIssueKey = (await pluginStateManager.load()).trackerIssueKey), !targetIssueKey) {
+    logger_default.warning(
+      `No issue key provided and plugin has not been submitted yet. Run "${CLI_NAME} submit" first.`
+    ), logger_default.suggest(`${CLI_NAME} submit`);
+    return;
+  }
+  logger_default.info(`\u23F3 Fetching plugin info for ${targetIssueKey}...`);
+  try {
+    let issue = await getIssue(targetIssueKey);
+    showTrackerPluginInfo(issue);
+  } catch (error2) {
+    throw logger_default.error(`Failed to fetch plugin info for ${targetIssueKey}`), error2;
+  }
+}
+var init_info = __esm({
+  "src/distributions/external/info.ts"() {
+    "use strict";
+    init_pluginStateManager();
+    init_logger();
+    init_pluginDisplay();
+    init_meta();
+    init_tracker();
+  }
+});
+
+// src/distributions/external/list.ts
+async function listExternal() {
+  logger_default.info("\u23F3 Fetching my plugins from Tracker...");
+  try {
+    let issues = await getMyPluginIssues();
+    showTrackerPluginList(issues);
+  } catch (error2) {
+    throw logger_default.error("Failed to fetch plugins list"), error2;
+  }
+}
+var init_list = __esm({
+  "src/distributions/external/list.ts"() {
+    "use strict";
+    init_logger();
+    init_pluginDisplay();
+    init_tracker();
+  }
+});
+
+// src/distributions/external/login.ts
+async function loginExternal() {
+  console.info(
+    import_picocolors3.default.dim(
+      "To get an OAuth token for Yandex Tracker, please contact Tracker support and request one."
+    )
+  ), console.info("");
+  let trimmed = (await (0, import_prompts2.input)({
+    message: "Enter your OAuth token:",
+    required: !0
+  })).trim();
+  externalAuthManager.saveAuthData(trimmed), logger_default.success("OAuth token saved successfully."), logger_default.info('You can now use "weavix submit" to submit your plugin for review.');
+}
+function logoutExternal() {
+  if (!externalAuthManager.data) {
+    logger_default.warning("You are not logged in.");
+    return;
+  }
+  externalAuthManager.removeAuthData(), logger_default.success("Successfully logged out.");
+}
+var import_prompts2, import_picocolors3, init_login = __esm({
+  "src/distributions/external/login.ts"() {
+    "use strict";
+    import_prompts2 = require("@inquirer/prompts"), import_picocolors3 = __toESM(require("picocolors"));
+    init_logger();
+    init_authManager();
+  }
+});
+
+// src/utils/execCommand.ts
+var import_execa, execCommand, init_execCommand = __esm({
+  "src/utils/execCommand.ts"() {
+    "use strict";
+    import_execa = require("execa"), execCommand = async (command, cwd = process.cwd(), env) => {
+      await (0, import_execa.execa)(command, {
+        cwd,
+        shell: !0,
+        stdio: "inherit",
+        env: env ? { ...process.env, ...env } : void 0
+      });
+    };
+  }
+});
+
+// src/commands/constants/templateCommands.ts
+var pluginCmd, init_templateCommands = __esm({
+  "src/commands/constants/templateCommands.ts"() {
     "use strict";
-    import_fs4 = require("fs"), import_promises2 = require("fs/promises"), import_ajv = __toESM(require("ajv")), import_ajv_formats = __toESM(require("ajv-formats"));
-    init_manifestPermissionsSchema2();
-    init_formatValidationErrors();
-    init_manifest_schema();
-    validator = (() => {
-      let schema = {
-        ...manifest_schema_default,
-        properties: {
-          ...manifest_schema_default.properties,
-          permissions: {
-            ...manifest_schema_default.properties.permissions,
-            properties: {
-              ...manifest_schema_default.properties.permissions.properties,
-              ...permissionsSchemaExtensions2
-            }
-          }
-        }
-      }, ajv = new import_ajv.default({ allErrors: !0, strict: !1 });
-      return (0, import_ajv_formats.default)(ajv), ajv.compile(schema);
-    })(), manifestPath = "./manifest.json", parseManifest = (content) => {
-      let manifest;
-      try {
-        manifest = JSON.parse(content);
-      } catch (error2) {
-        throw error2 instanceof SyntaxError ? new Error(`File manifest.json contains invalid JSON: ${error2.message}`) : new Error(`Error reading manifest.json: ${error2.message}`);
-      }
-      return manifest;
-    }, loadRaw = async () => {
-      if (!(0, import_fs4.existsSync)(manifestPath))
-        throw new Error(`File manifest.json not found at path: ${manifestPath}`);
-      try {
-        return await (0, import_promises2.readFile)(manifestPath, "utf8");
-      } catch (error2) {
-        throw error2 instanceof Error ? new Error(`Error reading manifest.json: ${error2.message}`) : new Error("Error loading manifest");
-      }
-    }, load2 = async () => {
-      let manifestContent = await loadRaw();
-      return parseManifest(manifestContent);
-    }, validate = async () => {
-      let manifest = await load2();
-      if (!validator(manifest) && validator.errors) {
-        let errorMessages2 = formatValidationErrors(validator.errors);
-        throw new Error(
-          `\u274C Manifest validation failed:
-${errorMessages2}
+    pluginCmd = {
+      install: "npm install",
+      build: "npm run build",
+      dev: "npm run dev",
+      lint: "npm run lint",
+      typecheck: "npm run typecheck",
+      test: "npm test",
+      audit: "npm audit --audit-level=critical"
+    };
+  }
+});
 
-\u{1F4A1} Ensure all required fields are filled according to the plugin documentation.`
-        );
-      }
-    }, save2 = async (manifest) => {
-      try {
-        let content = JSON.stringify(manifest, null, 4);
-        await (0, import_promises2.writeFile)(manifestPath, content, "utf8");
-      } catch (error2) {
-        throw error2 instanceof Error ? new Error(`Error saving manifest.json: ${error2.message}`) : new Error("Error saving manifest");
-      }
-    }, update2 = async (updates) => {
-      let updatedManifest = { ...await load2(), ...updates };
-      return await save2(updatedManifest), updatedManifest;
-    }, manifestManager = {
-      load: load2,
-      loadRaw,
-      validate,
-      save: save2,
-      update: update2
+// src/commands/build.ts
+var build, init_build = __esm({
+  "src/commands/build.ts"() {
+    "use strict";
+    init_execCommand();
+    init_logger();
+    init_templateCommands();
+    build = async ({ environment = "production" } = {}) => {
+      logger_default.info("\u{1F528} Building project..."), await execCommand(pluginCmd.install), await execCommand(
+        pluginCmd.build,
+        process.cwd(),
+        environment ? { VITE_DEPLOY_ENV: environment } : void 0
+      );
     };
   }
 });
 
 // src/utils/marketplace.ts
 function validateMarketplaceAssets() {
-  let marketplaceDir = import_path3.default.resolve(MARKETPLACE_DIR);
+  let marketplaceDir = import_path9.default.resolve(MARKETPLACE_DIR);
   ensurePathExists(
     marketplaceDir,
     "Marketplace folder not found. Create ./marketplace and add index.md and header-image.jpg before publishing."
   ), ensurePathExists(
-    import_path3.default.join(marketplaceDir, MARKETPLACE_INDEX_FILE),
+    import_path9.default.join(marketplaceDir, MARKETPLACE_INDEX_FILE),
     "Marketplace description not found. Add ./marketplace/index.md before publishing."
   ), ensurePathExists(
-    import_path3.default.join(marketplaceDir, MARKETPLACE_HEADER_IMAGE_FILE),
+    import_path9.default.join(marketplaceDir, MARKETPLACE_HEADER_IMAGE_FILE),
     "Marketplace header image not found. Add ./marketplace/header-image.jpg before publishing."
   ), ensurePathExists(
-    import_path3.default.resolve(PUBLIC_DIR, PUBLIC_LOGO_FILE),
+    import_path9.default.resolve(PUBLIC_DIR, PUBLIC_LOGO_FILE),
     "Plugin logo not found. Add ./public/logo.svg before publishing."
   );
 }
 function validateArchiveSources() {
-  ensurePathExists(import_path3.default.resolve(DIST_DIR), "Dist folder not found. Build the project first."), ensurePathExists(
-    import_path3.default.resolve(SRC_DIR),
+  ensurePathExists(import_path9.default.resolve(DIST_DIR), "Dist folder not found. Build the project first."), ensurePathExists(
+    import_path9.default.resolve(SRC_DIR),
     "Source folder not found. Add ./src before publishing."
-  ), ensurePathExists(import_path3.default.resolve(MANIFEST_FILE), "manifest.json not found in plugin root."), validateMarketplaceAssets();
+  ), ensurePathExists(import_path9.default.resolve(MANIFEST_FILE2), "manifest.json not found in plugin root."), validateMarketplaceAssets();
 }
-var import_fs5, import_path3, MARKETPLACE_DIR, MARKETPLACE_INDEX_FILE, MARKETPLACE_HEADER_IMAGE_FILE, PUBLIC_DIR, PUBLIC_LOGO_FILE, MANIFEST_FILE, DIST_DIR, SRC_DIR, ensurePathExists, validateManifestPublishingFields, ensureManifestCatalogFields, marketplacePaths, init_marketplace = __esm({
+var import_fs10, import_path9, MARKETPLACE_DIR, MARKETPLACE_INDEX_FILE, MARKETPLACE_HEADER_IMAGE_FILE, PUBLIC_DIR, PUBLIC_LOGO_FILE, MANIFEST_FILE2, DIST_DIR, SRC_DIR, ensurePathExists, validateManifestPublishingFields, ensureManifestCatalogFields, marketplacePaths, init_marketplace = __esm({
   "src/utils/marketplace.ts"() {
     "use strict";
-    import_fs5 = __toESM(require("fs")), import_path3 = __toESM(require("path"));
+    import_fs10 = __toESM(require("fs")), import_path9 = __toESM(require("path"));
     init_manifestManager();
     init_logger();
-    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_fs5.default.existsSync(targetPath) || (logger_default.error(errorMessage), process.exit(1));
+    MARKETPLACE_DIR = "marketplace", MARKETPLACE_INDEX_FILE = "index.md", MARKETPLACE_HEADER_IMAGE_FILE = "header-image.jpg", PUBLIC_DIR = "public", PUBLIC_LOGO_FILE = "logo.svg", MANIFEST_FILE2 = "manifest.json", DIST_DIR = "dist", SRC_DIR = "src", ensurePathExists = (targetPath, errorMessage) => {
+      import_fs10.default.existsSync(targetPath) || (logger_default.error(errorMessage), process.exit(1));
     }, validateManifestPublishingFields = async () => {
       let manifest = await manifestManager.load();
       ensureManifestCatalogFields(manifest);
@@ -1480,23 +2858,23 @@ var import_fs5, import_path3, MARKETPLACE_DIR, MARKETPLACE_INDEX_FILE, MARKETPLA
       distDir: DIST_DIR,
       srcDir: SRC_DIR,
       marketplaceDir: MARKETPLACE_DIR,
-      manifestFile: MANIFEST_FILE
+      manifestFile: MANIFEST_FILE2
     };
   }
 });
 
 // src/utils/pluginPackageScripts.ts
 function readPluginPackageScripts(cwd = process.cwd()) {
-  let packageJsonPath = import_path4.default.join(cwd, "package.json");
-  return import_fs6.default.existsSync(packageJsonPath) ? JSON.parse(import_fs6.default.readFileSync(packageJsonPath, "utf-8")).scripts ?? {} : null;
+  let packageJsonPath = import_path10.default.join(cwd, "package.json");
+  return import_fs11.default.existsSync(packageJsonPath) ? JSON.parse(import_fs11.default.readFileSync(packageJsonPath, "utf-8")).scripts ?? {} : null;
 }
 function hasPluginScript(name, cwd = process.cwd()) {
   return !!readPluginPackageScripts(cwd)?.[name];
 }
-var import_fs6, import_path4, init_pluginPackageScripts = __esm({
+var import_fs11, import_path10, init_pluginPackageScripts = __esm({
   "src/utils/pluginPackageScripts.ts"() {
     "use strict";
-    import_fs6 = __toESM(require("fs")), import_path4 = __toESM(require("path"));
+    import_fs11 = __toESM(require("fs")), import_path10 = __toESM(require("path"));
   }
 });
 
@@ -1549,22 +2927,27 @@ async function buildArchive() {
       resolve2(buffer);
     }), archive.on("error", reject), archive.glob("**/*", {
       cwd: process.cwd(),
-      ignore: ["node_modules/**", "dist/**", "**/.DS_Store"],
-      dot: !0
-    }), archive.file(import_path5.default.resolve(marketplacePaths.manifestFile), { name: "src/manifest.json" }), archive.glob(
+      ignore: ["node_modules/**", "dist/**"],
+      dot: !1
+    });
+    for (let dotfile of [".npmrc", ".nvmrc"]) {
+      let dotfilePath = import_path11.default.resolve(dotfile);
+      import_fs12.default.existsSync(dotfilePath) && archive.file(dotfilePath, { name: dotfile });
+    }
+    archive.file(import_path11.default.resolve(marketplacePaths.manifestFile), { name: "src/manifest.json" }), archive.glob(
       "**/*",
       {
-        cwd: import_path5.default.resolve(marketplacePaths.distDir),
-        ignore: ["**/.DS_Store"]
+        cwd: import_path11.default.resolve(marketplacePaths.distDir),
+        dot: !1
       },
       { prefix: "dist/" }
     ), archive.finalize();
   });
 }
-var import_path5, import_archiver, init_buildArchive = __esm({
+var import_fs12, import_path11, import_archiver, init_buildArchive = __esm({
   "src/utils/buildArchive.ts"() {
     "use strict";
-    import_path5 = __toESM(require("path")), import_archiver = __toESM(require("archiver"));
+    import_fs12 = __toESM(require("fs")), import_path11 = __toESM(require("path")), import_archiver = __toESM(require("archiver"));
     init_manifestManager();
     init_meta2();
     init_logger();
@@ -1653,13 +3036,14 @@ function registerDistributionCommands(program) {
     withErrorHandling(async () => {
       logoutExternal();
     })
-  ), program.command("submit").description("build plugin, create a Tracker issue in PLUGINMOD, and submit for review").addOption(skipChecksOption).action(withErrorHandling(submitExternal)), program.command("list").description("list all your plugins and their moderation status").action(withErrorHandling(listExternal)), program.command("info [issue-key]").description(
+  ), program.command("submit").description("build plugin, create a Tracker issue in PLUGINMOD, and submit for review").addOption(skipChecksOption).action(withErrorHandling(submitExternal)), program.command("doctor").description("validate local plugin project, external config and auth").option("--network", "verify OAuth token with Tracker /myself", !1).option("--publish", "treat publish-readiness checks as failures", !1).option("--json", "machine-readable output", !1).action((options) => withErrorHandling(doctor)(options)), program.command("list").description("list all your plugins and their moderation status").action(withErrorHandling(listExternal)), program.command("info [issue-key]").description(
     "show moderation status of a plugin (uses .tracker-plugin issue key if not provided)"
   ).action(withErrorHandling(infoExternal));
 }
 var init_registerCommands = __esm({
   "src/distributions/external/registerCommands.ts"() {
     "use strict";
+    init_doctor();
     init_options();
     init_registerCommand();
     init_withErrorHandling();
@@ -1671,166 +3055,20 @@ var init_registerCommands = __esm({
   }
 });
 
-// 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
-});
-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;
-}
-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;
-}
-function getTrackerBaseUrl() {
-  return TRACKER_BASE_URL2;
-}
-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;
-}
-function getUpdateCheckInfo() {
-  return null;
-}
-var TRACKER_BASE_URL2, init_hosts = __esm({
-  "src/distributions/external/hosts.ts"() {
-    "use strict";
-    init_manager();
-    TRACKER_BASE_URL2 = "https://api.tracker.yandex.net/v3";
-  }
-});
-
-// src/distributions/external/templateSubstitution.ts
-var templateSubstitution_exports = {};
-__export(templateSubstitution_exports, {
-  applySubstitutions: () => applySubstitutions,
-  overlayDirName: () => overlayDirName,
-  templateDeps: () => templateDeps
-});
-function rewritePackageJson(content) {
-  let pkg = JSON.parse(content);
-  if (pkg.dependencies) {
-    let next = {};
-    for (let [name, version] of Object.entries(pkg.dependencies)) {
-      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 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_path6.default.basename(filePath), ext = import_path6.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 ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
-    let original = content.toString("utf8"), rewritten = rewriteImports(original);
-    if (rewritten !== original)
-      return Buffer.from(rewritten, "utf8");
-  }
-  return content;
-}
-var import_path6, PACKAGE_RENAME, ADDED_DEPS, templateDeps, overlayDirName, init_templateSubstitution = __esm({
-  "src/distributions/external/templateSubstitution.ts"() {
-    "use strict";
-    import_path6 = __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"
-    }, 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"], overlayDirName = "_external";
-  }
-});
-
 // src/index.ts
 var import_commander2 = require("commander");
 init_meta2();
 
 // src/distribution/registerCommands.ts
 init_flag();
-var impl3 = (init_registerCommands(), __toCommonJS(registerCommands_exports)), { registerDistributionCommands: registerDistributionCommands2 } = impl3;
+var impl4 = (init_registerCommands(), __toCommonJS(registerCommands_exports)), { registerDistributionCommands: registerDistributionCommands2 } = impl4;
 
 // src/utils/checkUpdate.ts
 var import_node_fetch2 = __toESM(require("node-fetch"));
 
 // src/distribution/hosts.ts
 init_flag();
-var impl4 = (init_hosts(), __toCommonJS(hosts_exports)), {
+var impl5 = (init_hosts(), __toCommonJS(hosts_exports)), {
   getS3Endpoint: getS3Endpoint2,
   getMdsEndpoint: getMdsEndpoint2,
   getS3Region: getS3Region2,
@@ -1840,7 +3078,7 @@ var impl4 = (init_hosts(), __toCommonJS(hosts_exports)), {
   getTrackerBaseUrl: getTrackerBaseUrl2,
   getOAuthTokenUrl: getOAuthTokenUrl2,
   getUpdateCheckInfo: getUpdateCheckInfo2
-} = impl4;
+} = impl5;
 
 // src/utils/checkUpdate.ts
 init_logger();
@@ -1877,131 +3115,33 @@ Run: ${installCmd}`);
     }
 };
 
+// src/utils/shouldRunUpdateCheck.ts
+function shouldRunUpdateCheck(argv) {
+  return !(argv.includes("doctor") && argv.includes("--json"));
+}
+
 // src/index.ts
 init_build();
 
 // src/commands/create/index.ts
-var path13 = __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",
-  "project.block",
-  "project.tab",
-  "portfolio.action",
-  "portfolio.block",
-  "portfolio.tab",
-  "goal.action",
-  "goal.block",
-  "goal.tab",
-  "attachment.viewer.action",
-  "board.tab"
-];
-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"],
-  "project.block": ["project.block"],
-  "project.tab": ["project.tab"],
-  "portfolio.action": ["portfolio.action"],
-  "portfolio.block": ["portfolio.block"],
-  "portfolio.tab": ["portfolio.tab"],
-  "goal.action": ["goal.action"],
-  "goal.block": ["goal.block"],
-  "goal.tab": ["goal.tab"],
-  "attachment.viewer.action": ["attachment.viewer.action"],
-  "board.tab": ["board.tab"]
-};
-
-// src/commands/create/index.ts
+var path18 = __toESM(require("path")), import_prompts3 = require("@inquirer/prompts");
+init_constants();
 init_meta2();
 init_logger();
 
+// src/commands/create/templateChoices.ts
+init_constants();
+var DEFERRED_TEMPLATE_REASON = "will be added later", DEFERRED_TEMPLATES = /* @__PURE__ */ new Set(["user-card-info", "user-card-calendar"]);
+function getTemplateChoices(service) {
+  return TEMPLATES.filter((templateName) => TEMPLATE_SERVICE[templateName] === service).map(
+    (templateName) => ({
+      name: templateName,
+      value: templateName,
+      disabled: DEFERRED_TEMPLATES.has(templateName) ? DEFERRED_TEMPLATE_REASON : void 0
+    })
+  );
+}
+
 // src/commands/create/utils/getWelcomeMessage.ts
 var import_picocolors5 = __toESM(require("picocolors")), getWelcomeMessage = (pwd) => `
 ${import_picocolors5.default.bold(import_picocolors5.default.white("\u{1F680} Create new tracker plugin"))}
@@ -2012,25 +3152,27 @@ ${import_picocolors5.default.dim("Press")} ${import_picocolors5.default.yellow("
 `;
 
 // src/commands/create/utils/initManifest.ts
-var fs5 = __toESM(require("fs")), path7 = __toESM(require("path"));
+var fs11 = __toESM(require("fs")), path13 = __toESM(require("path"));
 
 // src/commands/create/utils/generateManifest.ts
+init_constants();
+var FULL_CONTEXT_TEMPLATES = /* @__PURE__ */ new Set(["user-card-info", "user-card-calendar"]);
 function buildSlots(template, slotTitle) {
   let slotNames = TEMPLATE_SLOTS[template];
   if (slotNames.length === 0) return;
-  let slotEntry = {
+  let service = TEMPLATE_SERVICE[template], contextLevel = FULL_CONTEXT_TEMPLATES.has(template) ? "full" : "basic", slotEntry = {
     entrypoint: "index.html",
     title: { ru: slotTitle, en: slotTitle },
-    contextLevel: "basic"
+    contextLevel
   };
   return {
-    tracker: Object.fromEntries(slotNames.map((slotName) => [slotName, [slotEntry]]))
+    [service]: Object.fromEntries(slotNames.map((slotName) => [slotName, [slotEntry]]))
   };
 }
 var generateManifest = (answers) => ({
   $schema: "./manifest.schema.json",
   manifest_version: 1,
-  supported_services: ["tracker"],
+  supported_services: [TEMPLATE_SERVICE[answers.template]],
   slug: answers.packageSlug,
   version: answers.version,
   name: {
@@ -2048,55 +3190,58 @@ var generateManifest = (answers) => ({
 
 // src/commands/create/utils/initManifest.ts
 var initManifest = ({ answers, targetDir }) => {
-  let generatedManifest = generateManifest(answers), manifestPath2 = path7.join(targetDir, "manifest.json");
-  fs5.writeFileSync(manifestPath2, JSON.stringify(generatedManifest, null, 2), "utf-8");
+  let generatedManifest = generateManifest(answers), manifestPath = path13.join(targetDir, "manifest.json");
+  fs11.writeFileSync(manifestPath, JSON.stringify(generatedManifest, null, 2), "utf-8");
 };
 
 // src/commands/create/utils/initTemplate.ts
-var fs8 = __toESM(require("fs")), path12 = __toESM(require("path"));
+var fs14 = __toESM(require("fs")), path17 = __toESM(require("path"));
 
 // src/distribution/templateSubstitution.ts
 init_flag();
-var impl5 = (init_templateSubstitution(), __toCommonJS(templateSubstitution_exports)), { applySubstitutions: applySubstitutions2, overlayDirName: overlayDirName2, templateDeps: templateDeps2 } = impl5;
+var isInternal = !1, templateDeps = [
+  "@weavix/tracker-plugin-sdk",
+  "@weavix/tracker-plugin-sdk-react",
+  "@weavix/tracker-api-types"
+], overlayDirName = isInternal ? "_internal" : "_external";
 
 // src/utils/copyDirectory.ts
-var fs6 = __toESM(require("fs")), import_path7 = __toESM(require("path")), import_tinyglobby = require("tinyglobby");
-var resolveTargetFileName = (file) => file.endsWith(".template") ? "." + file.replace(".template", "") : file, copyDirectory = async (sourceDir, targetDir) => {
-  let files = await (0, import_tinyglobby.glob)(["**/*"], {
+var fs12 = __toESM(require("fs")), import_path12 = __toESM(require("path")), import_tinyglobby2 = require("tinyglobby"), resolveTargetFileName = (file) => file.endsWith(".template") ? "." + file.replace(".template", "") : file, copyDirectory = async (sourceDir, targetDir) => {
+  let files = await (0, import_tinyglobby2.glob)(["**/*"], {
     cwd: sourceDir,
     onlyFiles: !0,
     dot: !0
   });
   await Promise.all(
     files.map(async (file) => {
-      let sourcePath = import_path7.default.join(sourceDir, file), targetFile = resolveTargetFileName(file), targetPath = import_path7.default.join(targetDir, targetFile);
-      await fs6.promises.mkdir(import_path7.default.dirname(targetPath), { recursive: !0 });
-      let content = await fs6.promises.readFile(sourcePath), rewritten = applySubstitutions2(file, content);
-      await fs6.promises.writeFile(targetPath, rewritten);
+      let sourcePath = import_path12.default.join(sourceDir, file), targetFile = resolveTargetFileName(file), targetPath = import_path12.default.join(targetDir, targetFile);
+      await fs12.promises.mkdir(import_path12.default.dirname(targetPath), { recursive: !0 });
+      let content = await fs12.promises.readFile(sourcePath);
+      await fs12.promises.writeFile(targetPath, content);
     })
   );
 };
 
 // src/utils/getProjectPath.ts
-var import_path8 = __toESM(require("path")), isDevelopment = () => __dirname.includes("/src/"), getProjectPath = (relativePath) => isDevelopment() ? import_path8.default.resolve(__dirname, "..", "..", relativePath) : import_path8.default.resolve(__dirname, relativePath), getTemplatesBaseDir = () => getProjectPath("templates"), getTemplatePath = (filename) => import_path8.default.join(getTemplatesBaseDir(), "_shared", filename);
+var import_path13 = __toESM(require("path")), isDevelopment = () => __dirname.includes("/src/"), getProjectPath = (relativePath) => isDevelopment() ? import_path13.default.resolve(__dirname, "..", "..", relativePath) : import_path13.default.resolve(__dirname, relativePath), getTemplatesBaseDir = () => getProjectPath("templates"), getTemplatePath = (filename) => import_path13.default.join(getTemplatesBaseDir(), "_shared", filename), getOverlayTemplatePath = (overlayDir, filename) => import_path13.default.join(getTemplatesBaseDir(), overlayDir, filename);
 
 // src/commands/create/utils/initTemplate.ts
 init_logger();
 
 // src/commands/create/utils/updatePackageJson.ts
-var fs7 = __toESM(require("fs")), path11 = __toESM(require("path")), updatePackageJson = (targetDir, packageSlug) => {
-  let packageJsonPath = path11.join(targetDir, "package.json");
-  if (fs7.existsSync(packageJsonPath)) {
-    let packageJson = JSON.parse(fs7.readFileSync(packageJsonPath, "utf-8"));
-    packageJson.name = packageSlug, fs7.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
+var fs13 = __toESM(require("fs")), path16 = __toESM(require("path")), updatePackageJson = (targetDir, packageSlug) => {
+  let packageJsonPath = path16.join(targetDir, "package.json");
+  if (fs13.existsSync(packageJsonPath)) {
+    let packageJson = JSON.parse(fs13.readFileSync(packageJsonPath, "utf-8"));
+    packageJson.name = packageSlug, fs13.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
 `);
   }
 };
 
 // src/commands/create/utils/initTemplate.ts
 var initTemplate = async ({ answers, targetDir }) => {
-  fs8.existsSync(targetDir) || fs8.mkdirSync(targetDir, { recursive: !0 });
-  let templatesBaseDir = getTemplatesBaseDir(), templatesDir = path12.join(templatesBaseDir, answers.template), sharedDir = path12.join(templatesBaseDir, "_shared"), overlayDir = path12.join(templatesBaseDir, overlayDirName2);
+  fs14.existsSync(targetDir) || fs14.mkdirSync(targetDir, { recursive: !0 });
+  let templatesBaseDir = getTemplatesBaseDir(), templatesDir = path17.join(templatesBaseDir, answers.template), sharedDir = path17.join(templatesBaseDir, "_shared"), overlayDir = path17.join(templatesBaseDir, overlayDirName);
   await copyDirectory(sharedDir, targetDir), await copyDirectory(overlayDir, 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)."
   );
@@ -2119,12 +3264,23 @@ async function create() {
     message: "Enter support email:",
     required: !0,
     validate: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) || "Please enter a valid email address"
-  }), template = await (0, import_prompts3.select)({
-    message: "Select a template:",
-    choices: TEMPLATES.map((templateName) => ({
-      name: templateName,
-      value: templateName
+  }), service = CREATE_SERVICES2.length === 1 ? CREATE_SERVICES2[0] : await (0, import_prompts3.select)({
+    message: "Select a service:",
+    choices: CREATE_SERVICES2.map((serviceName) => ({
+      name: serviceName,
+      value: serviceName
     }))
+  }), templateChoices = getTemplateChoices(service);
+  if (templateChoices.every((choice) => choice.disabled)) {
+    logger_default.warning(`No selectable templates are available for ${service} yet.`), logger_default.info(
+      templateChoices.map((choice) => `- ${choice.name} ${choice.disabled ?? ""}`.trim()).join(`
+`)
+    );
+    return;
+  }
+  let template = await (0, import_prompts3.select)({
+    message: "Select a template:",
+    choices: templateChoices
   }), dataPermissions = await (0, import_prompts3.checkbox)({
     message: "Select data permissions (some popular options):",
     choices: TOP_DATA_PERMISSIONS.map((permission) => ({
@@ -2137,25 +3293,26 @@ async function create() {
     pluginName,
     pluginDescription,
     supportEmail,
+    service,
     template,
     permissions: {
       data: dataPermissions
     },
     version: DEFAULT_VERSION
-  }, targetDir = path13.join(process.cwd(), answers.packageSlug);
+  }, targetDir = path18.join(process.cwd(), answers.packageSlug);
   await initTemplate({
     answers,
     targetDir
   }), initManifest({
     answers,
     targetDir
-  }), logger_default.newLine(), logger_default.success("\u2705 Plugin created successfully!"), logger_default.newLine(), logger_default.info("\u{1F680} To start development:"), logger_default.commands("", [`cd ${answers.packageSlug}`, "npm install", `${CLI_NAME2} debug`]), logger_default.newLine(), logger_default.info(
-    "\u{1F4CC} Important: After running debug, the plugin will be available in the Tracker interface,"
-  ), logger_default.info("not at localhost. Open Tracker and check the plugin in the appropriate context.");
+  }), logger_default.newLine(), logger_default.success("\u2705 Plugin created successfully!"), logger_default.info("\u{1F680} To start development:"), logger_default.commands("", [`cd ${answers.packageSlug}`, "npm install", `${CLI_NAME2} debug`]), logger_default.info(
+    "\u{1F4CC} Important: After running debug, the plugin will be available in the Tracker interface, not at localhost. Open Tracker and check the plugin in the appropriate context."
+  );
 }
 
 // src/commands/debug/index.ts
-var import_fs10 = __toESM(require("fs")), import_path12 = __toESM(require("path"));
+var import_fs16 = __toESM(require("fs")), import_path17 = __toESM(require("path"));
 init_manifestManager();
 
 // src/core/s3config/constants.ts
@@ -2179,7 +3336,7 @@ var registerCleanup = (cleanup) => {
 init_templateCommands();
 
 // src/commands/debug/utils/createDebugConfig.ts
-var import_fs7 = __toESM(require("fs")), import_path9 = __toESM(require("path"));
+var import_fs13 = __toESM(require("fs")), import_path14 = __toESM(require("path"));
 init_manifestManager();
 
 // src/utils/convertManifestToConfig.ts
@@ -2226,21 +3383,21 @@ var convertManifestToConfig = (manifest, environment) => {
 
 // src/commands/debug/utils/createDebugConfig.ts
 var createDebugConfig = async () => {
-  let manifest = await manifestManager.load(), config = convertManifestToConfig(manifest, "debug"), configPath = import_path9.default.join(process.cwd(), CONFIG_FILE_NAME);
-  import_fs7.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  let manifest = await manifestManager.load(), config = convertManifestToConfig(manifest, "debug"), configPath = import_path14.default.join(process.cwd(), CONFIG_FILE_NAME);
+  import_fs13.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
 };
 
 // src/commands/debug/utils/lockFile.ts
-var import_fs8 = __toESM(require("fs")), import_path10 = __toESM(require("path")), LOCK_FILE_NAME = ".tracker-cli-debug.lock", getLockFilePath = () => import_path10.default.join(process.cwd(), LOCK_FILE_NAME), getRunningDebugPid = () => {
+var import_fs14 = __toESM(require("fs")), import_path15 = __toESM(require("path")), LOCK_FILE_NAME = ".yaweavix-debug.lock", getLockFilePath = () => import_path15.default.join(process.cwd(), LOCK_FILE_NAME), getRunningDebugPid = () => {
   let lockPath = getLockFilePath();
-  if (!import_fs8.default.existsSync(lockPath))
+  if (!import_fs14.default.existsSync(lockPath))
     return null;
   try {
-    let pid = JSON.parse(import_fs8.default.readFileSync(lockPath, "utf-8")).pid;
+    let pid = JSON.parse(import_fs14.default.readFileSync(lockPath, "utf-8")).pid;
     return process.kill(pid, 0), pid;
   } catch {
     try {
-      import_fs8.default.unlinkSync(lockPath);
+      import_fs14.default.unlinkSync(lockPath);
     } catch {
     }
     return null;
@@ -2248,19 +3405,19 @@ var import_fs8 = __toESM(require("fs")), import_path10 = __toESM(require("path")
 }, createLockFile = () => {
   let lockPath = getLockFilePath(), lockData = {
     pid: process.pid
-  }, fd = import_fs8.default.openSync(lockPath, "wx");
-  import_fs8.default.writeSync(fd, JSON.stringify(lockData, null, 2)), import_fs8.default.closeSync(fd);
+  }, fd = import_fs14.default.openSync(lockPath, "wx");
+  import_fs14.default.writeSync(fd, JSON.stringify(lockData, null, 2)), import_fs14.default.closeSync(fd);
 }, removeLockFile = () => {
   let lockPath = getLockFilePath();
-  import_fs8.default.existsSync(lockPath) && import_fs8.default.unlinkSync(lockPath);
+  import_fs14.default.existsSync(lockPath) && import_fs14.default.unlinkSync(lockPath);
 };
 
 // src/commands/debug/utils/watchManifest.ts
-var import_fs9 = __toESM(require("fs")), import_path11 = __toESM(require("path"));
+var import_fs15 = __toESM(require("fs")), import_path16 = __toESM(require("path"));
 init_manifestManager();
 init_logger();
 var watchManifest = () => {
-  let manifestPath2 = import_path11.default.join(process.cwd(), "manifest.json"), debounceTimer = null, watcher = import_fs9.default.watch(manifestPath2, async (eventType) => {
+  let manifestPath = import_path16.default.join(process.cwd(), "manifest.json"), debounceTimer = null, watcher = import_fs15.default.watch(manifestPath, 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");
@@ -2284,10 +3441,10 @@ 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_path12.default.join(process.cwd(), CONFIG_FILE_NAME);
+  let configPath = import_path17.default.join(process.cwd(), CONFIG_FILE_NAME);
   options.lint && await manifestManager.validate(), await createDebugConfig();
   let watcher = watchManifest(), cleanup = () => {
-    watcher.close(), import_fs10.default.existsSync(configPath) && import_fs10.default.unlinkSync(configPath), removeLockFile();
+    watcher.close(), import_fs16.default.existsSync(configPath) && import_fs16.default.unlinkSync(configPath), removeLockFile();
   };
   registerCleanup(cleanup), createLockFile(), logger_default.newLine(), logger_default.info("\u{1F527} Debug mode started!"), logger_default.newLine(), logger_default.info("\u{1F4CC} The plugin is now available in the Tracker interface."), logger_default.info("Open Tracker and check the plugin functionality in the appropriate context."), logger_default.newLine(), logger_default.info("\u26A0\uFE0F  Do not try to open localhost in the browser - the plugin works"), logger_default.info("only inside Tracker through a special loading mechanism."), logger_default.newLine(), logger_default.info("\u{1F504} Code changes will be automatically reloaded."), logger_default.info("Press Ctrl+C to stop."), logger_default.newLine(), await execCommand(pluginCmd.dev), cleanup();
 }
@@ -2301,19 +3458,23 @@ 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/up/index.ts
+var import_fs19 = require("fs"), import_promises5 = require("fs/promises");
+init_execCommand();
+
 // src/commands/up/utils/copyTemplateFiles.ts
-var import_fs11 = require("fs"), import_promises3 = require("fs/promises");
-var copyTemplateFiles = async (filenames) => {
+var import_fs17 = require("fs"), import_promises3 = require("fs/promises"), import_path18 = __toESM(require("path"));
+var copyTemplateFiles = async (files) => {
   await Promise.all(
-    filenames.map(async (filename) => {
-      let templatePath = getTemplatePath(filename), targetPath = `./${filename}`;
-      if ((0, import_fs11.existsSync)(templatePath) && (0, import_fs11.existsSync)(targetPath)) {
-        let content = await (0, import_promises3.readFile)(templatePath), rewritten = applySubstitutions2(filename, content);
-        await (0, import_promises3.writeFile)(targetPath, rewritten);
-      }
+    files.map(async (file) => {
+      let templatePath, targetPath, force = !1;
+      typeof file == "string" ? (templatePath = getTemplatePath(file), targetPath = `./${file}`) : (templatePath = file.sourcePath ?? getTemplatePath(file.source ?? file.target), targetPath = `./${file.target}`, force = file.force ?? !1), (0, import_fs17.existsSync)(templatePath) && (force || (0, import_fs17.existsSync)(targetPath)) && (await (0, import_promises3.mkdir)(import_path18.default.dirname(targetPath), { recursive: !0 }), await (0, import_promises3.copyFile)(templatePath, targetPath));
     })
   );
-};
+}, overlayFileCopy = (overlayDir, sourceFilename, targetFilename) => ({
+  sourcePath: getOverlayTemplatePath(overlayDir, sourceFilename),
+  target: targetFilename
+});
 
 // src/commands/up/utils/updateManifestCompatibility.ts
 init_manifestManager();
@@ -2337,15 +3498,12 @@ async function updateManifestCompatibility() {
 }
 
 // src/commands/up/utils/updatePackageDependencies.ts
-var import_fs12 = require("fs"), import_promises4 = require("fs/promises");
+var import_fs18 = require("fs"), import_promises4 = 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_fs18.existsSync)(packageJsonPath) || !(0, import_fs18.existsSync)(templatePackageJsonPath))
     return;
-  let packageJsonContent = await (0, import_promises4.readFile)(packageJsonPath, "utf-8"), templatePackageJsonRaw = await (0, import_promises4.readFile)(templatePackageJsonPath), templatePackageJsonContent = applySubstitutions2(
-    "package.json",
-    templatePackageJsonRaw
-  ).toString("utf8"), packageJson = JSON.parse(packageJsonContent), templatePackageJson = JSON.parse(templatePackageJsonContent), updated = !1;
+  let packageJsonContent = await (0, import_promises4.readFile)(packageJsonPath, "utf-8"), templatePackageJsonContent = await (0, import_promises4.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_promises4.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
@@ -2353,18 +3511,36 @@ var updatePackageDependencies = async (dependencies) => {
 };
 
 // src/commands/up/index.ts
-var templateFiles = ["manifest.schema.json", "vite.config.ts"];
+var npmrcPath = "./.npmrc", npmrcTemplateFilename = "npmrc.template", sharedFiles = [
+  "manifest.schema.json",
+  "vite.config.ts",
+  { source: "proxy.ts", target: "proxy.ts", force: !0 }
+];
+async function isNpmrcOutdated() {
+  let templatePath = getOverlayTemplatePath(overlayDirName, npmrcTemplateFilename);
+  if (!(0, import_fs19.existsSync)(npmrcPath) || !(0, import_fs19.existsSync)(templatePath))
+    return !1;
+  let [currentNpmrc, templateNpmrc] = await Promise.all([
+    (0, import_promises5.readFile)(npmrcPath, "utf-8"),
+    (0, import_promises5.readFile)(templatePath, "utf-8")
+  ]);
+  return currentNpmrc !== templateNpmrc;
+}
 async function up() {
-  await copyTemplateFiles(templateFiles), await updateManifestCompatibility(), await updatePackageDependencies(templateDeps2);
+  let shouldCleanNpmCache = await isNpmrcOutdated();
+  await copyTemplateFiles([
+    ...sharedFiles,
+    { ...overlayFileCopy(overlayDirName, npmrcTemplateFilename, ".npmrc"), force: !0 }
+  ]), await updateManifestCompatibility(), await updatePackageDependencies(templateDeps), shouldCleanNpmCache && await execCommand("npm cache clean --force"), await execCommand("npm i");
 }
 
 // src/utils/getVersion.ts
-var import_fs13 = require("fs"), import_path13 = require("path"), UNKNOWN_VERSION = "unknown", CANDIDATES = ["..", "../.."], findVersionInPackageJson = (startDir) => {
+var import_fs20 = require("fs"), import_path19 = require("path"), UNKNOWN_VERSION = "unknown", CANDIDATES = ["..", "../.."], findVersionInPackageJson = (startDir) => {
   for (let rel of CANDIDATES) {
-    let path18 = (0, import_path13.resolve)(startDir, rel, "package.json");
-    if ((0, import_fs13.existsSync)(path18))
+    let path24 = (0, import_path19.resolve)(startDir, rel, "package.json");
+    if ((0, import_fs20.existsSync)(path24))
       try {
-        let pkg = JSON.parse((0, import_fs13.readFileSync)(path18, "utf-8"));
+        let pkg = JSON.parse((0, import_fs20.readFileSync)(path24, "utf-8"));
         if (typeof pkg.version == "string") return pkg.version;
       } catch {
       }
@@ -2377,10 +3553,10 @@ init_verbose();
 init_withErrorHandling();
 async function main() {
   let program = new import_commander2.Command(), version = getVersion();
-  await checkUpdate(version), program.name(CLI_NAME2).description(CLI_DESCRIPTION2).version(version).option("--verbose", "enable verbose output"), CLI_HELP_TEXT2 && program.addHelpText("before", CLI_HELP_TEXT2), program.hook("preAction", (thisCommand) => {
+  shouldRunUpdateCheck(process.argv.slice(2)) && await checkUpdate(version), program.name(CLI_NAME2).description(CLI_DESCRIPTION2).version(version).option("--verbose", "enable verbose output"), 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) => withErrorHandling(debug)(options)), program.command("lint").description("run TypeScript and ESLint checks").action(withErrorHandling(lint)), 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(typeof process.exitCode == "number" ? process.exitCode : 0);
 }
 main();