@weavix/cli 0.3.0 → 0.5.0

package/build/index.js

@@ -26,6 +26,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 )), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 
+// src/distribution/flag.ts
+var init_flag = __esm({
+  "src/distribution/flag.ts"() {
+    "use strict";
+  }
+});
+
 // src/distributions/external/meta.ts
 var meta_exports = {};
 __export(meta_exports, {
@@ -40,6 +47,26 @@ var CLI_NAME, CLI_DESCRIPTION, CLI_HELP_TEXT, init_meta = __esm({
   }
 });
 
+// src/distribution/meta.ts
+var impl, CLI_NAME2, CLI_DESCRIPTION2, CLI_HELP_TEXT2, 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;
@@ -47,10 +74,14 @@ function setVerboseEnabled(value) {
 function isVerboseEnabled() {
   return verboseEnabled;
 }
-var verboseEnabled, init_verbose = __esm({
+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";
-    verboseEnabled = !1;
+    import_fs = __toESM(require("fs")), import_path = __toESM(require("path")), verboseEnabled = !1;
   }
 });
 
@@ -112,25 +143,25 @@ function getConfigPath() {
 function readConfig() {
   if (cached !== void 0)
     return cached;
-  if (!(0, import_fs.existsSync)(CONFIG_FILE))
+  if (!(0, import_fs2.existsSync)(CONFIG_FILE))
     return cached = null, cached;
   try {
-    cached = JSON.parse((0, import_fs.readFileSync)(CONFIG_FILE, "utf-8"));
+    cached = JSON.parse((0, import_fs2.readFileSync)(CONFIG_FILE, "utf-8"));
   } catch {
     cached = null;
   }
   return cached;
 }
 function writeConfig(config) {
-  (0, import_fs.existsSync)(CONFIG_DIR) || (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: !0, mode: 448 }), (0, import_fs.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 }), cached = config;
+  (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;
 }
 function clearConfig() {
-  (0, import_fs.existsSync)(CONFIG_FILE) && (0, import_fs.rmSync)(CONFIG_FILE), cached = null;
+  (0, import_fs2.existsSync)(CONFIG_FILE) && (0, import_fs2.rmSync)(CONFIG_FILE), cached = null;
 }
-var import_fs, os, import_path, CONFIG_DIR, CONFIG_FILE, cached, init_manager = __esm({
+var import_fs2, os, import_path2, CONFIG_DIR, CONFIG_FILE, cached, init_manager = __esm({
   "src/core/cliConfig/manager.ts"() {
     "use strict";
-    import_fs = require("fs"), os = __toESM(require("os")), import_path = __toESM(require("path")), CONFIG_DIR = import_path.default.join(os.homedir(), ".tracker-cli"), CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
+    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");
   }
 });
 
@@ -197,19 +228,1446 @@ var import_prompts, init_registerCommand = __esm({
   }
 });
 
+// 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);
+    }
+  };
+}
+var init_withErrorHandling = __esm({
+  "src/utils/withErrorHandling.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/core/pluginState/pluginStateManager.ts
+var import_fs3, import_promises, STATE_FILE, load, save, update, pluginStateManager, init_pluginStateManager = __esm({
+  "src/core/pluginState/pluginStateManager.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 {};
+      try {
+        let content = await (0, import_promises.readFile)(STATE_FILE, "utf8");
+        return JSON.parse(content);
+      } catch {
+        return {};
+      }
+    }, save = async (state) => {
+      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}`);
+      }
+    }, update = async (updates) => {
+      let updated = { ...await load(), ...updates };
+      return await save(updated), updated;
+    }, pluginStateManager = {
+      load,
+      save,
+      update
+    };
+  }
+});
+
+// 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), 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();
+  });
+}
+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/authManager.ts
+var fs2, os2, path3, authDir, authFile, getData, getToken, saveAuthData, removeAuthData, externalAuthManager, init_authManager = __esm({
+  "src/distributions/external/authManager.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
+    };
+  }
+});
+
+// src/distributions/external/trackerApiRequest.ts
+function buildQueryString(queryParams) {
+  if (!queryParams || Object.keys(queryParams).length === 0)
+    return "";
+  let params = new URLSearchParams();
+  return Object.entries(queryParams).forEach(([key, value]) => {
+    params.append(key, String(value));
+  }), `?${params.toString()}`;
+}
+async function parseResponse(response) {
+  return response.status === 204 || response.headers.get("content-length") === "0" ? void 0 : response.headers.get("content-type")?.includes("application/json") ? await response.json() : await response.text();
+}
+async function externalTrackerApiRequest(endpoint, options = {}) {
+  let { method = "GET", body, headers = {}, formData, queryParams } = options, token = externalAuthManager.token;
+  if (!token)
+    throw new Error(`Not authenticated. Run "${CLI_NAME} login" first.`);
+  let requestHeaders = {
+    Authorization: `OAuth ${token}`,
+    "X-Org-ID": ORG_ID,
+    Accept: "application/json",
+    ...headers
+  }, requestBody;
+  if (formData) {
+    let formHeaders = formData.getHeaders?.();
+    Object.assign(requestHeaders, formHeaders), requestBody = formData;
+  } else body && method !== "GET" && (requestHeaders["Content-Type"] = "application/json", requestBody = JSON.stringify(body));
+  let queryString = buildQueryString(queryParams), url = `${TRACKER_BASE_URL}${endpoint}${queryString}`, response = await (0, import_node_fetch.default)(url, {
+    method,
+    headers: requestHeaders,
+    body: requestBody
+  });
+  if (!response.ok) {
+    let errorText = await response.text(), errorMessage = `Tracker API error ${response.status}: ${errorText}`;
+    try {
+      let errorJson = JSON.parse(errorText);
+      errorJson.message && (errorMessage = `Tracker API error ${response.status}: ${errorJson.message}`);
+    } catch {
+    }
+    throw new Error(errorMessage);
+  }
+  return parseResponse(response);
+}
+var import_node_fetch, TRACKER_BASE_URL, 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";
+  }
+});
+
+// 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";
+    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"() {
+    "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/distributions/external/manifestPermissionsSchema.ts
+var manifestPermissionsSchema_exports = {};
+__export(manifestPermissionsSchema_exports, {
+  permissionsSchemaExtensions: () => permissionsSchemaExtensions
+});
+var permissionsSchemaExtensions, init_manifestPermissionsSchema = __esm({
+  "src/distributions/external/manifestPermissionsSchema.ts"() {
+    "use strict";
+    permissionsSchemaExtensions = {};
+  }
+});
+
+// src/distribution/manifestPermissionsSchema.ts
+var impl2, permissionsSchemaExtensions2, init_manifestPermissionsSchema2 = __esm({
+  "src/distribution/manifestPermissionsSchema.ts"() {
+    "use strict";
+    init_flag();
+    impl2 = (init_manifestPermissionsSchema(), __toCommonJS(manifestPermissionsSchema_exports)), { permissionsSchemaExtensions: permissionsSchemaExtensions2 } = impl2;
+  }
+});
+
+// src/core/manifest/formatValidationErrors.ts
+var priorityOrder, errorMessages, getPriority, formatValidationErrors, init_formatValidationErrors = __esm({
+  "src/core/manifest/formatValidationErrors.ts"() {
+    "use strict";
+    priorityOrder = [
+      "required",
+      "type",
+      "minLength",
+      "format",
+      "pattern",
+      "enum",
+      "additionalProperties",
+      "uniqueItems"
+    ], errorMessages = {
+      required: (params) => `missing required property '${params.missingProperty}'`,
+      type: (params) => `must be ${params.type}`,
+      enum: (params) => `must be one of [${params.allowedValues.join(", ")}]`,
+      pattern: (params) => `must match pattern ${params.pattern}`,
+      format: (params) => `must be a valid ${params.format}`,
+      minLength: () => "must not be empty",
+      additionalProperties: (params) => `unexpected property '${params.additionalProperty}'`,
+      uniqueItems: () => "must contain unique items"
+    }, getPriority = (keyword) => {
+      let index = priorityOrder.indexOf(keyword);
+      return index === -1 ? priorityOrder.length : index;
+    }, formatValidationErrors = (errors) => {
+      let errorsByPath = {};
+      for (let error2 of errors) {
+        let path18 = error2.instancePath || "root";
+        errorsByPath[path18] || (errorsByPath[path18] = []), errorsByPath[path18].push(error2);
+      }
+      return Object.entries(errorsByPath).map(([path18, pathErrors]) => {
+        let error2 = [...pathErrors].sort(
+          (a, b) => getPriority(a.keyword) - getPriority(b.keyword)
+        )[0], formatter = errorMessages[error2.keyword], message = formatter ? formatter(error2.params) : error2.message;
+        return `  - ${path18}: ${message}`;
+      }).join(`
+`);
+    };
+  }
+});
+
+// src/core/manifest/manifest.schema.json
+var manifest_schema_default, init_manifest_schema = __esm({
+  "src/core/manifest/manifest.schema.json"() {
+    manifest_schema_default = {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      title: "Manifest",
+      description: "Schema for validating plugin manifest",
+      type: "object",
+      required: [
+        "slug",
+        "version",
+        "permissions",
+        "name",
+        "description",
+        "support"
+      ],
+      properties: {
+        $schema: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          description: "Unique identifier for the plugin ()",
+          minLength: 3,
+          maxLength: 63,
+          pattern: "^[a-z0-9-]+$"
+        },
+        manifest_version: {
+          type: "number",
+          description: "Manifest format version",
+          minimum: 1
+        },
+        supported_services: {
+          type: "array",
+          description: "Supported services for this plugin",
+          items: {
+            type: "string",
+            enum: [
+              "tracker"
+            ]
+          },
+          minItems: 1,
+          uniqueItems: !0
+        },
+        slug: {
+          type: "string",
+          description: "Unique identifier for the plugin (lowercase letters, numbers, hyphen)",
+          minLength: 3,
+          maxLength: 63,
+          pattern: "^[a-z0-9-]+$"
+        },
+        version: {
+          type: "string",
+          description: "Version of the plugin (semver format required)",
+          minLength: 1,
+          pattern: "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$"
+        },
+        name: {
+          type: "object",
+          description: "Localized plugin name",
+          required: [
+            "ru",
+            "en"
+          ],
+          properties: {
+            ru: {
+              type: "string",
+              description: "Russian name",
+              minLength: 1,
+              maxLength: 30
+            },
+            en: {
+              type: "string",
+              description: "English name",
+              minLength: 1,
+              maxLength: 30
+            }
+          },
+          additionalProperties: !1
+        },
+        description: {
+          type: "object",
+          description: "Localized plugin description",
+          required: [
+            "ru",
+            "en"
+          ],
+          properties: {
+            ru: {
+              type: "string",
+              description: "Russian description",
+              minLength: 1,
+              maxLength: 255
+            },
+            en: {
+              type: "string",
+              description: "English description",
+              minLength: 1,
+              maxLength: 255
+            }
+          },
+          additionalProperties: !1
+        },
+        support: {
+          type: "array",
+          description: "Support contact information",
+          items: {
+            type: "object",
+            required: [
+              "type",
+              "value"
+            ],
+            properties: {
+              type: {
+                type: "string",
+                description: "Type of support contact",
+                enum: [
+                  "email"
+                ]
+              },
+              value: {
+                type: "string",
+                description: "Contact value",
+                minLength: 1,
+                maxLength: 100
+              }
+            },
+            additionalProperties: !1
+          },
+          minItems: 1
+        },
+        homepage: {
+          type: "string",
+          description: "Homepage URL for the plugin (http or https)",
+          pattern: "^https?://",
+          maxLength: 1e3
+        },
+        license: {
+          type: "string",
+          description: "License identifier (e.g., MIT, Apache-2.0)",
+          minLength: 1,
+          maxLength: 32
+        },
+        keywords: {
+          type: "array",
+          description: "Keywords for plugin discovery",
+          items: {
+            type: "string",
+            minLength: 1,
+            maxLength: 30
+          },
+          uniqueItems: !0
+        },
+        whatsnew: {
+          type: "string",
+          description: "What's new in this version",
+          minLength: 1,
+          maxLength: 300
+        },
+        externalHost: {
+          type: "string",
+          description: "External host URL for the plugin (https only)",
+          format: "uri",
+          pattern: "^https://",
+          maxLength: 1e3
+        },
+        permissions: {
+          type: "object",
+          description: "Permissions required by the plugin",
+          required: [
+            "data"
+          ],
+          properties: {
+            data: {
+              type: "array",
+              description: "Data access permissions",
+              items: {
+                type: "string",
+                enum: [
+                  "tracker:issues:read",
+                  "tracker:issues:write",
+                  "tracker:issuetypes:read",
+                  "tracker:statuses:read",
+                  "tracker:queues:read",
+                  "tracker:fields:read",
+                  "tracker:entities:read",
+                  "tracker:attachments:read",
+                  "tracker:attachments:write",
+                  "tracker:applications:read",
+                  "tracker:boards:read",
+                  "tracker:boards:write",
+                  "tracker:bulk:read",
+                  "tracker:bulk:write",
+                  "tracker:bulkchange:read",
+                  "tracker:bulkchange:write",
+                  "tracker:charts:read",
+                  "tracker:commentTemplates:read",
+                  "tracker:commentTemplates:write",
+                  "tracker:components:read",
+                  "tracker:components:write",
+                  "tracker:data:read",
+                  "tracker:departments:read",
+                  "tracker:entities:write",
+                  "tracker:externalEventTypes:write",
+                  "tracker:externalEvents:write",
+                  "tracker:fields:write",
+                  "tracker:filterFolders:write",
+                  "tracker:filters:read",
+                  "tracker:filters:write",
+                  "tracker:goals:read",
+                  "tracker:goals:write",
+                  "tracker:groups:read",
+                  "tracker:issueTemplates:read",
+                  "tracker:issueTemplates:write",
+                  "tracker:links:read",
+                  "tracker:linktypes:read",
+                  "tracker:liveBoards:write",
+                  "tracker:localFields:read",
+                  "tracker:maillists:read",
+                  "tracker:maillists:write",
+                  "tracker:myself:read",
+                  "tracker:myself:write",
+                  "tracker:priorities:read",
+                  "tracker:queues:write",
+                  "tracker:reminders:read",
+                  "tracker:reminders:write",
+                  "tracker:remotelinks:read",
+                  "tracker:reports:read",
+                  "tracker:reports:write",
+                  "tracker:resolutions:read",
+                  "tracker:resources:read",
+                  "tracker:resources:write",
+                  "tracker:roles:read",
+                  "tracker:screens:read",
+                  "tracker:services:read",
+                  "tracker:sprints:read",
+                  "tracker:sprints:write",
+                  "tracker:system:write",
+                  "tracker:tags:read",
+                  "tracker:translations:read",
+                  "tracker:users:read",
+                  "tracker:users:write",
+                  "tracker:versions:read",
+                  "tracker:versions:write",
+                  "tracker:workflows:read",
+                  "tracker:workflows:write",
+                  "tracker:worklog:read",
+                  "tracker:worklog:write"
+                ]
+              },
+              uniqueItems: !0
+            },
+            ui: {
+              type: "array",
+              description: "UI permissions",
+              items: {
+                type: "string"
+              },
+              uniqueItems: !0
+            },
+            device: {
+              type: "array",
+              description: "Device permissions",
+              items: {
+                type: "string",
+                enum: [
+                  "clipboard-write"
+                ]
+              },
+              uniqueItems: !0
+            },
+            external: {
+              type: "array",
+              description: "External API domains the plugin may call through the platform proxy",
+              items: {
+                $ref: "#/definitions/ExternalDomain"
+              },
+              uniqueItems: !0
+            }
+          },
+          additionalProperties: !1
+        },
+        slots: {
+          type: "object",
+          description: "Configuration for service slots",
+          minProperties: 1,
+          properties: {
+            tracker: {
+              type: "object",
+              description: "Tracker service slots",
+              minProperties: 1,
+              properties: {
+                "issue.action": {
+                  type: "array",
+                  description: "Issue Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "issue.block": {
+                  type: "array",
+                  description: "Issue Block slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "issue.tab": {
+                  type: "array",
+                  description: "Issue Tab slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "issue.comment.action": {
+                  type: "array",
+                  description: "Issue Comment Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                navigation: {
+                  type: "array",
+                  description: "Navigation slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "trigger.create.action": {
+                  type: "array",
+                  description: "Trigger Create Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "trigger.edit.action": {
+                  type: "array",
+                  description: "Trigger Edit Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "project.action": {
+                  type: "array",
+                  description: "Project Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "project.block": {
+                  type: "array",
+                  description: "Project Block slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "project.tab": {
+                  type: "array",
+                  description: "Project Tab slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "portfolio.action": {
+                  type: "array",
+                  description: "Portfolio Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "portfolio.block": {
+                  type: "array",
+                  description: "Portfolio Block slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "portfolio.tab": {
+                  type: "array",
+                  description: "Portfolio Tab slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "goal.action": {
+                  type: "array",
+                  description: "Goal Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "goal.block": {
+                  type: "array",
+                  description: "Goal Block slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "goal.tab": {
+                  type: "array",
+                  description: "Goal Tab slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "attachment.viewer.action": {
+                  type: "array",
+                  description: "Attachment Viewer Action slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                "board.tab": {
+                  type: "array",
+                  description: "Board Tab slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                },
+                dock: {
+                  type: "array",
+                  description: "Dock slot configurations",
+                  minItems: 1,
+                  items: {
+                    $ref: "#/definitions/SlotConfig"
+                  }
+                }
+              },
+              additionalProperties: !1
+            }
+          },
+          additionalProperties: !1
+        }
+      },
+      additionalProperties: !1,
+      definitions: {
+        ExternalDomain: {
+          type: "object",
+          description: "External API domain declaration with optional authorization config",
+          required: [
+            "domain"
+          ],
+          properties: {
+            domain: {
+              type: "string",
+              description: "Hostname of the external API (no scheme, no path, lowercase)",
+              pattern: "^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$",
+              minLength: 1,
+              maxLength: 253
+            },
+            authorization: {
+              $ref: "#/definitions/ExternalAuthorization"
+            },
+            instructions: {
+              type: "object",
+              description: "Localized note shown to the end user when they need to provide a token for this domain (e.g. where to generate the PAT)",
+              required: [
+                "ru",
+                "en"
+              ],
+              properties: {
+                ru: {
+                  type: "string",
+                  description: "Russian instructions",
+                  minLength: 1,
+                  maxLength: 500
+                },
+                en: {
+                  type: "string",
+                  description: "English instructions",
+                  minLength: 1,
+                  maxLength: 500
+                }
+              },
+              additionalProperties: !1
+            }
+          },
+          additionalProperties: !1
+        },
+        ExternalAuthorization: {
+          type: "object",
+          description: "Authorization config for an external API domain",
+          required: [
+            "type"
+          ],
+          properties: {
+            type: {
+              type: "string",
+              description: "Authorization scheme: oauth (full OAuth flow or manual PAT for an OAuth provider) or token (manual non-OAuth token, e.g. API key)",
+              enum: [
+                "oauth",
+                "token"
+              ]
+            },
+            scopes: {
+              type: "array",
+              description: "Scopes required by this version of the plugin for the domain",
+              items: {
+                type: "string",
+                minLength: 1
+              },
+              uniqueItems: !0
+            },
+            contextTypes: {
+              type: "array",
+              description: "Supported token storage contexts",
+              items: {
+                type: "string",
+                enum: [
+                  "user",
+                  "organization"
+                ]
+              },
+              minItems: 1,
+              uniqueItems: !0
+            },
+            header: {
+              type: "string",
+              description: "Custom HTTP header name to put the token into (default: Authorization)",
+              minLength: 1
+            },
+            prefix: {
+              type: "string",
+              description: "Custom token prefix in the Authorization header (default: Bearer; empty string for no prefix)"
+            }
+          },
+          additionalProperties: !1
+        },
+        SlotConfig: {
+          type: "object",
+          description: "Configuration for a specific slot",
+          required: [
+            "entrypoint",
+            "title",
+            "contextLevel"
+          ],
+          properties: {
+            entrypoint: {
+              type: "string",
+              description: "Entry point file path for the slot",
+              minLength: 1
+            },
+            title: {
+              type: "object",
+              description: "Localized titles for the slot",
+              required: [
+                "ru",
+                "en"
+              ],
+              properties: {
+                ru: {
+                  type: "string",
+                  description: "Russian title",
+                  minLength: 1,
+                  maxLength: 32
+                },
+                en: {
+                  type: "string",
+                  description: "English title",
+                  minLength: 1,
+                  maxLength: 32
+                }
+              },
+              additionalProperties: !1
+            },
+            contextLevel: {
+              type: "string",
+              description: "Level of context data provided to the slot",
+              enum: [
+                "basic",
+                "full"
+              ]
+            },
+            icon: {
+              type: "object",
+              description: "Optional slot icon (used by 'dock' slot for FAB)",
+              required: [
+                "url"
+              ],
+              properties: {
+                url: {
+                  type: "string",
+                  description: "Relative path to the icon file (e.g. ./icon.svg)",
+                  minLength: 1
+                }
+              },
+              additionalProperties: !1
+            },
+            description: {
+              type: "object",
+              description: "Localized descriptions for the slot",
+              required: [
+                "ru",
+                "en"
+              ],
+              properties: {
+                ru: {
+                  type: "string",
+                  description: "Russian description",
+                  minLength: 1,
+                  maxLength: 300
+                },
+                en: {
+                  type: "string",
+                  description: "English description",
+                  minLength: 1,
+                  maxLength: 300
+                }
+              },
+              additionalProperties: !1
+            }
+          },
+          additionalProperties: !1
+        }
+      }
+    };
+  }
+});
+
+// src/core/manifest/manifestManager.ts
+var 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"() {
+    "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}
+
+\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/utils/marketplace.ts
+function validateMarketplaceAssets() {
+  let marketplaceDir = import_path3.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),
+    "Marketplace description not found. Add ./marketplace/index.md before publishing."
+  ), ensurePathExists(
+    import_path3.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),
+    "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),
+    "Source folder not found. Add ./src before publishing."
+  ), ensurePathExists(import_path3.default.resolve(MANIFEST_FILE), "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({
+  "src/utils/marketplace.ts"() {
+    "use strict";
+    import_fs5 = __toESM(require("fs")), import_path3 = __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));
+    }, validateManifestPublishingFields = async () => {
+      let manifest = await manifestManager.load();
+      ensureManifestCatalogFields(manifest);
+    }, ensureManifestCatalogFields = (manifest) => {
+      (!manifest.name?.ru || !manifest.name?.en) && (logger_default.error(
+        'Manifest field "name" is required for publishing. Add localized "name.ru" and "name.en" to ./manifest.json.'
+      ), process.exit(1)), (!manifest.description?.ru || !manifest.description?.en) && (logger_default.error(
+        'Manifest field "description" is required for publishing. Add localized "description.ru" and "description.en" to ./manifest.json.'
+      ), process.exit(1));
+    };
+    marketplacePaths = {
+      distDir: DIST_DIR,
+      srcDir: SRC_DIR,
+      marketplaceDir: MARKETPLACE_DIR,
+      manifestFile: MANIFEST_FILE
+    };
+  }
+});
+
+// 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;
+}
+function hasPluginScript(name, cwd = process.cwd()) {
+  return !!readPluginPackageScripts(cwd)?.[name];
+}
+var import_fs6, import_path4, init_pluginPackageScripts = __esm({
+  "src/utils/pluginPackageScripts.ts"() {
+    "use strict";
+    import_fs6 = __toESM(require("fs")), import_path4 = __toESM(require("path"));
+  }
+});
+
+// src/commands/submit/utils/runSubmitPrechecks.ts
+async function runSubmitPrechecks(options = {}) {
+  if (options.skip) {
+    logger_default.warning("Skipping pre-submit checks (--skip-checks).");
+    return;
+  }
+  logger_default.separator(), logger_default.info("\u{1F50D} Pre-submit checks"), logger_default.separator(), await runStep("Validate manifest.json", () => manifestManager.validate()), await runStep("Check publishing metadata and assets", async () => {
+    await validateManifestPublishingFields(), validateMarketplaceAssets();
+  }), await runShellStep("Install dependencies", pluginCmd.install), await runShellStep("Run linter", pluginCmd.lint), hasPluginScript("typecheck") ? await runShellStep("Run typecheck", pluginCmd.typecheck) : logger_default.verbose('Skipping typecheck (no "typecheck" script in package.json).'), hasPluginScript("test") ? await runShellStep("Run tests", pluginCmd.test) : logger_default.warning(
+    'No "test" script in package.json \u2014 add tests before publishing, or run submit with --skip-checks.'
+  ), await runShellStep("Check dependency vulnerabilities", pluginCmd.audit), logger_default.separator(), logger_default.success("Pre-submit checks passed"), logger_default.separator();
+}
+var import_picocolors4, stepStart, stepDone, runStep, runShellStep, init_runSubmitPrechecks = __esm({
+  "src/commands/submit/utils/runSubmitPrechecks.ts"() {
+    "use strict";
+    import_picocolors4 = __toESM(require("picocolors"));
+    init_manifestManager();
+    init_execCommand();
+    init_logger();
+    init_marketplace();
+    init_pluginPackageScripts();
+    init_templateCommands();
+    stepStart = (label) => {
+      console.info(`${import_picocolors4.default.cyan("\u25B8")} ${label}`);
+    }, stepDone = (label) => {
+      console.info(`${import_picocolors4.default.green("\u2713")} ${label}`), console.info("");
+    }, runStep = async (label, run) => {
+      stepStart(label), await run(), stepDone(label);
+    }, runShellStep = async (label, command) => {
+      stepStart(label), console.info(import_picocolors4.default.dim(`  $ ${command}`)), await execCommand(command), stepDone(label);
+    };
+  }
+});
+
+// src/utils/buildArchive.ts
+async function buildArchive() {
+  return validateArchiveSources(), (await manifestManager.load()).manifest_version === void 0 && (logger_default.error(
+    `manifest_version is missing in manifest.json. Run "${CLI_NAME2} up" or add "manifest_version": 1 manually before uploading.`
+  ), process.exit(1)), new Promise((resolve2, reject) => {
+    let archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } }), chunks = [];
+    archive.on("data", (chunk) => chunks.push(chunk)), archive.on("end", () => {
+      let buffer = Buffer.concat(chunks);
+      if (logger_default.info(`\u{1F4E6} Archive created (${buffer.length} bytes)`), isVerboseEnabled()) {
+        let debugPath = writeVerboseArtifact("archive/latest-upload.zip", buffer);
+        logger_default.info(`[platform-api-debug] Saved archive copy to ${debugPath}`);
+      }
+      resolve2(buffer);
+    }), archive.on("error", reject), archive.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(
+      "**/*",
+      {
+        cwd: import_path5.default.resolve(marketplacePaths.distDir),
+        ignore: ["**/.DS_Store"]
+      },
+      { prefix: "dist/" }
+    ), archive.finalize();
+  });
+}
+var import_path5, import_archiver, init_buildArchive = __esm({
+  "src/utils/buildArchive.ts"() {
+    "use strict";
+    import_path5 = __toESM(require("path")), import_archiver = __toESM(require("archiver"));
+    init_manifestManager();
+    init_meta2();
+    init_logger();
+    init_marketplace();
+    init_verbose();
+  }
+});
+
+// src/distributions/external/submit.ts
+async function submitExternal(options = {}) {
+  await runSubmitPrechecks({ skip: options.skipChecks });
+  let manifest = await manifestManager.load(), issueKey = (await pluginStateManager.load()).trackerIssueKey;
+  if (issueKey)
+    try {
+      await getIssue(issueKey);
+    } catch {
+      issueKey = void 0;
+    }
+  let pluginId = manifest.id ?? (0, import_crypto.randomUUID)();
+  manifest.id || await manifestManager.update({ id: pluginId });
+  let manifestJson = await manifestManager.loadRaw();
+  if (issueKey) {
+    logger_default.verbose(`\u23F3 Updating issue ${issueKey} with latest manifest...`);
+    let issueDescription = buildIssueDescription({
+      pluginId,
+      slug: manifest.slug,
+      version: manifest.version,
+      manifestJson
+    });
+    await updatePluginIssue(issueKey, { description: issueDescription });
+  } else if (options.ticket === !1) {
+    logger_default.warning(
+      "Tracker issue is required for tracker-backed submit. Skipping ticket creation."
+    );
+    return;
+  } else {
+    logger_default.info("\u23F3 Creating plugin issue in Tracker...");
+    let issue = await createPluginIssue({
+      pluginId,
+      slug: manifest.slug,
+      version: manifest.version,
+      manifestJson
+    });
+    await pluginStateManager.update({ trackerIssueKey: issue.key }), issueKey = issue.key, logger_default.info(`  Tracker issue : ${issueKey}`);
+  }
+  logger_default.info("\u{1F528} Building plugin..."), await build(), logger_default.info("\u{1F4E6} Creating archive...");
+  let archiveBuffer = await buildArchive(), archiveName = `${manifest.slug}-${manifest.version}.zip`;
+  logger_default.verbose(`\u2B06\uFE0F  Attaching ${archiveName} to ${issueKey}...`), await attachFileToIssue(issueKey, archiveBuffer, archiveName), await addIssueComment(
+    issueKey,
+    `Updated bundle: \`${archiveName}\` (${archiveBuffer.length} bytes)`
+  ), logger_default.verbose(`\u23F3 Fetching available transitions for ${issueKey}...`);
+  let transitions = await getIssueTransitions(issueKey), submitTransition = transitions.find(
+    (t) => t.display?.toLowerCase().includes(SUBMIT_TRANSITION_DISPLAY) || t.id?.toLowerCase().includes("waitingforapprove") || t.id?.toLowerCase().includes("waiting")
+  );
+  if (!submitTransition) {
+    let available = transitions.map((t) => `"${t.display ?? t.id}"`).join(", ");
+    logger_default.error(
+      `Could not find a "Waiting for approve" transition on ${issueKey}. Available: ${available}`
+    );
+    return;
+  }
+  logger_default.info("\u{1F680} Submitting plugin for review..."), await executeIssueTransition(issueKey, submitTransition.id), await addIssueComment(issueKey, `Submitted version \`${manifest.version}\` for review.`), logger_default.success("Plugin submitted for review!"), logger_default.info(`  Tracker issue : ${issueKey}`), logger_default.info(`  Version       : ${manifest.version}`), logger_default.newLine();
+}
+var import_crypto, SUBMIT_TRANSITION_DISPLAY, init_submit = __esm({
+  "src/distributions/external/submit.ts"() {
+    "use strict";
+    import_crypto = require("crypto");
+    init_build();
+    init_runSubmitPrechecks();
+    init_manifestManager();
+    init_pluginStateManager();
+    init_buildArchive();
+    init_logger();
+    init_tracker();
+    SUBMIT_TRANSITION_DISPLAY = "waiting for approve";
+  }
+});
+
 // src/distributions/external/registerCommands.ts
 var registerCommands_exports = {};
 __export(registerCommands_exports, {
   registerDistributionCommands: () => registerDistributionCommands
 });
 function registerDistributionCommands(program) {
-  registerConfigCommand(program, CLI_NAME);
+  registerConfigCommand(program, CLI_NAME), program.command("login").description("save your Yandex Tracker OAuth token (request it via Tracker support)").action(withErrorHandling(loginExternal)), program.command("logout").description("remove saved OAuth token").action(
+    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(
+    "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_options();
     init_registerCommand();
+    init_withErrorHandling();
+    init_info();
+    init_list();
+    init_login();
     init_meta();
+    init_submit();
   }
 });
 
@@ -276,7 +1734,7 @@ function getPlatformBaseUrl() {
   return cfg.api.platformBaseUrl;
 }
 function getTrackerBaseUrl() {
-  return TRACKER_BASE_URL;
+  return TRACKER_BASE_URL2;
 }
 function getOAuthTokenUrl() {
   let cfg = requireConfig();
@@ -287,11 +1745,11 @@ function getOAuthTokenUrl() {
 function getUpdateCheckInfo() {
   return null;
 }
-var TRACKER_BASE_URL, init_hosts = __esm({
+var TRACKER_BASE_URL2, init_hosts = __esm({
   "src/distributions/external/hosts.ts"() {
     "use strict";
     init_manager();
-    TRACKER_BASE_URL = "https://tracker.yandex.ru";
+    TRACKER_BASE_URL2 = "https://api.tracker.yandex.net/v3";
   }
 });
 
@@ -299,6 +1757,7 @@ var TRACKER_BASE_URL, init_hosts = __esm({
 var templateSubstitution_exports = {};
 __export(templateSubstitution_exports, {
   applySubstitutions: () => applySubstitutions,
+  overlayDirName: () => overlayDirName,
   templateDeps: () => templateDeps
 });
 function rewritePackageJson(content) {
@@ -306,8 +1765,6 @@ function rewritePackageJson(content) {
   if (pkg.dependencies) {
     let next = {};
     for (let [name, version] of Object.entries(pkg.dependencies)) {
-      if (PACKAGE_DROP.has(name))
-        continue;
       let renamed = PACKAGE_RENAME[name] ?? name;
       next[renamed] = ADDED_DEPS[renamed] ?? version;
     }
@@ -328,62 +1785,52 @@ function rewriteImports(content) {
   }
   return result;
 }
-function rewriteScss(content) {
-  return content.split(`
-`).filter((line) => {
-    let trimmed = line.trim();
-    return trimmed.startsWith("@import") ? ![...PACKAGE_DROP].some((pkg) => trimmed.includes(pkg)) : !0;
-  }).join(`
-`);
-}
 function rewriteNpmrc(content) {
   return content.split(`
 `).filter((line) => !/^registry\s*=\s*https?:\/\/npm\.yandex-team\.ru/.test(line.trim())).join(`
 `);
 }
 function applySubstitutions(filePath, content) {
-  let name = import_path2.default.basename(filePath), ext = import_path2.default.extname(filePath);
+  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 (ext === ".scss" || ext === ".css")
-    return Buffer.from(rewriteScss(content.toString("utf8")), "utf8");
   if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
-    let text = content.toString("utf8"), rewritten = rewriteImports(text);
-    if (rewritten !== text)
+    let original = content.toString("utf8"), rewritten = rewriteImports(original);
+    if (rewritten !== original)
       return Buffer.from(rewritten, "utf8");
   }
   return content;
 }
-var import_path2, PACKAGE_RENAME, PACKAGE_DROP, ADDED_DEPS, templateDeps, init_templateSubstitution = __esm({
+var import_path6, PACKAGE_RENAME, ADDED_DEPS, templateDeps, overlayDirName, init_templateSubstitution = __esm({
   "src/distributions/external/templateSubstitution.ts"() {
     "use strict";
-    import_path2 = __toESM(require("path")), PACKAGE_RENAME = {
+    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"
-    }, PACKAGE_DROP = /* @__PURE__ */ new Set(["@yandex-data-ui/gravity-themes"]), ADDED_DEPS = {
+    }, 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"];
+    }, templateDeps = ["@weavix/sdk-core", "@weavix/sdk-react", "@weavix/tracker-api-types"], overlayDirName = "_external";
   }
 });
 
 // src/index.ts
-var import_commander = require("commander");
-
-// src/distribution/meta.ts
-var impl = (init_meta(), __toCommonJS(meta_exports)), { CLI_NAME: CLI_NAME2, CLI_DESCRIPTION: CLI_DESCRIPTION2, CLI_HELP_TEXT: CLI_HELP_TEXT2 } = impl;
+var import_commander2 = require("commander");
+init_meta2();
 
 // src/distribution/registerCommands.ts
-var impl2 = (init_registerCommands(), __toCommonJS(registerCommands_exports)), { registerDistributionCommands: registerDistributionCommands2 } = impl2;
+init_flag();
+var impl3 = (init_registerCommands(), __toCommonJS(registerCommands_exports)), { registerDistributionCommands: registerDistributionCommands2 } = impl3;
 
 // src/utils/checkUpdate.ts
-var import_node_fetch = __toESM(require("node-fetch"));
+var import_node_fetch2 = __toESM(require("node-fetch"));
 
 // src/distribution/hosts.ts
-var impl3 = (init_hosts(), __toCommonJS(hosts_exports)), {
+init_flag();
+var impl4 = (init_hosts(), __toCommonJS(hosts_exports)), {
   getS3Endpoint: getS3Endpoint2,
   getMdsEndpoint: getMdsEndpoint2,
   getS3Region: getS3Region2,
@@ -393,55 +1840,48 @@ var impl3 = (init_hosts(), __toCommonJS(hosts_exports)), {
   getTrackerBaseUrl: getTrackerBaseUrl2,
   getOAuthTokenUrl: getOAuthTokenUrl2,
   getUpdateCheckInfo: getUpdateCheckInfo2
-} = impl3;
-
-// src/utils/checkUpdate.ts
-init_logger();
-var checkUpdate = async (version) => {
-  let info2 = getUpdateCheckInfo2();
-  if (info2)
-    try {
-      let response = await (0, import_node_fetch.default)(`${info2.registryUrl}/${info2.packageName}/latest`);
-      if (!response.ok)
-        return;
-      let latest = await response.json();
-      latest.version !== version && (logger_default.newLine(), logger_default.info(
-        `\u{1F514} Update available ${version} \u2192 ${latest.version}
-Run: npm i -g ${info2.packageName}@latest --registry=${info2.registryUrl}`
-      ));
-    } catch {
-    }
-};
-
-// src/utils/execCommand.ts
-var import_execa = require("execa"), execCommand = async (command, cwd = process.cwd()) => {
-  await (0, import_execa.execa)(command, {
-    cwd,
-    shell: !0,
-    stdio: "inherit"
-  });
-};
-
-// src/commands/build.ts
-init_logger();
+} = impl4;
 
-// src/commands/constants/templateCommands.ts
-var pluginCmd = {
-  install: "npm install",
-  build: "npm run build",
-  dev: "npm run dev",
-  lint: "npm run lint"
+// src/utils/checkUpdate.ts
+init_logger();
+var SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/, DIAGNOSTIC_FLAGS = /* @__PURE__ */ new Set(["--version", "-V", "--help", "-h", "help"]), parse = (v) => {
+  let m = SEMVER_RE.exec(v);
+  return m ? { major: +m[1], minor: +m[2], patch: +m[3] } : null;
+}, isDiagnosticInvocation = () => {
+  let args = process.argv.slice(2);
+  return args.length === 0 ? !0 : args.some((a) => DIAGNOSTIC_FLAGS.has(a));
+}, classify = (current, latest) => latest.major > current.major ? "minorOrMajor" : latest.major < current.major ? "none" : latest.minor > current.minor ? "minorOrMajor" : latest.minor < current.minor ? "none" : latest.patch > current.patch ? "patch" : "none", checkUpdate = async (version) => {
+  if (version === "unknown" || isDiagnosticInvocation() || process.env.TRACKER_CLI_SKIP_UPDATE_CHECK) return;
+  let info2 = getUpdateCheckInfo2();
+  if (!info2) return;
+  let current = parse(version);
+  if (current)
+    try {
+      let response = await (0, import_node_fetch2.default)(`${info2.registryUrl}/${info2.packageName}/latest`);
+      if (!response.ok) return;
+      let json = await response.json(), latest = parse(json.version);
+      if (!latest) return;
+      let kind = classify(current, latest);
+      if (kind === "none") return;
+      let installCmd = `npm i -g ${info2.packageName}@latest --registry=${info2.registryUrl}`;
+      if (kind === "minorOrMajor") {
+        logger_default.newLine(), logger_default.error(
+          `Update required ${version} \u2192 ${json.version}
+This release is not backward-compatible with your installed version.`
+        ), logger_default.suggest(installCmd), process.exit(1);
+        return;
+      }
+      logger_default.newLine(), logger_default.info(`\u{1F514} Update available ${version} \u2192 ${json.version}
+Run: ${installCmd}`);
+    } catch {
+    }
 };
 
-// src/commands/build.ts
-var build = async ({ environment = "production" } = {}) => {
-  logger_default.info("\u{1F528} Building project..."), await execCommand(pluginCmd.install), await execCommand(
-    environment ? `VITE_DEPLOY_ENV=${environment} ${pluginCmd.build}` : pluginCmd.build
-  );
-};
+// src/index.ts
+init_build();
 
 // src/commands/create/index.ts
-var path8 = __toESM(require("path")), import_prompts2 = require("@inquirer/prompts");
+var path13 = __toESM(require("path")), import_prompts3 = require("@inquirer/prompts");
 
 // src/core/manifest/constants.ts
 var DATA_PERMISSIONS = [
@@ -526,9 +1966,16 @@ var TEMPLATES = [
   "navigation",
   "trigger.action",
   "project.action",
+  "project.block",
+  "project.tab",
   "portfolio.action",
+  "portfolio.block",
+  "portfolio.tab",
   "goal.action",
-  "attachment.viewer.action"
+  "goal.block",
+  "goal.tab",
+  "attachment.viewer.action",
+  "board.tab"
 ];
 var TEMPLATE_SLOTS = {
   default: [],
@@ -539,25 +1986,33 @@ var TEMPLATE_SLOTS = {
   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"],
-  "attachment.viewer.action": ["attachment.viewer.action"]
+  "goal.block": ["goal.block"],
+  "goal.tab": ["goal.tab"],
+  "attachment.viewer.action": ["attachment.viewer.action"],
+  "board.tab": ["board.tab"]
 };
 
 // src/commands/create/index.ts
+init_meta2();
 init_logger();
 
 // src/commands/create/utils/getWelcomeMessage.ts
-var import_picocolors2 = __toESM(require("picocolors")), getWelcomeMessage = (pwd) => `
-${import_picocolors2.default.bold(import_picocolors2.default.white("\u{1F680} Create new tracker plugin"))}
+var import_picocolors5 = __toESM(require("picocolors")), getWelcomeMessage = (pwd) => `
+${import_picocolors5.default.bold(import_picocolors5.default.white("\u{1F680} Create new tracker plugin"))}
 
-${import_picocolors2.default.dim(`\u{1F4C1} Creating an app in your current directory: ${pwd}`)}
+${import_picocolors5.default.dim(`\u{1F4C1} Creating an app in your current directory: ${pwd}`)}
 
-${import_picocolors2.default.dim("Press")} ${import_picocolors2.default.yellow("Ctrl+C")} ${import_picocolors2.default.dim("to cancel.")}
+${import_picocolors5.default.dim("Press")} ${import_picocolors5.default.yellow("Ctrl+C")} ${import_picocolors5.default.dim("to cancel.")}
 `;
 
 // src/commands/create/utils/initManifest.ts
-var fs = __toESM(require("fs")), path2 = __toESM(require("path"));
+var fs5 = __toESM(require("fs")), path7 = __toESM(require("path"));
 
 // src/commands/create/utils/generateManifest.ts
 function buildSlots(template, slotTitle) {
@@ -565,7 +2020,8 @@ function buildSlots(template, slotTitle) {
   if (slotNames.length === 0) return;
   let slotEntry = {
     entrypoint: "index.html",
-    title: { ru: slotTitle, en: slotTitle }
+    title: { ru: slotTitle, en: slotTitle },
+    contextLevel: "basic"
   };
   return {
     tracker: Object.fromEntries(slotNames.map((slotName) => [slotName, [slotEntry]]))
@@ -592,20 +2048,19 @@ var generateManifest = (answers) => ({
 
 // src/commands/create/utils/initManifest.ts
 var initManifest = ({ answers, targetDir }) => {
-  let generatedManifest = generateManifest(answers), manifestPath2 = path2.join(targetDir, "manifest.json");
-  fs.writeFileSync(manifestPath2, JSON.stringify(generatedManifest, null, 2), "utf-8");
+  let generatedManifest = generateManifest(answers), manifestPath2 = path7.join(targetDir, "manifest.json");
+  fs5.writeFileSync(manifestPath2, JSON.stringify(generatedManifest, null, 2), "utf-8");
 };
 
 // src/commands/create/utils/initTemplate.ts
-var fs4 = __toESM(require("fs")), path7 = __toESM(require("path"));
-
-// src/utils/copyDirectory.ts
-var fs2 = __toESM(require("fs")), import_path3 = __toESM(require("path")), import_tinyglobby = require("tinyglobby");
+var fs8 = __toESM(require("fs")), path12 = __toESM(require("path"));
 
 // src/distribution/templateSubstitution.ts
-var impl4 = (init_templateSubstitution(), __toCommonJS(templateSubstitution_exports)), { applySubstitutions: applySubstitutions2, templateDeps: templateDeps2 } = impl4;
+init_flag();
+var impl5 = (init_templateSubstitution(), __toCommonJS(templateSubstitution_exports)), { applySubstitutions: applySubstitutions2, overlayDirName: overlayDirName2, templateDeps: templateDeps2 } = impl5;
 
 // 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)(["**/*"], {
     cwd: sourceDir,
@@ -614,38 +2069,35 @@ var resolveTargetFileName = (file) => file.endsWith(".template") ? "." + file.re
   });
   await Promise.all(
     files.map(async (file) => {
-      let sourcePath = import_path3.default.join(sourceDir, file), targetFile = resolveTargetFileName(file), targetPath = import_path3.default.join(targetDir, targetFile);
-      await fs2.promises.mkdir(import_path3.default.dirname(targetPath), { recursive: !0 });
-      let content = await fs2.promises.readFile(sourcePath), rewritten = applySubstitutions2(file, content);
-      await fs2.promises.writeFile(targetPath, rewritten);
+      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);
     })
   );
 };
 
 // src/utils/getProjectPath.ts
-var import_path4 = __toESM(require("path")), isDevelopment = () => __dirname.includes("/src/"), getProjectPath = (relativePath) => {
-  let levelsUp = isDevelopment() ? "../.." : "..";
-  return import_path4.default.resolve(__dirname, levelsUp, relativePath);
-}, getTemplatesBaseDir = () => getProjectPath("templates"), getTemplatePath = (filename) => import_path4.default.join(getTemplatesBaseDir(), "_shared", filename);
+var import_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);
 
 // src/commands/create/utils/initTemplate.ts
 init_logger();
 
 // src/commands/create/utils/updatePackageJson.ts
-var fs3 = __toESM(require("fs")), path6 = __toESM(require("path")), updatePackageJson = (targetDir, packageSlug) => {
-  let packageJsonPath = path6.join(targetDir, "package.json");
-  if (fs3.existsSync(packageJsonPath)) {
-    let packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
-    packageJson.name = packageSlug, fs3.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
+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) + `
 `);
   }
 };
 
 // src/commands/create/utils/initTemplate.ts
 var initTemplate = async ({ answers, targetDir }) => {
-  fs4.existsSync(targetDir) || fs4.mkdirSync(targetDir, { recursive: !0 });
-  let templatesBaseDir = getTemplatesBaseDir(), templatesDir = path7.join(templatesBaseDir, answers.template), sharedDir = path7.join(templatesBaseDir, "_shared");
-  await copyDirectory(sharedDir, targetDir), await copyDirectory(templatesDir, targetDir), updatePackageJson(targetDir, answers.packageSlug), logger_default.info("Created template with marketplace publication requirements."), logger_default.info(
+  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);
+  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)."
   );
 };
@@ -654,26 +2106,26 @@ var initTemplate = async ({ answers, targetDir }) => {
 var DEFAULT_VERSION = "0.0.1";
 async function create() {
   logger_default.info(getWelcomeMessage(process.cwd()));
-  let packageSlug = await (0, import_prompts2.input)({
+  let packageSlug = await (0, import_prompts3.input)({
     message: "Enter app slug (e.g., my-tracker-plugin):",
     required: !0
-  }), pluginName = await (0, import_prompts2.input)({
+  }), pluginName = await (0, import_prompts3.input)({
     message: "Enter plugin name:",
     required: !0
-  }), pluginDescription = await (0, import_prompts2.input)({
+  }), pluginDescription = await (0, import_prompts3.input)({
     message: "Enter plugin description:",
     required: !0
-  }), supportEmail = await (0, import_prompts2.input)({
+  }), supportEmail = await (0, import_prompts3.input)({
     message: "Enter support email:",
     required: !0,
     validate: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) || "Please enter a valid email address"
-  }), template = await (0, import_prompts2.select)({
+  }), template = await (0, import_prompts3.select)({
     message: "Select a template:",
     choices: TEMPLATES.map((templateName) => ({
       name: templateName,
       value: templateName
     }))
-  }), dataPermissions = await (0, import_prompts2.checkbox)({
+  }), dataPermissions = await (0, import_prompts3.checkbox)({
     message: "Select data permissions (some popular options):",
     choices: TOP_DATA_PERMISSIONS.map((permission) => ({
       name: permission,
@@ -690,567 +2142,28 @@ async function create() {
       data: dataPermissions
     },
     version: DEFAULT_VERSION
-  }, targetDir = path8.join(process.cwd(), answers.packageSlug);
+  }, targetDir = path13.join(process.cwd(), answers.packageSlug);
   await initTemplate({
     answers,
     targetDir
   }), initManifest({
     answers,
     targetDir
-  }), logger_default.newLine(), logger_default.success("Package generated!"), logger_default.commands("To get started, run", [
-    `cd ${answers.packageSlug}`,
-    "npm install",
-    `${CLI_NAME2} debug`
-  ]);
+  }), 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.");
 }
 
 // src/commands/debug/index.ts
-var import_fs6 = __toESM(require("fs")), import_path8 = __toESM(require("path"));
-
-// src/core/manifest/manifestManager.ts
-var import_fs2 = require("fs"), import_promises = require("fs/promises"), import_ajv = __toESM(require("ajv")), import_ajv_formats = __toESM(require("ajv-formats"));
-
-// src/core/manifest/formatValidationErrors.ts
-var priorityOrder = [
-  "required",
-  "type",
-  "minLength",
-  "format",
-  "pattern",
-  "enum",
-  "additionalProperties",
-  "uniqueItems"
-], errorMessages = {
-  required: (params) => `missing required property '${params.missingProperty}'`,
-  type: (params) => `must be ${params.type}`,
-  enum: (params) => `must be one of [${params.allowedValues.join(", ")}]`,
-  pattern: (params) => `must match pattern ${params.pattern}`,
-  format: (params) => `must be a valid ${params.format}`,
-  minLength: () => "must not be empty",
-  additionalProperties: (params) => `unexpected property '${params.additionalProperty}'`,
-  uniqueItems: () => "must contain unique items"
-}, getPriority = (keyword) => {
-  let index = priorityOrder.indexOf(keyword);
-  return index === -1 ? priorityOrder.length : index;
-}, formatValidationErrors = (errors) => {
-  let errorsByPath = {};
-  for (let error2 of errors) {
-    let path13 = error2.instancePath || "root";
-    errorsByPath[path13] || (errorsByPath[path13] = []), errorsByPath[path13].push(error2);
-  }
-  return Object.entries(errorsByPath).map(([path13, pathErrors]) => {
-    let error2 = [...pathErrors].sort(
-      (a, b) => getPriority(a.keyword) - getPriority(b.keyword)
-    )[0], formatter = errorMessages[error2.keyword], message = formatter ? formatter(error2.params) : error2.message;
-    return `  - ${path13}: ${message}`;
-  }).join(`
-`);
-};
-
-// src/core/manifest/manifest.schema.json
-var manifest_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  title: "Manifest",
-  description: "Schema for validating plugin manifest",
-  type: "object",
-  required: [
-    "slug",
-    "version",
-    "permissions",
-    "name",
-    "description",
-    "support"
-  ],
-  properties: {
-    $schema: {
-      type: "string"
-    },
-    id: {
-      type: "string",
-      description: "Unique identifier for the plugin ()",
-      minLength: 3,
-      maxLength: 63,
-      pattern: "^[a-z0-9-]+$"
-    },
-    manifest_version: {
-      type: "number",
-      description: "Manifest format version",
-      minimum: 1
-    },
-    supported_services: {
-      type: "array",
-      description: "Supported services for this plugin",
-      items: {
-        type: "string",
-        enum: [
-          "tracker"
-        ]
-      },
-      minItems: 1,
-      uniqueItems: !0
-    },
-    slug: {
-      type: "string",
-      description: "Unique identifier for the plugin (lowercase letters, numbers, hyphen)",
-      minLength: 3,
-      maxLength: 63,
-      pattern: "^[a-z0-9-]+$"
-    },
-    version: {
-      type: "string",
-      description: "Version of the plugin (semver format required)",
-      minLength: 1,
-      pattern: "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$"
-    },
-    name: {
-      type: "object",
-      description: "Localized plugin name",
-      required: [
-        "ru",
-        "en"
-      ],
-      properties: {
-        ru: {
-          type: "string",
-          description: "Russian name",
-          minLength: 1,
-          maxLength: 30
-        },
-        en: {
-          type: "string",
-          description: "English name",
-          minLength: 1,
-          maxLength: 30
-        }
-      },
-      additionalProperties: !1
-    },
-    description: {
-      type: "object",
-      description: "Localized plugin description",
-      required: [
-        "ru",
-        "en"
-      ],
-      properties: {
-        ru: {
-          type: "string",
-          description: "Russian description",
-          minLength: 1,
-          maxLength: 255
-        },
-        en: {
-          type: "string",
-          description: "English description",
-          minLength: 1,
-          maxLength: 255
-        }
-      },
-      additionalProperties: !1
-    },
-    support: {
-      type: "array",
-      description: "Support contact information",
-      items: {
-        type: "object",
-        required: [
-          "type",
-          "value"
-        ],
-        properties: {
-          type: {
-            type: "string",
-            description: "Type of support contact",
-            enum: [
-              "email"
-            ]
-          },
-          value: {
-            type: "string",
-            description: "Contact value",
-            minLength: 1,
-            maxLength: 100
-          }
-        },
-        additionalProperties: !1
-      },
-      minItems: 1
-    },
-    homepage: {
-      type: "string",
-      description: "Homepage URL for the plugin (http or https)",
-      pattern: "^https?://",
-      maxLength: 1e3
-    },
-    license: {
-      type: "string",
-      description: "License identifier (e.g., MIT, Apache-2.0)",
-      minLength: 1,
-      maxLength: 32
-    },
-    keywords: {
-      type: "array",
-      description: "Keywords for plugin discovery",
-      items: {
-        type: "string",
-        minLength: 1,
-        maxLength: 30
-      },
-      uniqueItems: !0
-    },
-    whatsnew: {
-      type: "string",
-      description: "What's new in this version",
-      minLength: 1,
-      maxLength: 300
-    },
-    externalHost: {
-      type: "string",
-      description: "External host URL for the plugin (https only)",
-      format: "uri",
-      pattern: "^https://",
-      maxLength: 1e3
-    },
-    permissions: {
-      type: "object",
-      description: "Permissions required by the plugin",
-      required: [
-        "data"
-      ],
-      properties: {
-        data: {
-          type: "array",
-          description: "Data access permissions",
-          items: {
-            type: "string",
-            enum: [
-              "tracker:issues:read",
-              "tracker:issues:write",
-              "tracker:issuetypes:read",
-              "tracker:statuses:read",
-              "tracker:queues:read",
-              "tracker:fields:read",
-              "tracker:entities:read",
-              "tracker:attachments:read",
-              "tracker:attachments:write",
-              "tracker:applications:read",
-              "tracker:boards:read",
-              "tracker:boards:write",
-              "tracker:bulk:read",
-              "tracker:bulk:write",
-              "tracker:bulkchange:read",
-              "tracker:bulkchange:write",
-              "tracker:charts:read",
-              "tracker:commentTemplates:read",
-              "tracker:commentTemplates:write",
-              "tracker:components:read",
-              "tracker:components:write",
-              "tracker:data:read",
-              "tracker:departments:read",
-              "tracker:entities:write",
-              "tracker:externalEventTypes:write",
-              "tracker:externalEvents:write",
-              "tracker:fields:write",
-              "tracker:filterFolders:write",
-              "tracker:filters:read",
-              "tracker:filters:write",
-              "tracker:goals:read",
-              "tracker:goals:write",
-              "tracker:groups:read",
-              "tracker:issueTemplates:read",
-              "tracker:issueTemplates:write",
-              "tracker:links:read",
-              "tracker:linktypes:read",
-              "tracker:liveBoards:write",
-              "tracker:localFields:read",
-              "tracker:maillists:read",
-              "tracker:maillists:write",
-              "tracker:myself:read",
-              "tracker:myself:write",
-              "tracker:priorities:read",
-              "tracker:queues:write",
-              "tracker:reminders:read",
-              "tracker:reminders:write",
-              "tracker:remotelinks:read",
-              "tracker:reports:read",
-              "tracker:reports:write",
-              "tracker:resolutions:read",
-              "tracker:resources:read",
-              "tracker:resources:write",
-              "tracker:roles:read",
-              "tracker:screens:read",
-              "tracker:services:read",
-              "tracker:sprints:read",
-              "tracker:sprints:write",
-              "tracker:system:write",
-              "tracker:tags:read",
-              "tracker:translations:read",
-              "tracker:users:read",
-              "tracker:users:write",
-              "tracker:versions:read",
-              "tracker:versions:write",
-              "tracker:workflows:read",
-              "tracker:workflows:write",
-              "tracker:worklog:read",
-              "tracker:worklog:write"
-            ]
-          },
-          uniqueItems: !0
-        },
-        ui: {
-          type: "array",
-          description: "UI permissions",
-          items: {
-            type: "string"
-          },
-          uniqueItems: !0
-        },
-        device: {
-          type: "array",
-          description: "Device permissions",
-          items: {
-            type: "string",
-            enum: [
-              "clipboard-write"
-            ]
-          },
-          uniqueItems: !0
-        },
-        external: {
-          type: "array",
-          description: "External permissions",
-          items: {
-            type: "string"
-          },
-          uniqueItems: !0
-        }
-      },
-      additionalProperties: !1
-    },
-    slots: {
-      type: "object",
-      description: "Configuration for service slots",
-      minProperties: 1,
-      properties: {
-        tracker: {
-          type: "object",
-          description: "Tracker service slots",
-          minProperties: 1,
-          properties: {
-            "issue.action": {
-              type: "array",
-              description: "Issue Action slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            },
-            "issue.block": {
-              type: "array",
-              description: "Issue Block slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            },
-            "issue.tab": {
-              type: "array",
-              description: "Issue Tab slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            },
-            "issue.comment.action": {
-              type: "array",
-              description: "Issue Comment Action slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            },
-            navigation: {
-              type: "array",
-              description: "Navigation slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            },
-            "trigger.create.action": {
-              type: "array",
-              description: "Trigger Create Action slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            },
-            "trigger.edit.action": {
-              type: "array",
-              description: "Trigger Edit Action slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            },
-            "project.action": {
-              type: "array",
-              description: "Project Action slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            },
-            "portfolio.action": {
-              type: "array",
-              description: "Portfolio Action slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            },
-            "goal.action": {
-              type: "array",
-              description: "Goal Action slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            },
-            "attachment.viewer.action": {
-              type: "array",
-              description: "Attachment Viewer Action slot configurations",
-              minItems: 1,
-              items: {
-                $ref: "#/definitions/SlotConfig"
-              }
-            }
-          },
-          additionalProperties: !1
-        }
-      },
-      additionalProperties: !1
-    }
-  },
-  additionalProperties: !1,
-  definitions: {
-    SlotConfig: {
-      type: "object",
-      description: "Configuration for a specific slot",
-      required: [
-        "entrypoint",
-        "title"
-      ],
-      properties: {
-        entrypoint: {
-          type: "string",
-          description: "Entry point file path for the slot",
-          minLength: 1
-        },
-        title: {
-          type: "object",
-          description: "Localized titles for the slot",
-          required: [
-            "ru",
-            "en"
-          ],
-          properties: {
-            ru: {
-              type: "string",
-              description: "Russian title",
-              minLength: 1,
-              maxLength: 32
-            },
-            en: {
-              type: "string",
-              description: "English title",
-              minLength: 1,
-              maxLength: 32
-            }
-          },
-          additionalProperties: !1
-        },
-        description: {
-          type: "object",
-          description: "Localized descriptions for the slot",
-          required: [
-            "ru",
-            "en"
-          ],
-          properties: {
-            ru: {
-              type: "string",
-              description: "Russian description",
-              minLength: 1,
-              maxLength: 300
-            },
-            en: {
-              type: "string",
-              description: "English description",
-              minLength: 1,
-              maxLength: 300
-            }
-          },
-          additionalProperties: !1
-        }
-      },
-      additionalProperties: !1
-    }
-  }
-};
-
-// src/core/manifest/manifestManager.ts
-var validator = (() => {
-  let ajv = new import_ajv.default({ allErrors: !0, strict: !1 });
-  return (0, import_ajv_formats.default)(ajv), ajv.compile(manifest_schema_default);
-})(), manifestPath = "./manifest.json", parseManifest = (content) => {
-  let manifest;
-  try {
-    manifest = JSON.parse(content);
-  } catch (error2) {
-    throw error2 instanceof SyntaxError ? new Error(`File manifest.json contains invalid JSON: ${error2.message}`) : new Error(`Error reading manifest.json: ${error2.message}`);
-  }
-  return manifest;
-}, loadRaw = async () => {
-  if (!(0, import_fs2.existsSync)(manifestPath))
-    throw new Error(`File manifest.json not found at path: ${manifestPath}`);
-  try {
-    return await (0, import_promises.readFile)(manifestPath, "utf8");
-  } catch (error2) {
-    throw error2 instanceof Error ? new Error(`Error reading manifest.json: ${error2.message}`) : new Error("Error loading manifest");
-  }
-}, load = async () => {
-  let manifestContent = await loadRaw();
-  return parseManifest(manifestContent);
-}, validate = async () => {
-  let manifest = await load();
-  if (!validator(manifest) && validator.errors) {
-    let errorMessages2 = formatValidationErrors(validator.errors);
-    throw new Error(`Manifest validation failed:
-${errorMessages2}`);
-  }
-}, save = async (manifest) => {
-  try {
-    let content = JSON.stringify(manifest, null, 4);
-    await (0, import_promises.writeFile)(manifestPath, content, "utf8");
-  } catch (error2) {
-    throw error2 instanceof Error ? new Error(`Error saving manifest.json: ${error2.message}`) : new Error("Error saving manifest");
-  }
-}, update = async (updates) => {
-  let updatedManifest = { ...await load(), ...updates };
-  return await save(updatedManifest), updatedManifest;
-}, manifestManager = {
-  load,
-  loadRaw,
-  validate,
-  save,
-  update
-};
+var import_fs10 = __toESM(require("fs")), import_path12 = __toESM(require("path"));
+init_manifestManager();
 
 // src/core/s3config/constants.ts
 var CONFIG_FILE_NAME = "config.json";
 
 // src/commands/debug/index.ts
+init_meta2();
+init_execCommand();
 init_logger();
 
 // src/utils/registerCleanup.ts
@@ -1262,8 +2175,12 @@ var registerCleanup = (cleanup) => {
   });
 };
 
+// src/commands/debug/index.ts
+init_templateCommands();
+
 // src/commands/debug/utils/createDebugConfig.ts
-var import_fs3 = __toESM(require("fs")), import_path5 = __toESM(require("path"));
+var import_fs7 = __toESM(require("fs")), import_path9 = __toESM(require("path"));
+init_manifestManager();
 
 // src/utils/convertManifestToConfig.ts
 function buildPluginDownloadUrl(env, id, version) {
@@ -1292,6 +2209,7 @@ var convertManifestToConfig = (manifest, environment) => {
               description: slotConfig.description,
               entrypoint: slotConfig.entrypoint,
               title: slotConfig.title,
+              contextLevel: slotConfig.contextLevel,
               downloadUrl: buildPluginDownloadUrl(
                 environment,
                 manifest.slug,
@@ -1308,21 +2226,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_path5.default.join(process.cwd(), CONFIG_FILE_NAME);
-  import_fs3.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  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");
 };
 
 // src/commands/debug/utils/lockFile.ts
-var import_fs4 = __toESM(require("fs")), import_path6 = __toESM(require("path")), LOCK_FILE_NAME = ".tracker-cli-debug.lock", getLockFilePath = () => import_path6.default.join(process.cwd(), LOCK_FILE_NAME), getRunningDebugPid = () => {
+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 = () => {
   let lockPath = getLockFilePath();
-  if (!import_fs4.default.existsSync(lockPath))
+  if (!import_fs8.default.existsSync(lockPath))
     return null;
   try {
-    let pid = JSON.parse(import_fs4.default.readFileSync(lockPath, "utf-8")).pid;
+    let pid = JSON.parse(import_fs8.default.readFileSync(lockPath, "utf-8")).pid;
     return process.kill(pid, 0), pid;
   } catch {
     try {
-      import_fs4.default.unlinkSync(lockPath);
+      import_fs8.default.unlinkSync(lockPath);
     } catch {
     }
     return null;
@@ -1330,18 +2248,19 @@ var import_fs4 = __toESM(require("fs")), import_path6 = __toESM(require("path"))
 }, createLockFile = () => {
   let lockPath = getLockFilePath(), lockData = {
     pid: process.pid
-  }, fd = import_fs4.default.openSync(lockPath, "wx");
-  import_fs4.default.writeSync(fd, JSON.stringify(lockData, null, 2)), import_fs4.default.closeSync(fd);
+  }, fd = import_fs8.default.openSync(lockPath, "wx");
+  import_fs8.default.writeSync(fd, JSON.stringify(lockData, null, 2)), import_fs8.default.closeSync(fd);
 }, removeLockFile = () => {
   let lockPath = getLockFilePath();
-  import_fs4.default.existsSync(lockPath) && import_fs4.default.unlinkSync(lockPath);
+  import_fs8.default.existsSync(lockPath) && import_fs8.default.unlinkSync(lockPath);
 };
 
 // src/commands/debug/utils/watchManifest.ts
-var import_fs5 = __toESM(require("fs")), import_path7 = __toESM(require("path"));
+var import_fs9 = __toESM(require("fs")), import_path11 = __toESM(require("path"));
+init_manifestManager();
 init_logger();
 var watchManifest = () => {
-  let manifestPath2 = import_path7.default.join(process.cwd(), "manifest.json"), debounceTimer = null, watcher = import_fs5.default.watch(manifestPath2, async (eventType) => {
+  let manifestPath2 = import_path11.default.join(process.cwd(), "manifest.json"), debounceTimer = null, watcher = import_fs9.default.watch(manifestPath2, async (eventType) => {
     eventType === "change" && (debounceTimer && clearTimeout(debounceTimer), debounceTimer = setTimeout(async () => {
       try {
         logger_default.newLine(), logger_default.info("Manifest file changed, validating..."), await manifestManager.validate(), logger_default.info("Regenerating debug config..."), await createDebugConfig(), logger_default.success("Debug config regenerated successfully");
@@ -1365,53 +2284,71 @@ Please stop the existing instance before starting a new one.
 If you lost the terminal tab, you can kill the process with:
   kill ${runningPid}`
   ), process.exit(1));
-  let configPath = import_path8.default.join(process.cwd(), CONFIG_FILE_NAME);
+  let configPath = import_path12.default.join(process.cwd(), CONFIG_FILE_NAME);
   options.lint && await manifestManager.validate(), await createDebugConfig();
   let watcher = watchManifest(), cleanup = () => {
-    watcher.close(), import_fs6.default.existsSync(configPath) && import_fs6.default.unlinkSync(configPath), removeLockFile();
+    watcher.close(), import_fs10.default.existsSync(configPath) && import_fs10.default.unlinkSync(configPath), removeLockFile();
   };
-  registerCleanup(cleanup), createLockFile(), await execCommand(pluginCmd.dev), cleanup();
+  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();
 }
 
 // src/commands/lint.ts
+init_manifestManager();
+init_execCommand();
 init_logger();
+init_templateCommands();
 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/utils/copyTemplateFiles.ts
-var import_fs7 = require("fs"), import_promises2 = require("fs/promises");
+var import_fs11 = require("fs"), import_promises3 = require("fs/promises");
 var copyTemplateFiles = async (filenames) => {
   await Promise.all(
     filenames.map(async (filename) => {
       let templatePath = getTemplatePath(filename), targetPath = `./${filename}`;
-      if ((0, import_fs7.existsSync)(templatePath) && (0, import_fs7.existsSync)(targetPath)) {
-        let content = await (0, import_promises2.readFile)(templatePath), rewritten = applySubstitutions2(filename, content);
-        await (0, import_promises2.writeFile)(targetPath, rewritten);
+      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);
       }
     })
   );
 };
 
 // src/commands/up/utils/updateManifestCompatibility.ts
+init_manifestManager();
+function addDefaultContextLevel(slots) {
+  if (!slots)
+    return;
+  let updatedSlots = {}, updates = [];
+  for (let [service, serviceSlots] of Object.entries(slots))
+    if (serviceSlots) {
+      updatedSlots[service] = {};
+      for (let [slot, slotConfigs] of Object.entries(serviceSlots))
+        slotConfigs && (updatedSlots[service][slot] = slotConfigs.map((slotConfig) => "contextLevel" in slotConfig ? slotConfig : (updates.push(slotConfig), Object.assign({}, slotConfig, { contextLevel: "basic" }))));
+    }
+  return updates.length > 0 ? updatedSlots : void 0;
+}
 async function updateManifestCompatibility() {
   let manifest = await manifestManager.load(), updates = {};
-  "manifest_version" in manifest || (updates.manifest_version = 1), "supported_services" in manifest || (updates.supported_services = ["tracker"]), Object.keys(updates).length > 0 && await manifestManager.update(updates);
+  "manifest_version" in manifest || (updates.manifest_version = 1), "supported_services" in manifest || (updates.supported_services = ["tracker"]);
+  let updatedSlots = addDefaultContextLevel(manifest.slots);
+  updatedSlots && (updates.slots = updatedSlots), Object.keys(updates).length > 0 && await manifestManager.update(updates);
 }
 
 // src/commands/up/utils/updatePackageDependencies.ts
-var import_fs8 = require("fs"), import_promises3 = require("fs/promises");
+var import_fs12 = require("fs"), import_promises4 = require("fs/promises");
 var updatePackageDependencies = async (dependencies) => {
   let packageJsonPath = "./package.json", templatePackageJsonPath = getTemplatePath("package.json");
-  if (!(0, import_fs8.existsSync)(packageJsonPath) || !(0, import_fs8.existsSync)(templatePackageJsonPath))
+  if (!(0, import_fs12.existsSync)(packageJsonPath) || !(0, import_fs12.existsSync)(templatePackageJsonPath))
     return;
-  let packageJsonContent = await (0, import_promises3.readFile)(packageJsonPath, "utf-8"), templatePackageJsonRaw = await (0, import_promises3.readFile)(templatePackageJsonPath), templatePackageJsonContent = applySubstitutions2(
+  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;
   dependencies.forEach((dep) => {
     packageJson.dependencies?.[dep] && templatePackageJson.dependencies?.[dep] && packageJson.dependencies[dep] !== templatePackageJson.dependencies[dep] && (packageJson.dependencies[dep] = templatePackageJson.dependencies[dep], updated = !0);
-  }), updated && await (0, import_promises3.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
+  }), updated && await (0, import_promises4.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
 `, "utf-8");
 };
 
@@ -1422,34 +2359,25 @@ async function up() {
 }
 
 // src/utils/getVersion.ts
-var import_fs9 = require("fs"), import_path9 = require("path"), UNKNOWN_VERSION = "unknown", getVersionFromPackageJson = () => {
-  try {
-    let packagePath = (0, import_path9.resolve)(__dirname, "../../package.json");
-    return (0, import_fs9.existsSync)(packagePath) && JSON.parse((0, import_fs9.readFileSync)(packagePath, "utf-8")).version || null;
-  } catch {
-    return null;
+var import_fs13 = require("fs"), import_path13 = 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))
+      try {
+        let pkg = JSON.parse((0, import_fs13.readFileSync)(path18, "utf-8"));
+        if (typeof pkg.version == "string") return pkg.version;
+      } catch {
+      }
   }
-}, getVersion = () => "0.3.0";
+  return null;
+}, getVersion = () => findVersionInPackageJson(__dirname) ?? UNKNOWN_VERSION;
 
 // src/index.ts
 init_verbose();
-
-// src/utils/withErrorHandling.ts
-init_logger();
-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/index.ts
+init_withErrorHandling();
 async function main() {
-  let program = new import_commander.Command(), version = getVersion();
-  await checkUpdate(version), program.name(CLI_NAME2).description(CLI_DESCRIPTION2).version(version), CLI_HELP_TEXT2 && program.addHelpText("before", CLI_HELP_TEXT2), program.hook("preAction", (thisCommand) => {
+  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) => {
     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"