@weavix/cli 0.5.1 → 0.7.0

package/build/index.js

@@ -263,6 +263,7 @@ __export(hosts_exports, {
   getBuckets: () => getBuckets,
   getMdsEndpoint: () => getMdsEndpoint,
   getOAuthTokenUrl: () => getOAuthTokenUrl,
+  getPlatformApiPrefix: () => getPlatformApiPrefix,
   getPlatformBaseUrl: () => getPlatformBaseUrl,
   getPluginDownloadBase: () => getPluginDownloadBase,
   getS3Endpoint: () => getS3Endpoint,
@@ -312,30 +313,25 @@ function getPluginDownloadBase(env) {
   return base;
 }
 function getPlatformBaseUrl() {
-  let cfg = requireConfig();
-  if (!cfg.api?.platformBaseUrl)
-    throw new Error(
-      'Platform API URL is not configured. Run "weavix config set" to configure.'
-    );
-  return cfg.api.platformBaseUrl;
+  return readConfig()?.api?.platformBaseUrl ?? PLATFORM_BASE_URL;
+}
+function getPlatformApiPrefix() {
+  return "/api/cli/v1";
 }
 function getTrackerBaseUrl() {
   return TRACKER_BASE_URL;
 }
 function getOAuthTokenUrl() {
-  let cfg = requireConfig();
-  if (!cfg.auth?.oauthUrl)
-    throw new Error('OAuth URL is not configured. Run "weavix config set" to configure.');
-  return cfg.auth.oauthUrl;
+  return readConfig()?.auth?.oauthUrl ?? OAUTH_TOKEN_URL;
 }
 function getUpdateCheckInfo() {
   return null;
 }
-var TRACKER_BASE_URL, init_hosts = __esm({
+var TRACKER_BASE_URL, PLATFORM_BASE_URL, OAUTH_TOKEN_URL, init_hosts = __esm({
   "src/distributions/external/hosts.ts"() {
     "use strict";
     init_manager();
-    TRACKER_BASE_URL = "https://api.tracker.yandex.net/v3";
+    TRACKER_BASE_URL = "https://api.tracker.yandex.net/v3", PLATFORM_BASE_URL = "https://plugins.cli-api.tracker.yandex.net", OAUTH_TOKEN_URL = "https://oauth.yandex.ru/authorize?response_type=token&client_id=f57901dffe3849cbb3dbb5f616158e28";
   }
 });
 
@@ -2301,14 +2297,34 @@ var init_doctor = __esm({
   }
 });
 
-// src/commands/submit/options.ts
-var import_commander, skipChecksOption, init_options = __esm({
-  "src/commands/submit/options.ts"() {
+// src/distributions/external/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  getAuthHeader: () => getAuthHeader,
+  getPlatformHeaders: () => getPlatformHeaders
+});
+function getAuthHeader() {
+  let token = externalAuthManager.token;
+  return token ? `OAuth ${token}` : null;
+}
+function getPlatformHeaders() {
+  let orgId = readConfig()?.api?.platformOrgId;
+  return orgId ? { "X-Org-ID": orgId } : {};
+}
+var init_auth = __esm({
+  "src/distributions/external/auth.ts"() {
     "use strict";
-    import_commander = require("commander"), skipChecksOption = new import_commander.Option(
-      "--skip-checks",
-      "skip pre-submit validation (manifest, assets, lint, typecheck, tests, audit)"
-    );
+    init_manager();
+    init_authManager();
+  }
+});
+
+// src/distribution/auth.ts
+var impl4, getAuthHeader2, getPlatformHeaders2, init_auth2 = __esm({
+  "src/distribution/auth.ts"() {
+    "use strict";
+    init_flag();
+    impl4 = (init_auth(), __toCommonJS(auth_exports)), { getAuthHeader: getAuthHeader2, getPlatformHeaders: getPlatformHeaders2 } = impl4;
   }
 });
 
@@ -2381,159 +2397,271 @@ var import_picocolors, logger, logger_default, init_logger = __esm({
   }
 });
 
-// src/core/cliConfig/registerCommand.ts
-async function promptString(message, current) {
-  return (await (0, import_prompts.input)({
-    message: current ? `${message} (current: ${current})` : `${message} (optional)`,
-    default: current,
-    required: !1
-  }))?.trim() || void 0;
-}
-async function runConfigSet(cliName) {
-  let existing = readConfig() ?? {};
-  logger_default.info(
-    "Configure CLI overrides. Empty input clears the value (and falls back to defaults where applicable)."
-  );
-  let s3Endpoint = await promptString("S3 endpoint", existing.s3?.endpoint), s3Region = await promptString("S3 region", existing.s3?.region), mdsEndpoint = await promptString("MDS endpoint", existing.mds?.endpoint), productionStatic = await promptString(
-    "Production bucket (static)",
-    existing.buckets?.production?.static
-  ), productionConfig = await promptString(
-    "Production bucket (config)",
-    existing.buckets?.production?.config
-  ), pluginDownloadProduction = await promptString(
-    "Plugin download base URL",
-    existing.pluginDownloadBase?.production
-  ), platformBaseUrl = await promptString(
-    "Platform API base URL",
-    existing.api?.platformBaseUrl
-  ), oauthUrl = await promptString("OAuth token URL", existing.auth?.oauthUrl);
-  writeConfig({
-    s3: { endpoint: s3Endpoint, region: s3Region },
-    mds: { endpoint: mdsEndpoint },
-    buckets: {
-      production: { static: productionStatic, config: productionConfig }
-    },
-    pluginDownloadBase: { production: pluginDownloadProduction },
-    api: { platformBaseUrl },
-    auth: { oauthUrl }
-  }), logger_default.success(`Configuration saved \u2192 ${getConfigPath()}`), logger_default.info(`Inspect with "${cliName} config show" or revert with "${cliName} config clear".`);
-}
-function runConfigShow(cliName) {
-  let cfg = readConfig();
-  if (!cfg) {
-    logger_default.info(
-      `No configuration found at ${getConfigPath()}. Run "${cliName} config set" to create one.`
-    );
-    return;
+// src/distribution/hosts.ts
+var impl5, getS3Endpoint2, getMdsEndpoint2, getS3Region2, getBuckets2, getPluginDownloadBase2, getPlatformBaseUrl2, getPlatformApiPrefix2, getTrackerBaseUrl2, getOAuthTokenUrl2, getUpdateCheckInfo2, init_hosts2 = __esm({
+  "src/distribution/hosts.ts"() {
+    "use strict";
+    init_flag();
+    impl5 = (init_hosts(), __toCommonJS(hosts_exports)), {
+      getS3Endpoint: getS3Endpoint2,
+      getMdsEndpoint: getMdsEndpoint2,
+      getS3Region: getS3Region2,
+      getBuckets: getBuckets2,
+      getPluginDownloadBase: getPluginDownloadBase2,
+      getPlatformBaseUrl: getPlatformBaseUrl2,
+      getPlatformApiPrefix: getPlatformApiPrefix2,
+      getTrackerBaseUrl: getTrackerBaseUrl2,
+      getOAuthTokenUrl: getOAuthTokenUrl2,
+      getUpdateCheckInfo: getUpdateCheckInfo2
+    } = impl5;
   }
-  logger_default.info(`Configuration at ${getConfigPath()}:`), logger_default.info(JSON.stringify(cfg, null, 2));
-}
-function runConfigClear() {
-  clearConfig(), logger_default.success(`Configuration removed (${getConfigPath()})`);
-}
-function registerConfigCommand(program, cliName) {
-  let config = program.command("config").description("manage CLI configuration");
-  config.command("set").description("set CLI configuration values interactively").action(() => runConfigSet(cliName)), config.command("show").description("display current CLI configuration").action(() => runConfigShow(cliName)), config.command("clear").description("remove stored CLI configuration").action(runConfigClear);
-}
-var import_prompts, init_registerCommand = __esm({
-  "src/core/cliConfig/registerCommand.ts"() {
+});
+
+// src/api/constants.ts
+var init_constants2 = __esm({
+  "src/api/constants.ts"() {
     "use strict";
-    import_prompts = require("@inquirer/prompts");
-    init_logger();
-    init_manager();
+    init_hosts2();
+    init_hosts2();
   }
 });
 
-// src/utils/withErrorHandling.ts
-function withErrorHandling(fn) {
-  return async (...args) => {
+// src/api/requestDebug.ts
+function redactHeaders(headers) {
+  let result = {};
+  for (let [key, value] of Object.entries(headers))
+    if (key.toLowerCase() === "authorization") {
+      let [scheme] = value.split(" ");
+      result[key] = scheme ? `${scheme} ${REDACTED}` : REDACTED;
+    } else
+      result[key] = value;
+  return result;
+}
+function formatDebugBody(body, formData) {
+  if (formData) {
+    let size = "";
     try {
-      await fn(...args);
-    } catch (error2) {
-      error2 instanceof Error && error2.name === "ExitPromptError" && process.exit(0), logger_default.error(error2), printErrorHints(error2), process.exit(1);
+      let length = formData.getLengthSync?.();
+      typeof length == "number" && (size = `, ~${length} bytes`);
+    } catch {
     }
-  };
+    return `[multipart/form-data${size}] (binary body, e.g. plugin archive \u2014 not dumped)`;
+  }
+  return typeof body == "string" ? body : "(none)";
 }
-function getErrorMessage2(error2) {
-  return error2 instanceof Error ? error2.message : String(error2);
+function buildFailureDebug(params) {
+  let { method, url, status, headers, body, formData } = params;
+  return [
+    "Platform API request failed \u2014 debug info (Authorization redacted):",
+    `  method:  ${method}`,
+    `  url:     ${url}`,
+    `  status:  ${status ?? "(no HTTP response \u2014 network/transport error)"}`,
+    `  headers: ${JSON.stringify(redactHeaders(headers), null, 2)}`,
+    `  body:    ${formatDebugBody(body, formData)}`
+  ].join(`
+`);
 }
-function printErrorHints(error2) {
-  if (error2 instanceof PackageManagerRuntimeError) {
-    error2.action && logger_default.info(`Action: ${error2.action}`), logger_default.info(`Run ${CLI_NAME2} doctor from the plugin directory for full local diagnostics.`);
-    return;
+var REDACTED, init_requestDebug = __esm({
+  "src/api/requestDebug.ts"() {
+    "use strict";
+    REDACTED = "****redacted****";
   }
-  let message = getErrorMessage2(error2);
-  if (isCorepackKeyIdError(message)) {
-    logger_default.info(`Action: ${getPackageManagerRuntimeAction(message, "pnpm")}`);
-    return;
+});
+
+// src/api/platformApiRequest.ts
+function buildRequestHeaders(headers, formData) {
+  let authHeader = getAuthHeader2();
+  if (!authHeader)
+    throw new Error(`Not authenticated. Run "${CLI_NAME2} login" first.`);
+  let requestHeaders = {
+    Accept: "*/*",
+    Authorization: authHeader,
+    ...getPlatformHeaders2(),
+    ...headers
+  };
+  return formData || (requestHeaders["Content-Type"] = "application/json"), requestHeaders;
+}
+function buildRequestBody(method, body, formData) {
+  if (formData) {
+    let formHeaders = formData.getHeaders?.();
+    return {
+      body: formData,
+      headers: formHeaders || {}
+    };
   }
-  /\b(manifest\.json|manifest validation|package manager|corepack|pnpm|npm|build|dist)\b/i.test(
-    message
-  ) && logger_default.info(`Run ${CLI_NAME2} doctor from the plugin directory for local diagnostics.`);
+  return body && method !== "GET" ? { body: JSON.stringify(body) } : {};
 }
-var init_withErrorHandling = __esm({
-  "src/utils/withErrorHandling.ts"() {
+function buildQueryString2(queryParams) {
+  if (!queryParams || Object.keys(queryParams).length === 0)
+    return "";
+  let params = new URLSearchParams();
+  return Object.entries(queryParams).forEach(([key, value]) => {
+    params.append(key, String(value));
+  }), `?${params.toString()}`;
+}
+async function parseResponse2(response) {
+  return response.status === 204 || response.headers.get("content-length") === "0" ? void 0 : response.headers.get("content-type")?.includes("application/json") ? await response.json() : await response.text();
+}
+async function platformApiRequest(endpoint, options = {}) {
+  let { method = "GET", body, headers = {}, formData, queryParams } = options, requestHeaders = buildRequestHeaders(headers, formData), { body: requestBody, headers: additionalHeaders } = buildRequestBody(
+    method,
+    body,
+    formData
+  ), requestOptions = {
+    method,
+    headers: { ...requestHeaders, ...additionalHeaders },
+    body: requestBody
+  }, queryString = buildQueryString2(queryParams), url = `${getPlatformBaseUrl2()}${getPlatformApiPrefix2()}${endpoint}${queryString}`, controller = new AbortController(), timeout = setTimeout(() => controller.abort(), PLATFORM_API_TIMEOUT_MS), responseStatus;
+  if (isVerboseEnabled() && (logger_default.info(
+    `[platform-api-debug] Request: method=${method} url=${url} hasBody=${!!body} hasFormData=${!!formData} timeoutMs=${PLATFORM_API_TIMEOUT_MS}`
+  ), body !== void 0 && logger_default.info(`[platform-api-debug] Request body: ${JSON.stringify(body)}`), formData)) {
+    let debugPath = writeVerboseArtifact(
+      "requests/latest-form-data.txt",
+      `method=${method}
+url=${url}
+headers=${JSON.stringify({ ...requestHeaders, ...additionalHeaders }, null, 2)}
+formData=present
+`
+    );
+    logger_default.info(`[platform-api-debug] Saved form-data request metadata to ${debugPath}`);
+  }
+  try {
+    let response = await (0, import_node_fetch2.default)(url, {
+      ...requestOptions,
+      signal: controller.signal
+    });
+    if (responseStatus = response.status, isVerboseEnabled() && logger_default.info(
+      `[platform-api-debug] Response: method=${method} url=${url} status=${response.status} contentType=${response.headers.get("content-type") ?? "n/a"}`
+    ), !response.ok) {
+      let errorText = await response.text(), errorMessage = errorText;
+      try {
+        let errorJson = JSON.parse(errorText);
+        errorJson.message && (errorMessage = errorJson.message);
+      } catch {
+      }
+      throw new Error(`HTTP ${response.status} ${response.statusText}: ${errorMessage}`);
+    }
+    return parseResponse2(response);
+  } catch (error2) {
+    throw logger_default.error(
+      buildFailureDebug({
+        method,
+        url,
+        status: responseStatus,
+        headers: requestOptions.headers,
+        body: requestBody,
+        formData
+      })
+    ), error2 instanceof Error && error2.name === "AbortError" ? new Error(
+      `Platform API request timed out after ${PLATFORM_API_TIMEOUT_MS}ms: ${method} ${url}`
+    ) : error2;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+var import_node_fetch2, PLATFORM_API_TIMEOUT_MS, init_platformApiRequest = __esm({
+  "src/api/platformApiRequest.ts"() {
     "use strict";
+    import_node_fetch2 = __toESM(require("node-fetch"));
+    init_auth2();
     init_meta2();
     init_logger();
-    init_packageManager();
+    init_verbose();
+    init_constants2();
+    init_requestDebug();
+    PLATFORM_API_TIMEOUT_MS = Number(process.env.TRACKER_CLI_PLATFORM_TIMEOUT_MS || 3e4);
   }
 });
 
-// src/core/pluginState/pluginStateManager.ts
-var import_fs9, import_promises2, STATE_FILE, load2, save2, update2, pluginStateManager, init_pluginStateManager = __esm({
-  "src/core/pluginState/pluginStateManager.ts"() {
+// src/api/platform.ts
+async function createPlugin(archiveBuffer, archiveName) {
+  let formData = new import_form_data.default();
+  return formData.append("archive", archiveBuffer, {
+    filename: archiveName,
+    contentType: "application/zip"
+  }), platformApiRequest("/plugins", {
+    method: "POST",
+    formData
+  });
+}
+async function updatePluginArchive(pluginId, archiveBuffer, archiveName) {
+  let formData = new import_form_data.default();
+  return formData.append("archive", archiveBuffer, {
+    filename: archiveName,
+    contentType: "application/zip"
+  }), platformApiRequest(`/plugins/${pluginId}/archive`, {
+    method: "PUT",
+    formData
+  });
+}
+async function updateCatalogEntry(pluginId, catalogData) {
+  return platformApiRequest(`/plugins/${pluginId}/catalog-entry`, {
+    method: "PUT",
+    body: catalogData
+  });
+}
+async function updateCatalogImage(pluginId, imageBuffer, imageName) {
+  let formData = new import_form_data.default();
+  return formData.append("image", imageBuffer, {
+    filename: imageName,
+    contentType: "image/jpeg"
+  }), platformApiRequest(`/plugins/${pluginId}/catalog-image`, {
+    method: "PUT",
+    formData
+  });
+}
+async function submitPlugin(pluginId, version) {
+  return platformApiRequest(`/plugins/${pluginId}/submit`, {
+    method: "POST",
+    queryParams: {
+      version
+    }
+  });
+}
+async function getPluginInfo(pluginId) {
+  return platformApiRequest(`/plugins/${pluginId}`, {
+    method: "GET"
+  });
+}
+async function getMyPlugins() {
+  return platformApiRequest("/plugins/my", {
+    method: "GET"
+  });
+}
+async function checkSlugAvailability(slug) {
+  return platformApiRequest(`/slugs/${slug}/available`, {
+    method: "GET"
+  });
+}
+var import_form_data, init_platform = __esm({
+  "src/api/platform.ts"() {
     "use strict";
-    import_fs9 = require("fs"), import_promises2 = require("fs/promises"), STATE_FILE = ".tracker-plugin", load2 = async () => {
-      if (!(0, import_fs9.existsSync)(STATE_FILE))
-        return {};
-      try {
-        let content = await (0, import_promises2.readFile)(STATE_FILE, "utf8");
-        return JSON.parse(content);
-      } catch {
-        return {};
-      }
-    }, save2 = async (state) => {
-      try {
-        let content = JSON.stringify(state, null, 4);
-        await (0, import_promises2.writeFile)(STATE_FILE, content, "utf8");
-      } catch (error2) {
-        throw error2 instanceof Error ? new Error(`Error saving ${STATE_FILE}: ${error2.message}`) : new Error(`Error saving ${STATE_FILE}`);
-      }
-    }, update2 = async (updates) => {
-      let updated = { ...await load2(), ...updates };
-      return await save2(updated), updated;
-    }, pluginStateManager = {
-      load: load2,
-      save: save2,
-      update: update2
-    };
+    import_form_data = __toESM(require("form-data"));
+    init_platformApiRequest();
   }
 });
 
-// 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";
+// src/utils/getPluginId.ts
+async function getPluginId(pluginId) {
+  if (pluginId)
+    return pluginId;
+  try {
+    let manifest = await manifestManager.load();
+    if (!manifest.id)
+      throw new Error("Plugin ID not found in manifest.json");
+    return manifest.id;
+  } catch {
+    throw new Error("Plugin ID must be provided as argument or present in manifest.json");
   }
 }
+var init_getPluginId = __esm({
+  "src/utils/getPluginId.ts"() {
+    "use strict";
+    init_manifestManager();
+  }
+});
+
+// src/api/utils.ts
 var init_utils = __esm({
   "src/api/utils.ts"() {
     "use strict";
@@ -2541,22 +2669,33 @@ var init_utils = __esm({
 });
 
 // src/utils/pluginDisplay.ts
-function showTrackerPluginList(issues) {
-  if (!issues || issues.length === 0) {
+function showPluginInfo(data) {
+  printHeader("\u{1F4E6} Plugin"), logger_default.newLine(), printPluginId(data.id), printField("Slug", import_picocolors2.default.magenta(data.slug)), printField("Name", import_picocolors2.default.white(data.name)), printField("Status", getStatusBadgeByLabel(data.status.toUpperCase())), data.moderationTicketKey && printField("Moderation", import_picocolors2.default.cyan(data.moderationTicketKey)), data.createdAt && printCreated(data.createdAt), data.updatedAt && printUpdated(data.updatedAt);
+}
+function showPluginVersions(versions) {
+  if (!versions || versions.length === 0) {
+    console.info(import_picocolors2.default.dim("  No versions found")), logger_default.newLine();
+    return;
+  }
+  printHeader(`\u{1F9FE} Versions \xB7 ${versions.length}`), logger_default.newLine(), versions.forEach((version, index) => {
+    console.info(`  ${import_picocolors2.default.bold(String(index + 1) + ".")} ${import_picocolors2.default.cyan(version.versionId)}`), printField("Status", getStatusBadgeByLabel(version.status.toUpperCase())), printField("Version", import_picocolors2.default.white(version.version)), printCreated(version.createdAt), logger_default.newLine();
+  });
+}
+function showPluginList(plugins) {
+  if (!plugins || plugins.length === 0) {
     console.info(import_picocolors2.default.dim("  No plugins found")), logger_default.newLine();
     return;
   }
-  printHeader(`\u{1F4CB} Your Plugins \xB7 ${issues.length}`), logger_default.newLine(), issues.forEach((issue) => {
-    let slugMatch = issue.summary.match(/^Plugin:\s*(.+)$/), slug = slugMatch ? import_picocolors2.default.magenta(slugMatch[1].trim()) : import_picocolors2.default.dim(issue.summary), statusBadge2 = getTrackerIssueBadge(issue);
+  printHeader(`\u{1F4CB} Your Plugins \xB7 ${plugins.length}`), logger_default.newLine(), plugins.forEach((plugin) => {
     console.info(
-      `  ${slug}  ${import_picocolors2.default.dim("\xB7")}  ${statusBadge2}  ${import_picocolors2.default.dim("\xB7")}  ${import_picocolors2.default.dim(issue.key)}`
+      `  ${import_picocolors2.default.magenta(plugin.slug)}  ${import_picocolors2.default.dim("\xB7")}  ${getStatusBadgeByLabel(plugin.status.toUpperCase())}  ${import_picocolors2.default.dim("\xB7")}  ${import_picocolors2.default.cyan(plugin.id)}`
     ), 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);
+function showPluginCreated(data) {
+  printSuccessHeader("\u2705 Plugin Created"), logger_default.newLine(), printPluginId(data.id);
 }
-var import_picocolors2, printHeader, getTrackerIssueBadge, formatDate, printField, printCreated, printUpdated, init_pluginDisplay = __esm({
+var import_picocolors2, printHeader, printSuccessHeader, getStatusBadgeByLabel, formatDate, printField, printPluginId, printCreated, printUpdated, init_pluginDisplay = __esm({
   "src/utils/pluginDisplay.ts"() {
     "use strict";
     import_picocolors2 = __toESM(require("picocolors"));
@@ -2564,24 +2703,11 @@ var import_picocolors2, printHeader, getTrackerIssueBadge, formatDate, printFiel
     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} `));
-      }
+    }, printSuccessHeader = (title) => {
+      console.info(import_picocolors2.default.bold(import_picocolors2.default.green(title)));
+    }, getStatusBadgeByLabel = (label) => {
+      let normalized = label.toLowerCase();
+      return normalized.includes("approved") ? import_picocolors2.default.black(import_picocolors2.default.bgGreen(` ${label} `)) : normalized.includes("pending") || normalized.includes("review") ? import_picocolors2.default.black(import_picocolors2.default.bgYellow(` ${label} `)) : normalized.includes("rejected") ? import_picocolors2.default.white(import_picocolors2.default.bgRed(` ${label} `)) : normalized.includes("draft") || normalized.includes("unknown") ? import_picocolors2.default.black(import_picocolors2.default.bgWhite(` ${label} `)) : import_picocolors2.default.black(import_picocolors2.default.bgBlue(` ${label} `));
     }, formatDate = (dateString) => dateString ? new Date(dateString).toLocaleString("ru-RU", {
       year: "numeric",
       month: "2-digit",
@@ -2590,6 +2716,8 @@ var import_picocolors2, printHeader, getTrackerIssueBadge, formatDate, printFiel
       minute: "2-digit"
     }) : "-", printField = (label, value, minWidth = 12) => {
       console.info(`  ${import_picocolors2.default.dim(label.padEnd(minWidth))} ${value}`);
+    }, printPluginId = (pluginId) => {
+      printField("Plugin ID", import_picocolors2.default.cyan(pluginId));
     }, printCreated = (createdAt) => {
       printField("Created", import_picocolors2.default.white(formatDate(createdAt)));
     }, printUpdated = (updatedAt) => {
@@ -2598,218 +2726,54 @@ var import_picocolors2, printHeader, getTrackerIssueBadge, formatDate, printFiel
   }
 });
 
-// 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}...`);
+// src/commands/info/platform.ts
+async function infoPlatform(pluginId) {
+  let actualPluginId = await getPluginId(pluginId);
+  logger_default.info(`\u23F3 Fetching plugin info for ID: ${actualPluginId}...`);
   try {
-    let issue = await getIssue(targetIssueKey);
-    showTrackerPluginInfo(issue);
+    let pluginInfo = await getPluginInfo(actualPluginId);
+    showPluginInfo(pluginInfo), pluginInfo.versions && pluginInfo.versions.length > 0 && (logger_default.newLine(), showPluginVersions(pluginInfo.versions));
   } catch (error2) {
-    throw logger_default.error(`Failed to fetch plugin info for ${targetIssueKey}`), error2;
+    throw logger_default.error(`Failed to fetch plugin info for ID: ${actualPluginId}`), error2;
   }
 }
-var init_info = __esm({
-  "src/distributions/external/info.ts"() {
+var init_platform2 = __esm({
+  "src/commands/info/platform.ts"() {
     "use strict";
-    init_pluginStateManager();
+    init_platform();
+    init_getPluginId();
     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...");
+// src/commands/list/platform.ts
+async function listPlatform() {
+  logger_default.info("\u23F3 Fetching my plugins...");
   try {
-    let issues = await getMyPluginIssues();
-    showTrackerPluginList(issues);
+    let plugins = await getMyPlugins();
+    showPluginList(plugins);
   } catch (error2) {
     throw logger_default.error("Failed to fetch plugins list"), error2;
   }
 }
-var init_list = __esm({
-  "src/distributions/external/list.ts"() {
+var init_platform3 = __esm({
+  "src/commands/list/platform.ts"() {
     "use strict";
+    init_platform();
     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"() {
+// src/commands/submit/options.ts
+var import_commander, skipChecksOption, init_options = __esm({
+  "src/commands/submit/options.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
-      );
-    };
+    import_commander = require("commander"), skipChecksOption = new import_commander.Option(
+      "--skip-checks",
+      "skip pre-submit validation (manifest, assets, lint, typecheck, tests, audit)"
+    );
   }
 });
 
@@ -2836,14 +2800,38 @@ function validateArchiveSources() {
     "Source folder not found. Add ./src before publishing."
   ), ensurePathExists(import_path9.default.resolve(MANIFEST_FILE2), "manifest.json not found in plugin root."), validateMarketplaceAssets();
 }
-var import_fs10, import_path9, MARKETPLACE_DIR, MARKETPLACE_INDEX_FILE, MARKETPLACE_HEADER_IMAGE_FILE, PUBLIC_DIR, PUBLIC_LOGO_FILE, MANIFEST_FILE2, DIST_DIR, SRC_DIR, ensurePathExists, validateManifestPublishingFields, ensureManifestCatalogFields, marketplacePaths, init_marketplace = __esm({
+async function getMarketplaceCatalogEntry() {
+  let indexPath = import_path9.default.resolve(MARKETPLACE_DIR, MARKETPLACE_INDEX_FILE);
+  ensurePathExists(
+    indexPath,
+    "Marketplace description not found. Add ./marketplace/index.md before uploading."
+  ), await validateManifestPublishingFields();
+  let longDescription = import_fs9.default.readFileSync(indexPath, "utf-8").trim(), manifest = await manifestManager.load();
+  return {
+    name: manifest.name.ru,
+    description: manifest.description.ru,
+    longDescription,
+    tags: manifest.keywords ?? []
+  };
+}
+function getMarketplaceHeaderImage() {
+  let imagePath = import_path9.default.resolve(MARKETPLACE_DIR, MARKETPLACE_HEADER_IMAGE_FILE);
+  return ensurePathExists(
+    imagePath,
+    "Marketplace header image not found. Add ./marketplace/header-image.jpg before uploading."
+  ), {
+    buffer: import_fs9.default.readFileSync(imagePath),
+    filename: MARKETPLACE_HEADER_IMAGE_FILE
+  };
+}
+var import_fs9, import_path9, MARKETPLACE_DIR, MARKETPLACE_INDEX_FILE, MARKETPLACE_HEADER_IMAGE_FILE, PUBLIC_DIR, PUBLIC_LOGO_FILE, MANIFEST_FILE2, DIST_DIR, SRC_DIR, ensurePathExists, validateManifestPublishingFields, ensureManifestCatalogFields, marketplacePaths, init_marketplace = __esm({
   "src/utils/marketplace.ts"() {
     "use strict";
-    import_fs10 = __toESM(require("fs")), import_path9 = __toESM(require("path"));
+    import_fs9 = __toESM(require("fs")), import_path9 = __toESM(require("path"));
     init_manifestManager();
     init_logger();
     MARKETPLACE_DIR = "marketplace", MARKETPLACE_INDEX_FILE = "index.md", MARKETPLACE_HEADER_IMAGE_FILE = "header-image.jpg", PUBLIC_DIR = "public", PUBLIC_LOGO_FILE = "logo.svg", MANIFEST_FILE2 = "manifest.json", DIST_DIR = "dist", SRC_DIR = "src", ensurePathExists = (targetPath, errorMessage) => {
-      import_fs10.default.existsSync(targetPath) || (logger_default.error(errorMessage), process.exit(1));
+      import_fs9.default.existsSync(targetPath) || (logger_default.error(errorMessage), process.exit(1));
     }, validateManifestPublishingFields = async () => {
       let manifest = await manifestManager.load();
       ensureManifestCatalogFields(manifest);
@@ -2863,18 +2851,128 @@ var import_fs10, import_path9, MARKETPLACE_DIR, MARKETPLACE_INDEX_FILE, MARKETPL
   }
 });
 
+// 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/**"],
+      dot: !1
+    });
+    for (let dotfile of [".npmrc", ".nvmrc"]) {
+      let dotfilePath = import_path10.default.resolve(dotfile);
+      import_fs10.default.existsSync(dotfilePath) && archive.file(dotfilePath, { name: dotfile });
+    }
+    archive.file(import_path10.default.resolve(marketplacePaths.manifestFile), { name: "src/manifest.json" }), archive.glob(
+      "**/*",
+      {
+        cwd: import_path10.default.resolve(marketplacePaths.distDir),
+        dot: !1
+      },
+      { prefix: "dist/" }
+    ), archive.finalize();
+  });
+}
+var import_fs10, import_path10, import_archiver, init_buildArchive = __esm({
+  "src/utils/buildArchive.ts"() {
+    "use strict";
+    import_fs10 = __toESM(require("fs")), import_path10 = __toESM(require("path")), import_archiver = __toESM(require("archiver"));
+    init_manifestManager();
+    init_meta2();
+    init_logger();
+    init_marketplace();
+    init_verbose();
+  }
+});
+
+// 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
+function getPluginCommands(projectRoot = process.cwd()) {
+  return COMMANDS[detectPackageManager(projectRoot)];
+}
+var COMMANDS, pluginCmd, init_templateCommands = __esm({
+  "src/commands/constants/templateCommands.ts"() {
+    "use strict";
+    init_packageManager();
+    COMMANDS = {
+      npm: {
+        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"
+      },
+      pnpm: {
+        install: "pnpm install",
+        build: "pnpm run build",
+        dev: "pnpm run dev",
+        lint: "pnpm run lint",
+        typecheck: "pnpm run typecheck",
+        test: "pnpm test",
+        audit: "pnpm audit --audit-level=critical"
+      }
+    };
+    pluginCmd = COMMANDS.npm;
+  }
+});
+
+// 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...");
+      let pluginCmd2 = getPluginCommands();
+      await execCommand(pluginCmd2.install), await execCommand(
+        pluginCmd2.build,
+        process.cwd(),
+        environment ? { VITE_DEPLOY_ENV: environment } : void 0
+      );
+    };
+  }
+});
+
 // src/utils/pluginPackageScripts.ts
 function readPluginPackageScripts(cwd = process.cwd()) {
-  let packageJsonPath = import_path10.default.join(cwd, "package.json");
+  let packageJsonPath = import_path11.default.join(cwd, "package.json");
   return import_fs11.default.existsSync(packageJsonPath) ? JSON.parse(import_fs11.default.readFileSync(packageJsonPath, "utf-8")).scripts ?? {} : null;
 }
 function hasPluginScript(name, cwd = process.cwd()) {
   return !!readPluginPackageScripts(cwd)?.[name];
 }
-var import_fs11, import_path10, init_pluginPackageScripts = __esm({
+var import_fs11, import_path11, init_pluginPackageScripts = __esm({
   "src/utils/pluginPackageScripts.ts"() {
     "use strict";
-    import_fs11 = __toESM(require("fs")), import_path10 = __toESM(require("path"));
+    import_fs11 = __toESM(require("fs")), import_path11 = __toESM(require("path"));
   }
 });
 
@@ -2884,16 +2982,18 @@ async function runSubmitPrechecks(options = {}) {
     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 () => {
+  logger_default.separator(), logger_default.info("\u{1F50D} Pre-submit checks"), logger_default.separator();
+  let pluginCmd2 = getPluginCommands();
+  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(
+  }), await runShellStep("Install dependencies", pluginCmd2.install), await runShellStep("Run linter", pluginCmd2.lint), hasPluginScript("typecheck") ? await runShellStep("Run typecheck", pluginCmd2.typecheck) : logger_default.verbose('Skipping typecheck (no "typecheck" script in package.json).'), hasPluginScript("test") ? await runShellStep("Run tests", pluginCmd2.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();
+  ), await runShellStep("Check dependency vulnerabilities", pluginCmd2.audit), logger_default.separator(), logger_default.success("Pre-submit checks passed"), logger_default.separator();
 }
-var import_picocolors4, stepStart, stepDone, runStep, runShellStep, init_runSubmitPrechecks = __esm({
+var import_picocolors3, stepStart, stepDone, runStep, runShellStep, init_runSubmitPrechecks = __esm({
   "src/commands/submit/utils/runSubmitPrechecks.ts"() {
     "use strict";
-    import_picocolors4 = __toESM(require("picocolors"));
+    import_picocolors3 = __toESM(require("picocolors"));
     init_manifestManager();
     init_execCommand();
     init_logger();
@@ -2901,128 +3001,222 @@ var import_picocolors4, stepStart, stepDone, runStep, runShellStep, init_runSubm
     init_pluginPackageScripts();
     init_templateCommands();
     stepStart = (label) => {
-      console.info(`${import_picocolors4.default.cyan("\u25B8")} ${label}`);
+      console.info(`${import_picocolors3.default.cyan("\u25B8")} ${label}`);
     }, stepDone = (label) => {
-      console.info(`${import_picocolors4.default.green("\u2713")} ${label}`), console.info("");
+      console.info(`${import_picocolors3.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);
+      stepStart(label), console.info(import_picocolors3.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/**"],
-      dot: !1
+// src/commands/submit/utils/validateSlug.ts
+function promptForSlug() {
+  return new Promise((resolve2) => {
+    let rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question("Enter a new slug: ", (answer) => {
+      rl.close(), resolve2(answer.trim());
     });
-    for (let dotfile of [".npmrc", ".nvmrc"]) {
-      let dotfilePath = import_path11.default.resolve(dotfile);
-      import_fs12.default.existsSync(dotfilePath) && archive.file(dotfilePath, { name: dotfile });
-    }
-    archive.file(import_path11.default.resolve(marketplacePaths.manifestFile), { name: "src/manifest.json" }), archive.glob(
-      "**/*",
-      {
-        cwd: import_path11.default.resolve(marketplacePaths.distDir),
-        dot: !1
-      },
-      { prefix: "dist/" }
-    ), archive.finalize();
   });
 }
-var import_fs12, import_path11, import_archiver, init_buildArchive = __esm({
-  "src/utils/buildArchive.ts"() {
+async function validateAndGetUniqueSlug(currentSlug) {
+  let slugToCheck = currentSlug, isValid = !1;
+  for (; !isValid; )
+    try {
+      if ((await checkSlugAvailability(slugToCheck)).available)
+        return isValid = !0, slugToCheck;
+      logger_default.error(`\u274C Slug "${slugToCheck}" is already taken.`), logger_default.info("Please enter a different slug."), slugToCheck = await promptForSlug(), slugToCheck || (logger_default.error("Slug cannot be empty. Please try again."), slugToCheck = currentSlug);
+    } catch (error2) {
+      throw logger_default.error(`Failed to check slug availability: ${error2.message}`), error2;
+    }
+  return slugToCheck;
+}
+var readline, init_validateSlug = __esm({
+  "src/commands/submit/utils/validateSlug.ts"() {
     "use strict";
-    import_fs12 = __toESM(require("fs")), import_path11 = __toESM(require("path")), import_archiver = __toESM(require("archiver"));
+    readline = __toESM(require("readline"));
+    init_platform();
+    init_logger();
+  }
+});
+
+// src/commands/submit/platform.ts
+async function submitPlatform(options = {}) {
+  await runSubmitPrechecks({ skip: options.skipChecks });
+  let manifest = await manifestManager.load();
+  await build(), logger_default.info("\u{1F4E6} Creating archive...");
+  let archiveBuffer = await buildArchive(), archiveName = `${manifest.slug}-${manifest.version}.zip`, pluginId;
+  if (manifest.id)
+    pluginId = manifest.id, logger_default.info("\u{1F4E4} Updating plugin archive..."), await updatePluginArchive(pluginId, archiveBuffer, archiveName);
+  else {
+    let validatedSlug = await validateAndGetUniqueSlug(manifest.slug);
+    validatedSlug !== manifest.slug && await manifestManager.update({ slug: validatedSlug }), logger_default.info("\u23F3 Creating plugin...");
+    let createdPlugin = await createPlugin(archiveBuffer, archiveName);
+    showPluginCreated(createdPlugin), pluginId = createdPlugin.id, await manifestManager.update({ id: pluginId });
+  }
+  let catalogEntry = await getMarketplaceCatalogEntry();
+  logger_default.info("\u{1F4DD} Updating catalog entry from ./marketplace/index.md..."), await updateCatalogEntry(pluginId, catalogEntry);
+  let headerImage = getMarketplaceHeaderImage();
+  logger_default.info("\u{1F5BC}\uFE0F Uploading catalog image from ./marketplace/header-image.jpg..."), await updateCatalogImage(pluginId, headerImage.buffer, headerImage.filename), await submitPlugin(pluginId, manifest.version), logger_default.success("Plugin submitted for review!"), logger_default.info(`  Version       : ${manifest.version}`), logger_default.newLine();
+}
+var init_platform4 = __esm({
+  "src/commands/submit/platform.ts"() {
+    "use strict";
+    init_platform();
     init_manifestManager();
-    init_meta2();
+    init_buildArchive();
     init_logger();
     init_marketplace();
-    init_verbose();
+    init_pluginDisplay();
+    init_build();
+    init_runSubmitPrechecks();
+    init_validateSlug();
   }
 });
 
-// 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)
+// src/core/cliConfig/registerCommand.ts
+async function promptString(message, current) {
+  return (await (0, import_prompts.input)({
+    message: current ? `${message} (current: ${current})` : `${message} (optional)`,
+    default: current,
+    required: !1
+  }))?.trim() || void 0;
+}
+async function runConfigSet(cliName) {
+  let existing = readConfig() ?? {};
+  logger_default.info(
+    "Configure CLI overrides. Empty input clears the value (and falls back to defaults where applicable)."
+  );
+  let s3Endpoint = await promptString("S3 endpoint", existing.s3?.endpoint), s3Region = await promptString("S3 region", existing.s3?.region), mdsEndpoint = await promptString("MDS endpoint", existing.mds?.endpoint), productionStatic = await promptString(
+    "Production bucket (static)",
+    existing.buckets?.production?.static
+  ), productionConfig = await promptString(
+    "Production bucket (config)",
+    existing.buckets?.production?.config
+  ), pluginDownloadProduction = await promptString(
+    "Plugin download base URL",
+    existing.pluginDownloadBase?.production
+  ), platformBaseUrl = await promptString(
+    "Platform API base URL",
+    existing.api?.platformBaseUrl
+  ), oauthUrl = await promptString("OAuth token URL", existing.auth?.oauthUrl);
+  writeConfig({
+    s3: { endpoint: s3Endpoint, region: s3Region },
+    mds: { endpoint: mdsEndpoint },
+    buckets: {
+      production: { static: productionStatic, config: productionConfig }
+    },
+    pluginDownloadBase: { production: pluginDownloadProduction },
+    api: { platformBaseUrl },
+    auth: { oauthUrl }
+  }), logger_default.success(`Configuration saved \u2192 ${getConfigPath()}`), logger_default.info(`Inspect with "${cliName} config show" or revert with "${cliName} config clear".`);
+}
+function runConfigShow(cliName) {
+  let cfg = readConfig();
+  if (!cfg) {
+    logger_default.info(
+      `No configuration found at ${getConfigPath()}. Run "${cliName} config set" to create one.`
+    );
+    return;
+  }
+  logger_default.info(`Configuration at ${getConfigPath()}:`), logger_default.info(JSON.stringify(cfg, null, 2));
+}
+function runConfigClear() {
+  clearConfig(), logger_default.success(`Configuration removed (${getConfigPath()})`);
+}
+function registerConfigCommand(program, cliName) {
+  let config = program.command("config").description("manage CLI configuration");
+  config.command("set").description("set CLI configuration values interactively").action(() => runConfigSet(cliName)), config.command("show").description("display current CLI configuration").action(() => runConfigShow(cliName)), config.command("clear").description("remove stored CLI configuration").action(runConfigClear);
+}
+var import_prompts, init_registerCommand = __esm({
+  "src/core/cliConfig/registerCommand.ts"() {
+    "use strict";
+    import_prompts = require("@inquirer/prompts");
+    init_logger();
+    init_manager();
+  }
+});
+
+// src/utils/withErrorHandling.ts
+function withErrorHandling(fn) {
+  return async (...args) => {
     try {
-      await getIssue(issueKey);
-    } catch {
-      issueKey = void 0;
+      await fn(...args);
+    } catch (error2) {
+      error2 instanceof Error && error2.name === "ExitPromptError" && process.exit(0), logger_default.error(error2), printErrorHints(error2), process.exit(1);
     }
-  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."
-    );
+  };
+}
+function getErrorMessage2(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function printErrorHints(error2) {
+  if (error2 instanceof PackageManagerRuntimeError) {
+    error2.action && logger_default.info(`Action: ${error2.action}`), logger_default.info(`Run ${CLI_NAME2} doctor from the plugin directory for full local diagnostics.`);
     return;
-  } 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}`
-    );
+  }
+  let message = getErrorMessage2(error2);
+  if (isCorepackKeyIdError(message)) {
+    logger_default.info(`Action: ${getPackageManagerRuntimeAction(message, "pnpm")}`);
+    return;
+  }
+  /\b(manifest\.json|manifest validation|package manager|corepack|pnpm|npm|build|dist)\b/i.test(
+    message
+  ) && logger_default.info(`Run ${CLI_NAME2} doctor from the plugin directory for local diagnostics.`);
+}
+var init_withErrorHandling = __esm({
+  "src/utils/withErrorHandling.ts"() {
+    "use strict";
+    init_meta2();
+    init_logger();
+    init_packageManager();
+  }
+});
+
+// src/distributions/external/login.ts
+async function loginExternal() {
+  let tokenUrl = getOAuthTokenUrl();
+  console.info(
+    import_picocolors4.default.dim("Get your OAuth token at: ") + import_picocolors4.default.cyan(`${ESC}]8;;${tokenUrl}${BEL}${tokenUrl}${ESC}]8;;${BEL}`)
+  ), console.info("");
+  let token = await (0, import_prompts2.input)({
+    message: "Enter your OAuth token:",
+    required: !0
+  }), orgId = await (0, import_prompts2.input)({
+    message: "Enter your Organization ID (X-Org-ID):",
+    required: !0
+  });
+  externalAuthManager.saveAuthData(token.trim());
+  let cfg = readConfig() ?? {};
+  writeConfig({ ...cfg, api: { ...cfg.api, platformOrgId: orgId.trim() } }), logger_default.success("OAuth token and organization ID 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;
   }
-  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();
+  externalAuthManager.removeAuthData();
+  let cfg = readConfig();
+  if (cfg?.api?.platformOrgId) {
+    let nextApi = { ...cfg.api };
+    delete nextApi.platformOrgId, writeConfig({ ...cfg, api: nextApi });
+  }
+  logger_default.success("Successfully logged out.");
 }
-var import_crypto, SUBMIT_TRANSITION_DISPLAY, init_submit = __esm({
-  "src/distributions/external/submit.ts"() {
+var import_prompts2, import_picocolors4, ESC, BEL, init_login = __esm({
+  "src/distributions/external/login.ts"() {
     "use strict";
-    import_crypto = require("crypto");
-    init_build();
-    init_runSubmitPrechecks();
-    init_manifestManager();
-    init_pluginStateManager();
-    init_buildArchive();
+    import_prompts2 = require("@inquirer/prompts"), import_picocolors4 = __toESM(require("picocolors"));
+    init_manager();
     init_logger();
-    init_tracker();
-    SUBMIT_TRANSITION_DISPLAY = "waiting for approve";
+    init_authManager();
+    init_hosts();
+    ESC = "\x1B", BEL = "\x07";
   }
 });
 
@@ -3036,22 +3230,20 @@ function registerDistributionCommands(program) {
     withErrorHandling(async () => {
       logoutExternal();
     })
-  ), program.command("submit").description("build plugin, create a Tracker issue in PLUGINMOD, and submit for review").addOption(skipChecksOption).action(withErrorHandling(submitExternal)), program.command("doctor").description("validate local plugin project, external config and auth").option("--network", "verify OAuth token with Tracker /myself", !1).option("--publish", "treat publish-readiness checks as failures", !1).option("--json", "machine-readable output", !1).action((options) => withErrorHandling(doctor)(options)), program.command("list").description("list all your plugins and their moderation status").action(withErrorHandling(listExternal)), program.command("info [issue-key]").description(
-    "show moderation status of a plugin (uses .tracker-plugin issue key if not provided)"
-  ).action(withErrorHandling(infoExternal));
+  ), program.command("submit").description("build plugin and submit it to the platform for review").addOption(skipChecksOption).action(withErrorHandling(submitPlatform)), program.command("doctor").description("validate local plugin project, external config and auth").option("--network", "verify OAuth token with Tracker /myself", !1).option("--publish", "treat publish-readiness checks as failures", !1).option("--json", "machine-readable output", !1).action((options) => withErrorHandling(doctor)(options)), program.command("list").description("list all your plugins and their moderation status").action(withErrorHandling(listPlatform)), program.command("info [plugin-id]").description("show plugin status (uses plugin id from manifest if not provided)").action(withErrorHandling(infoPlatform));
 }
 var init_registerCommands = __esm({
   "src/distributions/external/registerCommands.ts"() {
     "use strict";
     init_doctor();
+    init_platform2();
+    init_platform3();
     init_options();
+    init_platform4();
     init_registerCommand();
     init_withErrorHandling();
-    init_info();
-    init_list();
     init_login();
     init_meta();
-    init_submit();
   }
 });
 
@@ -3061,26 +3253,11 @@ init_meta2();
 
 // src/distribution/registerCommands.ts
 init_flag();
-var impl4 = (init_registerCommands(), __toCommonJS(registerCommands_exports)), { registerDistributionCommands: registerDistributionCommands2 } = impl4;
-
-// src/utils/checkUpdate.ts
-var import_node_fetch2 = __toESM(require("node-fetch"));
-
-// src/distribution/hosts.ts
-init_flag();
-var impl5 = (init_hosts(), __toCommonJS(hosts_exports)), {
-  getS3Endpoint: getS3Endpoint2,
-  getMdsEndpoint: getMdsEndpoint2,
-  getS3Region: getS3Region2,
-  getBuckets: getBuckets2,
-  getPluginDownloadBase: getPluginDownloadBase2,
-  getPlatformBaseUrl: getPlatformBaseUrl2,
-  getTrackerBaseUrl: getTrackerBaseUrl2,
-  getOAuthTokenUrl: getOAuthTokenUrl2,
-  getUpdateCheckInfo: getUpdateCheckInfo2
-} = impl5;
+var impl6 = (init_registerCommands(), __toCommonJS(registerCommands_exports)), { registerDistributionCommands: registerDistributionCommands2 } = impl6;
 
 // src/utils/checkUpdate.ts
+var import_node_fetch3 = __toESM(require("node-fetch"));
+init_hosts2();
 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);
@@ -3095,7 +3272,7 @@ var SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/, DIAGNOSTIC_FLAGS = /* @__PURE__ */ new
   let current = parse(version);
   if (current)
     try {
-      let response = await (0, import_node_fetch2.default)(`${info2.registryUrl}/${info2.packageName}/latest`);
+      let response = await (0, import_node_fetch3.default)(`${info2.registryUrl}/${info2.packageName}/latest`);
       if (!response.ok) return;
       let json = await response.json(), latest = parse(json.version);
       if (!latest) return;
@@ -3312,7 +3489,7 @@ async function create() {
 }
 
 // src/commands/debug/index.ts
-var import_fs16 = __toESM(require("fs")), import_path17 = __toESM(require("path"));
+var import_fs15 = __toESM(require("fs")), import_path17 = __toESM(require("path"));
 init_manifestManager();
 
 // src/core/s3config/constants.ts
@@ -3336,10 +3513,11 @@ var registerCleanup = (cleanup) => {
 init_templateCommands();
 
 // src/commands/debug/utils/createDebugConfig.ts
-var import_fs13 = __toESM(require("fs")), import_path14 = __toESM(require("path"));
+var import_fs12 = __toESM(require("fs")), import_path14 = __toESM(require("path"));
 init_manifestManager();
 
 // src/utils/convertManifestToConfig.ts
+init_hosts2();
 function buildPluginDownloadUrl(env, id, version) {
   return env === "debug" ? getPluginDownloadBase2(env) : `${getPluginDownloadBase2(env)}/${id}/${version}`;
 }
@@ -3384,20 +3562,20 @@ var convertManifestToConfig = (manifest, environment) => {
 // src/commands/debug/utils/createDebugConfig.ts
 var createDebugConfig = async () => {
   let manifest = await manifestManager.load(), config = convertManifestToConfig(manifest, "debug"), configPath = import_path14.default.join(process.cwd(), CONFIG_FILE_NAME);
-  import_fs13.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  import_fs12.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
 };
 
 // src/commands/debug/utils/lockFile.ts
-var import_fs14 = __toESM(require("fs")), import_path15 = __toESM(require("path")), LOCK_FILE_NAME = ".yaweavix-debug.lock", getLockFilePath = () => import_path15.default.join(process.cwd(), LOCK_FILE_NAME), getRunningDebugPid = () => {
+var import_fs13 = __toESM(require("fs")), import_path15 = __toESM(require("path")), LOCK_FILE_NAME = ".yaweavix-debug.lock", getLockFilePath = () => import_path15.default.join(process.cwd(), LOCK_FILE_NAME), getRunningDebugPid = () => {
   let lockPath = getLockFilePath();
-  if (!import_fs14.default.existsSync(lockPath))
+  if (!import_fs13.default.existsSync(lockPath))
     return null;
   try {
-    let pid = JSON.parse(import_fs14.default.readFileSync(lockPath, "utf-8")).pid;
+    let pid = JSON.parse(import_fs13.default.readFileSync(lockPath, "utf-8")).pid;
     return process.kill(pid, 0), pid;
   } catch {
     try {
-      import_fs14.default.unlinkSync(lockPath);
+      import_fs13.default.unlinkSync(lockPath);
     } catch {
     }
     return null;
@@ -3405,19 +3583,19 @@ var import_fs14 = __toESM(require("fs")), import_path15 = __toESM(require("path"
 }, createLockFile = () => {
   let lockPath = getLockFilePath(), lockData = {
     pid: process.pid
-  }, fd = import_fs14.default.openSync(lockPath, "wx");
-  import_fs14.default.writeSync(fd, JSON.stringify(lockData, null, 2)), import_fs14.default.closeSync(fd);
+  }, fd = import_fs13.default.openSync(lockPath, "wx");
+  import_fs13.default.writeSync(fd, JSON.stringify(lockData, null, 2)), import_fs13.default.closeSync(fd);
 }, removeLockFile = () => {
   let lockPath = getLockFilePath();
-  import_fs14.default.existsSync(lockPath) && import_fs14.default.unlinkSync(lockPath);
+  import_fs13.default.existsSync(lockPath) && import_fs13.default.unlinkSync(lockPath);
 };
 
 // src/commands/debug/utils/watchManifest.ts
-var import_fs15 = __toESM(require("fs")), import_path16 = __toESM(require("path"));
+var import_fs14 = __toESM(require("fs")), import_path16 = __toESM(require("path"));
 init_manifestManager();
 init_logger();
 var watchManifest = () => {
-  let manifestPath = import_path16.default.join(process.cwd(), "manifest.json"), debounceTimer = null, watcher = import_fs15.default.watch(manifestPath, async (eventType) => {
+  let manifestPath = import_path16.default.join(process.cwd(), "manifest.json"), debounceTimer = null, watcher = import_fs14.default.watch(manifestPath, async (eventType) => {
     eventType === "change" && (debounceTimer && clearTimeout(debounceTimer), debounceTimer = setTimeout(async () => {
       try {
         logger_default.newLine(), logger_default.info("Manifest file changed, validating..."), await manifestManager.validate(), logger_default.info("Regenerating debug config..."), await createDebugConfig(), logger_default.success("Debug config regenerated successfully");
@@ -3444,9 +3622,9 @@ If you lost the terminal tab, you can kill the process with:
   let configPath = import_path17.default.join(process.cwd(), CONFIG_FILE_NAME);
   options.lint && await manifestManager.validate(), await createDebugConfig();
   let watcher = watchManifest(), cleanup = () => {
-    watcher.close(), import_fs16.default.existsSync(configPath) && import_fs16.default.unlinkSync(configPath), removeLockFile();
+    watcher.close(), import_fs15.default.existsSync(configPath) && import_fs15.default.unlinkSync(configPath), removeLockFile();
   };
-  registerCleanup(cleanup), createLockFile(), logger_default.newLine(), logger_default.info("\u{1F527} Debug mode started!"), logger_default.newLine(), logger_default.info("\u{1F4CC} The plugin is now available in the Tracker interface."), logger_default.info("Open Tracker and check the plugin functionality in the appropriate context."), logger_default.newLine(), logger_default.info("\u26A0\uFE0F  Do not try to open localhost in the browser - the plugin works"), logger_default.info("only inside Tracker through a special loading mechanism."), logger_default.newLine(), logger_default.info("\u{1F504} Code changes will be automatically reloaded."), logger_default.info("Press Ctrl+C to stop."), logger_default.newLine(), await execCommand(pluginCmd.dev), cleanup();
+  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(getPluginCommands().dev), cleanup();
 }
 
 // src/commands/lint.ts
@@ -3455,20 +3633,20 @@ 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);
+  logger_default.info("\u{1F50D} Running manifest.json validation..."), await manifestManager.validate(), logger_default.info("\u{1F50D} Running code lint check..."), await execCommand(getPluginCommands().lint);
 }
 
 // src/commands/up/index.ts
-var import_fs19 = require("fs"), import_promises5 = require("fs/promises");
+var import_fs18 = require("fs"), import_promises4 = require("fs/promises");
 init_execCommand();
 
 // src/commands/up/utils/copyTemplateFiles.ts
-var import_fs17 = require("fs"), import_promises3 = require("fs/promises"), import_path18 = __toESM(require("path"));
+var import_fs16 = require("fs"), import_promises2 = require("fs/promises"), import_path18 = __toESM(require("path"));
 var copyTemplateFiles = async (files) => {
   await Promise.all(
     files.map(async (file) => {
       let templatePath, targetPath, force = !1;
-      typeof file == "string" ? (templatePath = getTemplatePath(file), targetPath = `./${file}`) : (templatePath = file.sourcePath ?? getTemplatePath(file.source ?? file.target), targetPath = `./${file.target}`, force = file.force ?? !1), (0, import_fs17.existsSync)(templatePath) && (force || (0, import_fs17.existsSync)(targetPath)) && (await (0, import_promises3.mkdir)(import_path18.default.dirname(targetPath), { recursive: !0 }), await (0, import_promises3.copyFile)(templatePath, targetPath));
+      typeof file == "string" ? (templatePath = getTemplatePath(file), targetPath = `./${file}`) : (templatePath = file.sourcePath ?? getTemplatePath(file.source ?? file.target), targetPath = `./${file.target}`, force = file.force ?? !1), (0, import_fs16.existsSync)(templatePath) && (force || (0, import_fs16.existsSync)(targetPath)) && (await (0, import_promises2.mkdir)(import_path18.default.dirname(targetPath), { recursive: !0 }), await (0, import_promises2.copyFile)(templatePath, targetPath));
     })
   );
 }, overlayFileCopy = (overlayDir, sourceFilename, targetFilename) => ({
@@ -3498,15 +3676,15 @@ async function updateManifestCompatibility() {
 }
 
 // src/commands/up/utils/updatePackageDependencies.ts
-var import_fs18 = require("fs"), import_promises4 = require("fs/promises");
+var import_fs17 = require("fs"), import_promises3 = require("fs/promises");
 var updatePackageDependencies = async (dependencies) => {
   let packageJsonPath = "./package.json", templatePackageJsonPath = getTemplatePath("package.json");
-  if (!(0, import_fs18.existsSync)(packageJsonPath) || !(0, import_fs18.existsSync)(templatePackageJsonPath))
+  if (!(0, import_fs17.existsSync)(packageJsonPath) || !(0, import_fs17.existsSync)(templatePackageJsonPath))
     return;
-  let packageJsonContent = await (0, import_promises4.readFile)(packageJsonPath, "utf-8"), templatePackageJsonContent = await (0, import_promises4.readFile)(templatePackageJsonPath, "utf-8"), packageJson = JSON.parse(packageJsonContent), templatePackageJson = JSON.parse(templatePackageJsonContent), updated = !1;
+  let packageJsonContent = await (0, import_promises3.readFile)(packageJsonPath, "utf-8"), templatePackageJsonContent = await (0, import_promises3.readFile)(templatePackageJsonPath, "utf-8"), packageJson = JSON.parse(packageJsonContent), templatePackageJson = JSON.parse(templatePackageJsonContent), updated = !1;
   dependencies.forEach((dep) => {
     packageJson.dependencies?.[dep] && templatePackageJson.dependencies?.[dep] && packageJson.dependencies[dep] !== templatePackageJson.dependencies[dep] && (packageJson.dependencies[dep] = templatePackageJson.dependencies[dep], updated = !0);
-  }), updated && await (0, import_promises4.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
+  }), updated && await (0, import_promises3.writeFile)(packageJsonPath, JSON.stringify(packageJson, null, 4) + `
 `, "utf-8");
 };
 
@@ -3518,11 +3696,11 @@ var npmrcPath = "./.npmrc", npmrcTemplateFilename = "npmrc.template", sharedFile
 ];
 async function isNpmrcOutdated() {
   let templatePath = getOverlayTemplatePath(overlayDirName, npmrcTemplateFilename);
-  if (!(0, import_fs19.existsSync)(npmrcPath) || !(0, import_fs19.existsSync)(templatePath))
+  if (!(0, import_fs18.existsSync)(npmrcPath) || !(0, import_fs18.existsSync)(templatePath))
     return !1;
   let [currentNpmrc, templateNpmrc] = await Promise.all([
-    (0, import_promises5.readFile)(npmrcPath, "utf-8"),
-    (0, import_promises5.readFile)(templatePath, "utf-8")
+    (0, import_promises4.readFile)(npmrcPath, "utf-8"),
+    (0, import_promises4.readFile)(templatePath, "utf-8")
   ]);
   return currentNpmrc !== templateNpmrc;
 }
@@ -3535,12 +3713,12 @@ async function up() {
 }
 
 // src/utils/getVersion.ts
-var import_fs20 = require("fs"), import_path19 = require("path"), UNKNOWN_VERSION = "unknown", CANDIDATES = ["..", "../.."], findVersionInPackageJson = (startDir) => {
+var import_fs19 = require("fs"), import_path19 = require("path"), UNKNOWN_VERSION = "unknown", CANDIDATES = ["..", "../.."], findVersionInPackageJson = (startDir) => {
   for (let rel of CANDIDATES) {
     let path24 = (0, import_path19.resolve)(startDir, rel, "package.json");
-    if ((0, import_fs20.existsSync)(path24))
+    if ((0, import_fs19.existsSync)(path24))
       try {
-        let pkg = JSON.parse((0, import_fs20.readFileSync)(path24, "utf-8"));
+        let pkg = JSON.parse((0, import_fs19.readFileSync)(path24, "utf-8"));
         if (typeof pkg.version == "string") return pkg.version;
       } catch {
       }