@reliverse/dler 1.7.91 → 1.7.93

package/bin/app/update/migrate/cmd.js

@@ -0,0 +1,605 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand, multiselectPrompt } from "@reliverse/rempts";
+import { readPackageJSON } from "pkg-types";
+import semver from "semver";
+import { glob } from "tinyglobby";
+import { isCatalogSupported } from "../../utils/pm/pm-catalog.js";
+import { detectPackageManager } from "../../utils/pm/pm-detect.js";
+function isCatalogReference(versionSpec) {
+  return versionSpec.startsWith("catalog:");
+}
+function isWorkspaceDependency(versionSpec) {
+  return versionSpec.startsWith("workspace:");
+}
+function isNpmAlias(versionSpec) {
+  return versionSpec.startsWith("npm:");
+}
+function shouldSkipDependency(versionSpec) {
+  return isNpmAlias(versionSpec) || isWorkspaceDependency(versionSpec) || isCatalogReference(versionSpec) || versionSpec.startsWith("git+") || versionSpec.startsWith("file:") || versionSpec.startsWith("link:") || versionSpec.startsWith("http:") || versionSpec.startsWith("https:");
+}
+async function findWorkspacePackageJsons(cwd) {
+  const root = await readPackageJSON(cwd);
+  const ws = root.workspaces;
+  let patterns = [];
+  if (Array.isArray(ws)) {
+    patterns = ws;
+  } else if (ws && Array.isArray(ws.packages)) {
+    patterns = ws.packages;
+  }
+  if (!patterns.length) return [];
+  const dirs = await glob(patterns, {
+    cwd,
+    onlyDirectories: true,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+  });
+  const pkgJsonPaths = [];
+  for (const dir of dirs) {
+    const pj = path.join(dir, "package.json");
+    if (await fs.pathExists(pj)) pkgJsonPaths.push(pj);
+  }
+  return pkgJsonPaths;
+}
+async function isMonorepo(cwd) {
+  try {
+    const root = await readPackageJSON(cwd);
+    const ws = root.workspaces;
+    if (Array.isArray(ws) && ws.length > 0) {
+      return true;
+    }
+    if (ws && Array.isArray(ws.packages) && ws.packages.length > 0) {
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function extractDependencies(packageJson, packageJsonPath) {
+  const dependencies = [];
+  const deps = packageJson.dependencies || {};
+  for (const [name, version] of Object.entries(deps)) {
+    if (typeof version === "string" && !shouldSkipDependency(version)) {
+      dependencies.push({
+        name,
+        version,
+        locations: /* @__PURE__ */ new Set(["dependencies"]),
+        packageJsonPath
+      });
+    }
+  }
+  const devDeps = packageJson.devDependencies || {};
+  for (const [name, version] of Object.entries(devDeps)) {
+    if (typeof version === "string" && !shouldSkipDependency(version)) {
+      const existing = dependencies.find((d) => d.name === name);
+      if (existing) {
+        existing.locations.add("devDependencies");
+        if (existing.locations.has("dependencies")) {
+          existing.version = deps[name] || existing.version;
+        }
+      } else {
+        dependencies.push({
+          name,
+          version,
+          locations: /* @__PURE__ */ new Set(["devDependencies"]),
+          packageJsonPath
+        });
+      }
+    }
+  }
+  return dependencies;
+}
+function mergeToCatalog(existingCatalog, newDependencies) {
+  const result = {
+    added: [],
+    bumped: [],
+    skipped: []
+  };
+  for (const dep of newDependencies) {
+    const existingVersion = existingCatalog[dep.name];
+    if (!existingVersion) {
+      existingCatalog[dep.name] = dep.version;
+      result.added.push(dep);
+    } else {
+      try {
+        const cleanExisting = existingVersion.replace(/^[\^~]/, "");
+        const cleanNew = dep.version.replace(/^[\^~]/, "");
+        if (semver.valid(cleanExisting) && semver.valid(cleanNew)) {
+          if (semver.gt(cleanNew, cleanExisting)) {
+            existingCatalog[dep.name] = dep.version;
+            result.bumped.push({ ...dep, oldVersion: existingVersion });
+          } else {
+            result.skipped.push(dep);
+          }
+        } else {
+          result.skipped.push(dep);
+        }
+      } catch {
+        result.skipped.push(dep);
+      }
+    }
+  }
+  return result;
+}
+async function replaceDependenciesWithCatalogRefs(packageJsonPath, dependenciesToReplace) {
+  try {
+    const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonContent);
+    let replacedCount = 0;
+    for (const dep of dependenciesToReplace) {
+      for (const location of dep.locations) {
+        if (location === "dependencies" && packageJson.dependencies?.[dep.name]) {
+          packageJson.dependencies[dep.name] = "catalog:";
+          replacedCount++;
+        } else if (location === "devDependencies" && packageJson.devDependencies?.[dep.name]) {
+          packageJson.devDependencies[dep.name] = "catalog:";
+          replacedCount++;
+        }
+      }
+    }
+    if (replacedCount > 0) {
+      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
+    }
+    return replacedCount;
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to update ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return 0;
+  }
+}
+async function restoreCatalogReferences(packageJsonPath, catalog) {
+  try {
+    const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonContent);
+    let restoredCount = 0;
+    const deps = packageJson.dependencies || {};
+    for (const [name, version] of Object.entries(deps)) {
+      if (typeof version === "string" && isCatalogReference(version)) {
+        const catalogVersion = catalog[name];
+        if (catalogVersion && packageJson.dependencies) {
+          packageJson.dependencies[name] = catalogVersion;
+          restoredCount++;
+        } else {
+          relinka("warn", `No catalog entry found for dependency: ${name} in ${packageJsonPath}`);
+        }
+      }
+    }
+    const devDeps = packageJson.devDependencies || {};
+    for (const [name, version] of Object.entries(devDeps)) {
+      if (typeof version === "string" && isCatalogReference(version)) {
+        const catalogVersion = catalog[name];
+        if (catalogVersion && packageJson.devDependencies) {
+          packageJson.devDependencies[name] = catalogVersion;
+          restoredCount++;
+        } else {
+          relinka(
+            "warn",
+            `No catalog entry found for devDependency: ${name} in ${packageJsonPath}`
+          );
+        }
+      }
+    }
+    if (restoredCount > 0) {
+      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
+    }
+    return restoredCount;
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to restore ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return 0;
+  }
+}
+async function updateRootWithCatalog(rootPackageJsonPath, catalog) {
+  try {
+    const packageJsonContent = await fs.readFile(rootPackageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonContent);
+    if (!packageJson.workspaces) {
+      packageJson.workspaces = {};
+    }
+    if (Array.isArray(packageJson.workspaces)) {
+      packageJson.workspaces = { packages: packageJson.workspaces };
+    }
+    packageJson.workspaces.catalog = catalog;
+    await fs.writeFile(rootPackageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
+  } catch (error) {
+    throw new Error(
+      `Failed to update root package.json: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function removeCatalogFromRoot(rootPackageJsonPath) {
+  try {
+    const packageJsonContent = await fs.readFile(rootPackageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonContent);
+    if (packageJson.workspaces && !Array.isArray(packageJson.workspaces) && packageJson.workspaces.catalog) {
+      packageJson.workspaces.catalog = void 0;
+      if (Object.keys(packageJson.workspaces).length === 0 || Object.keys(packageJson.workspaces).length === 1 && packageJson.workspaces.packages) {
+        if (!packageJson.workspaces.packages) {
+          packageJson.workspaces = void 0;
+        }
+      }
+    }
+    if (packageJson.catalog) {
+      packageJson.catalog = void 0;
+    }
+    await fs.writeFile(rootPackageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
+  } catch (error) {
+    throw new Error(
+      `Failed to remove catalog from root package.json: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function migrateToCatalog(rootPath, dryRun = false, interactive = false) {
+  const results = [];
+  const workspacePaths = await findWorkspacePackageJsons(rootPath);
+  if (workspacePaths.length === 0) {
+    throw new Error("No workspace packages found. This command requires a monorepo setup.");
+  }
+  relinka("log", `Found ${workspacePaths.length} workspace packages`);
+  const allDependencies = [];
+  for (const workspacePath of workspacePaths) {
+    try {
+      const packageJsonContent = await fs.readFile(workspacePath, "utf8");
+      const packageJson = JSON.parse(packageJsonContent);
+      const deps = extractDependencies(packageJson, workspacePath);
+      allDependencies.push(...deps);
+    } catch (error) {
+      relinka(
+        "warn",
+        `Failed to read ${workspacePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (allDependencies.length === 0) {
+    relinka("log", "No dependencies found to migrate to catalog");
+    return results;
+  }
+  relinka("log", `Found ${allDependencies.length} total dependency entries across workspaces`);
+  const rootPackageJsonPath = path.resolve(rootPath, "package.json");
+  let existingCatalog = {};
+  try {
+    const rootPackageJson = await readPackageJSON(rootPath);
+    existingCatalog = rootPackageJson.workspaces?.catalog || {};
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to read root package.json: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const mergeResult = mergeToCatalog(existingCatalog, allDependencies);
+  relinka("log", `Catalog merge summary:`);
+  relinka("log", `  - ${mergeResult.added.length} new dependencies added`);
+  relinka("log", `  - ${mergeResult.bumped.length} dependencies bumped to newer versions`);
+  relinka(
+    "log",
+    `  - ${mergeResult.skipped.length} dependencies skipped (already up-to-date or incompatible)`
+  );
+  let dependenciesToMigrate = allDependencies;
+  if (interactive && allDependencies.length > 0) {
+    const selectedPackages = await multiselectPrompt({
+      title: "Select dependencies to migrate to catalog",
+      options: [
+        { label: "Migrate all dependencies", value: "all" },
+        { label: "Cancel migration", value: "cancel" },
+        ...Array.from(new Set(allDependencies.map((d) => d.name))).map((name) => ({
+          label: name,
+          value: name
+        }))
+      ]
+    });
+    if (selectedPackages.includes("cancel")) {
+      relinka("log", "Migration cancelled");
+      return results;
+    }
+    if (!selectedPackages.includes("all")) {
+      dependenciesToMigrate = allDependencies.filter((dep) => selectedPackages.includes(dep.name));
+    }
+  }
+  if (dryRun) {
+    relinka("log", "Dry run mode - no changes were made");
+    relinka("log", "Would migrate the following dependencies to catalog:");
+    const uniqueDeps = Array.from(new Set(dependenciesToMigrate.map((d) => d.name)));
+    for (const depName of uniqueDeps) {
+      const catalogVersion = existingCatalog[depName];
+      relinka("log", `  ${depName}: ${catalogVersion || "new entry"}`);
+    }
+    return results;
+  }
+  await updateRootWithCatalog(rootPackageJsonPath, existingCatalog);
+  const workspaceResults = /* @__PURE__ */ new Map();
+  for (const dep of dependenciesToMigrate) {
+    if (!workspaceResults.has(dep.packageJsonPath)) {
+      workspaceResults.set(dep.packageJsonPath, []);
+    }
+    workspaceResults.get(dep.packageJsonPath).push(dep);
+  }
+  for (const [packagePath, deps] of workspaceResults.entries()) {
+    const replacedCount = await replaceDependenciesWithCatalogRefs(packagePath, deps);
+    if (replacedCount > 0) {
+      relinka("log", `Updated ${replacedCount} dependencies in ${packagePath}`);
+      for (const dep of deps) {
+        results.push({
+          package: dep.name,
+          action: "replaced-with-catalog",
+          oldVersion: dep.version,
+          newVersion: "catalog:",
+          location: Array.from(dep.locations).join(", "),
+          packageJsonPath: packagePath
+        });
+      }
+    }
+  }
+  for (const dep of mergeResult.added) {
+    results.push({
+      package: dep.name,
+      action: "added-to-catalog",
+      newVersion: dep.version,
+      location: "catalog"
+    });
+  }
+  for (const dep of mergeResult.bumped) {
+    results.push({
+      package: dep.name,
+      action: "version-bumped",
+      oldVersion: dep.oldVersion,
+      newVersion: dep.version,
+      location: "catalog"
+    });
+  }
+  return results;
+}
+async function migrateFromCatalog(rootPath, removeCatalog = false, dryRun = false, interactive = false) {
+  const results = [];
+  const rootPackageJson = await readPackageJSON(rootPath);
+  const catalog = rootPackageJson.workspaces?.catalog || {};
+  if (Object.keys(catalog).length === 0) {
+    relinka("warn", "No workspaces.catalog found in root package.json");
+    return results;
+  }
+  relinka("log", `Found catalog with ${Object.keys(catalog).length} entries`);
+  const workspacePaths = await findWorkspacePackageJsons(rootPath);
+  if (workspacePaths.length === 0) {
+    relinka("warn", "No workspace packages found");
+    return results;
+  }
+  const packagesWithCatalogRefs = [];
+  for (const workspacePath of workspacePaths) {
+    try {
+      const packageJsonContent = await fs.readFile(workspacePath, "utf8");
+      const packageJson = JSON.parse(packageJsonContent);
+      const catalogRefs = [];
+      const deps = packageJson.dependencies || {};
+      for (const [name, version] of Object.entries(deps)) {
+        if (typeof version === "string" && isCatalogReference(version)) {
+          catalogRefs.push(name);
+        }
+      }
+      const devDeps = packageJson.devDependencies || {};
+      for (const [name, version] of Object.entries(devDeps)) {
+        if (typeof version === "string" && isCatalogReference(version)) {
+          catalogRefs.push(name);
+        }
+      }
+      if (catalogRefs.length > 0) {
+        packagesWithCatalogRefs.push({
+          path: workspacePath,
+          catalogRefs: [...new Set(catalogRefs)]
+          // Remove duplicates
+        });
+      }
+    } catch (error) {
+      relinka(
+        "warn",
+        `Failed to read ${workspacePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (packagesWithCatalogRefs.length === 0) {
+    relinka("log", "No catalog references found in workspace packages");
+    if (removeCatalog && !dryRun) {
+      const rootPackageJsonPath = path.resolve(rootPath, "package.json");
+      await removeCatalogFromRoot(rootPackageJsonPath);
+      relinka("log", "Removed catalog from root package.json");
+    }
+    return results;
+  }
+  const totalCatalogRefs = packagesWithCatalogRefs.reduce(
+    (sum, pkg) => sum + pkg.catalogRefs.length,
+    0
+  );
+  relinka(
+    "log",
+    `Found ${totalCatalogRefs} catalog references across ${packagesWithCatalogRefs.length} packages`
+  );
+  let packagesToProcess = packagesWithCatalogRefs;
+  if (interactive && packagesWithCatalogRefs.length > 0) {
+    const allCatalogRefs = Array.from(
+      new Set(packagesWithCatalogRefs.flatMap((p) => p.catalogRefs))
+    );
+    const selectedPackages = await multiselectPrompt({
+      title: "Select dependencies to restore from catalog",
+      options: [
+        { label: "Restore all catalog references", value: "all" },
+        { label: "Cancel restoration", value: "cancel" },
+        ...allCatalogRefs.map((name) => ({
+          label: `${name} (${catalog[name] || "missing in catalog"})`,
+          value: name,
+          disabled: !catalog[name]
+        }))
+      ]
+    });
+    if (selectedPackages.includes("cancel")) {
+      relinka("log", "Restoration cancelled");
+      return results;
+    }
+    if (!selectedPackages.includes("all")) {
+      packagesToProcess = packagesWithCatalogRefs.map((pkg) => ({
+        ...pkg,
+        catalogRefs: pkg.catalogRefs.filter((ref) => selectedPackages.includes(ref))
+      })).filter((pkg) => pkg.catalogRefs.length > 0);
+    }
+  }
+  if (dryRun) {
+    relinka("log", "Dry run mode - no changes were made");
+    relinka("log", "Would restore the following catalog references:");
+    for (const pkg of packagesToProcess) {
+      relinka("log", `  ${pkg.path}:`);
+      for (const ref of pkg.catalogRefs) {
+        const catalogVersion = catalog[ref];
+        relinka("log", `    ${ref}: catalog: \u2192 ${catalogVersion || "MISSING"}`);
+      }
+    }
+    if (removeCatalog) {
+      relinka("log", "Would also remove workspaces.catalog from root package.json");
+    }
+    return results;
+  }
+  for (const pkg of packagesToProcess) {
+    const restoredCount = await restoreCatalogReferences(pkg.path, catalog);
+    if (restoredCount > 0) {
+      relinka("log", `Restored ${restoredCount} catalog references in ${pkg.path}`);
+      for (const ref of pkg.catalogRefs) {
+        if (catalog[ref]) {
+          results.push({
+            package: ref,
+            action: "restored-from-catalog",
+            oldVersion: "catalog:",
+            newVersion: catalog[ref],
+            location: "dependencies/devDependencies",
+            packageJsonPath: pkg.path
+          });
+        }
+      }
+    }
+  }
+  if (removeCatalog) {
+    const rootPackageJsonPath = path.resolve(rootPath, "package.json");
+    await removeCatalogFromRoot(rootPackageJsonPath);
+    relinka("log", "Removed workspaces.catalog from root package.json");
+  }
+  return results;
+}
+function displayMigrationResults(results) {
+  if (results.length === 0) {
+    relinka("log", "No changes were made");
+    return;
+  }
+  const byAction = results.reduce(
+    (acc, result) => {
+      if (!acc[result.action]) acc[result.action] = [];
+      acc[result.action].push(result);
+      return acc;
+    },
+    {}
+  );
+  for (const [action, actionResults] of Object.entries(byAction)) {
+    relinka("log", `
+${action.replace(/-/g, " ")} (${actionResults.length}):`);
+    for (const result of actionResults) {
+      let message = `  ${result.package}`;
+      if (result.oldVersion && result.newVersion) {
+        message += `: ${result.oldVersion} \u2192 ${result.newVersion}`;
+      } else if (result.newVersion) {
+        message += `: ${result.newVersion}`;
+      }
+      if (result.packageJsonPath) {
+        message += ` (${result.packageJsonPath})`;
+      }
+      relinka("log", message);
+    }
+  }
+  relinka("success", `Migration completed: ${results.length} changes made`);
+  relinka("log", "Run your package manager install command to apply the changes");
+}
+export default defineCommand({
+  meta: {
+    name: "migrate",
+    description: "Migrate dependencies between workspace packages and workspaces.catalog"
+  },
+  args: defineArgs({
+    "to-catalog": {
+      type: "boolean",
+      description: "Migrate workspace dependencies to workspaces.catalog and replace with catalog references"
+    },
+    "from-catalog": {
+      type: "boolean",
+      description: "Restore catalog references to actual versions from workspaces.catalog"
+    },
+    "remove-catalog": {
+      type: "boolean",
+      description: "Remove workspaces.catalog from root package.json after restoring (only with --from-catalog)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without making modifications"
+    },
+    interactive: {
+      type: "boolean",
+      description: "Interactively select dependencies to migrate"
+    }
+  }),
+  async run({ args }) {
+    try {
+      if (!args["to-catalog"] && !args["from-catalog"]) {
+        relinka("error", "Must specify either --to-catalog or --from-catalog");
+        return process.exit(1);
+      }
+      if (args["to-catalog"] && args["from-catalog"]) {
+        relinka("error", "Cannot specify both --to-catalog and --from-catalog");
+        return process.exit(1);
+      }
+      if (args["remove-catalog"] && !args["from-catalog"]) {
+        relinka("error", "--remove-catalog can only be used with --from-catalog");
+        return process.exit(1);
+      }
+      const cwd = process.cwd();
+      const packageJsonPath = path.resolve(cwd, "package.json");
+      if (!await fs.pathExists(packageJsonPath)) {
+        relinka("error", "No package.json found in current directory");
+        return process.exit(1);
+      }
+      if (!await isMonorepo(cwd)) {
+        relinka("error", "This command requires a monorepo with workspace configuration");
+        return process.exit(1);
+      }
+      const packageManager = await detectPackageManager(cwd);
+      if (!packageManager) {
+        relinka("warn", "Could not detect package manager");
+      } else if (!isCatalogSupported(packageManager)) {
+        relinka(
+          "warn",
+          `Catalogs may not be fully supported by ${packageManager.name}. Only Bun has full catalog support.`
+        );
+      }
+      let results = [];
+      if (args["to-catalog"]) {
+        relinka("log", "Migrating workspace dependencies to catalog...");
+        results = await migrateToCatalog(cwd, !!args["dry-run"], !!args.interactive);
+      } else if (args["from-catalog"]) {
+        relinka("log", "Restoring dependencies from catalog...");
+        results = await migrateFromCatalog(
+          cwd,
+          !!args["remove-catalog"],
+          !!args["dry-run"],
+          !!args.interactive
+        );
+      }
+      displayMigrationResults(results);
+      if (args["dry-run"]) {
+        relinka("info", "This was a dry run - no actual changes were made");
+      }
+    } catch (error) {
+      relinka(
+        "error",
+        `Migration failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  }
+});

package/bin/app/update/update-impl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@reliverse/rempts").Command<import("@reliverse/rempts").EmptyArgs>;
+export default _default;

package/bin/app/update/update-impl.js

@@ -0,0 +1,50 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand, selectPrompt } from "@reliverse/rempts";
+import { execaCommand } from "execa";
+import { cliName } from "../config/constants.js";
+import { getAllPkgManagers } from "../utils/dependencies/getUserPkgManager.js";
+import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
+async function getPmOptions() {
+  const projectPath = getCurrentWorkingDirectory();
+  const detectedPMs = await getAllPkgManagers(projectPath);
+  const detectedPMMap = new Map(detectedPMs.map((pm) => [pm.packageManager, pm.source]));
+  const pmOptions = ["bun", "pnpm", "npm", "yarn"].map((pm) => {
+    const option = {
+      label: pm,
+      value: pm
+    };
+    const source = detectedPMMap.get(pm);
+    if (source && source !== "default") {
+      option.hint = "detected";
+    }
+    return option;
+  });
+  const defaultValue = [...detectedPMMap.keys()][0] ?? "npm";
+  return { pmOptions, defaultValue };
+}
+export default defineCommand({
+  meta: {
+    name: "update",
+    description: "Updates the CLI to the latest version",
+    hidden: false
+  },
+  run: async () => {
+    try {
+      const { pmOptions, defaultValue } = await getPmOptions();
+      const pm = await selectPrompt({
+        title: `Select a package manager to update the ${cliName}`,
+        options: pmOptions,
+        defaultValue
+      });
+      await execaCommand(`${pm} -g update --latest`, { stdio: "inherit" });
+      relinka("success", "Updated successfully!", "You can now use the latest `rse cli` version.");
+    } catch (error) {
+      relinka(
+        "error",
+        "Failed to update @rse",
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+    process.exit(0);
+  }
+});

package/bin/app/upgrade/cmd.js

@@ -3,8 +3,8 @@ import { relinka } from "@reliverse/relinka";
 import { defineArgs, defineCommand, multiselectPrompt } from "@reliverse/rempts";
 import { lookpath } from "lookpath";
 import { readPackageJSON } from "pkg-types";
-import { x } from "../../libs/sdk/sdk-impl/utils/exec/exec-mod.js";
-import { detectPackageManager } from "../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
+import { x } from "../utils/exec/exec-mod.js";
+import { detectPackageManager } from "../utils/pm/pm-detect.js";
 export default defineCommand({
   meta: {
     name: "upgrade",

package/bin/app/upload/cmd.d.ts

@@ -0,0 +1,17 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    files: {
+        type: "positional";
+        required: true;
+        description: string;
+    };
+    provider: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    dryRun: {
+        type: "boolean";
+        description: string;
+    };
+}>;
+export default _default;