@reliverse/dler 1.7.63 → 1.7.65

package/bin/libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/make.js

@@ -0,0 +1,203 @@
+import { resolve, extname, join, basename, dirname } from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import defu from "defu";
+import fsp from "node:fs/promises";
+import { glob } from "tinyglobby";
+import { createLoader } from "./loader.js";
+import { getDeclarations, normalizeCompilerOptions } from "./utils/dts.js";
+import { copyFileWithStream } from "./utils/fs.js";
+import { getVueDeclarations } from "./utils/vue-dts.js";
+export async function mkdist(options = {}) {
+  const startTime = Date.now();
+  options.rootDir = resolve(process.cwd(), options.rootDir || ".");
+  options.srcDir = resolve(options.rootDir, options.srcDir || "src");
+  options.distDir = resolve(options.rootDir, options.distDir || "dist");
+  if (options.cleanDist !== false) {
+    relinka("info", "Cleaning distribution directory...");
+    await fsp.unlink(options.distDir).catch(() => {
+    });
+    await fsp.rm(options.distDir, { recursive: true, force: true });
+    await fsp.mkdir(options.distDir, { recursive: true });
+  }
+  relinka("info", "Scanning input files...");
+  const filePaths = await glob(options.pattern || "**", {
+    absolute: false,
+    ignore: ["**/node_modules", "**/coverage", "**/.git"],
+    cwd: options.srcDir,
+    dot: true,
+    ...options.globOptions
+  });
+  const files = filePaths.map((path) => {
+    const sourcePath = resolve(options.srcDir, path);
+    return {
+      path,
+      srcPath: sourcePath,
+      extension: extname(path),
+      getContents: () => fsp.readFile(sourcePath, { encoding: "utf8" })
+    };
+  });
+  relinka("info", `Found ${files.length} files to process`);
+  options.typescript ||= {};
+  if (options.typescript.compilerOptions) {
+    relinka("info", "Normalizing TypeScript compiler options...");
+    options.typescript.compilerOptions = await normalizeCompilerOptions(
+      options.typescript.compilerOptions
+    );
+  }
+  options.typescript.compilerOptions = defu(
+    { noEmit: false },
+    options.typescript.compilerOptions,
+    {
+      allowJs: true,
+      declaration: true,
+      skipLibCheck: true,
+      strictNullChecks: true,
+      emitDeclarationOnly: true,
+      allowImportingTsExtensions: true,
+      allowNonTsExtensions: true
+    }
+  );
+  relinka("info", "Creating file loaders...");
+  const { loadFile } = createLoader(options);
+  relinka("info", "Processing files with loaders...");
+  const outputs = [];
+  let processedCount = 0;
+  await Promise.all(
+    files.map(async (file) => {
+      const result = await loadFile(file);
+      if (result) {
+        outputs.push(...result);
+      }
+      processedCount++;
+      const shouldUpdate = processedCount % Math.max(1, Math.floor(files.length / 10)) === 0 || processedCount === files.length;
+      if (shouldUpdate) {
+        relinka("verbose", `Processing files: ${file.path} (${processedCount}/${files.length})`);
+      }
+    })
+  );
+  relinka("info", "Normalizing output extensions...");
+  const pathConflicts = [];
+  for (const output of outputs.filter((o) => o.extension)) {
+    const renamed = basename(output.path, extname(output.path)) + output.extension;
+    output.path = join(dirname(output.path), renamed);
+    const conflictingOutput = outputs.find((o) => o !== output && o.path === output.path);
+    if (conflictingOutput) {
+      pathConflicts.push(output.path);
+    }
+  }
+  if (pathConflicts.length > 0) {
+    const errorMessage = `Output path conflict detected for paths: ${pathConflicts.join(", ")}. Multiple files would write to the same output path.`;
+    relinka("error", errorMessage);
+    throw new Error(errorMessage);
+  }
+  const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
+  if (dtsOutputs.length > 0) {
+    relinka("info", `Generating TypeScript declarations for ${dtsOutputs.length} files...`);
+    const vfs = new Map(dtsOutputs.map((o) => [o.srcPath, o.contents || ""]));
+    const declarations = /* @__PURE__ */ Object.create(null);
+    for (const loader of [getVueDeclarations, getDeclarations]) {
+      Object.assign(declarations, await loader(vfs, options));
+    }
+    let dtsProcessed = 0;
+    for (const output of dtsOutputs) {
+      const result = declarations[output.srcPath];
+      output.contents = result?.contents || "";
+      if (result.errors) {
+        output.errors = result.errors;
+      }
+      dtsProcessed++;
+      if (dtsProcessed % Math.max(1, Math.floor(dtsOutputs.length / 5)) === 0) {
+        relinka("verbose", `Generated declarations for ${dtsProcessed}/${dtsOutputs.length} files`);
+      }
+    }
+  }
+  relinka("info", "Resolving relative imports...");
+  const outPaths = new Set(outputs.map((o) => o.path));
+  const resolveId = (from, id = "", resolveExtensions) => {
+    if (!id.startsWith(".")) {
+      return id;
+    }
+    for (const extension of resolveExtensions) {
+      if (outPaths.has(join(dirname(from), id + extension))) {
+        return id + extension;
+      }
+    }
+    return id;
+  };
+  const esmResolveExtensions = ["", "/index.mjs", "/index.js", ".mjs", ".ts", ".js"];
+  const esmOutputs = outputs.filter((o) => o.extension === ".mjs" || o.extension === ".js");
+  for (const output of esmOutputs) {
+    output.contents = output.contents.replace(
+      /(import|export)(\s+(?:.+|{[\s\w,]+})\s+from\s+["'])(.*)(["'])/g,
+      (_, type, head, id, tail) => type + head + resolveId(output.path, id, esmResolveExtensions) + tail
+    ).replace(
+      /import\((["'])(.*)(["'])\)/g,
+      (_, head, id, tail) => "import(" + head + resolveId(output.path, id, esmResolveExtensions) + tail + ")"
+    );
+  }
+  const cjsResolveExtensions = ["", "/index.cjs", ".cjs"];
+  const cjsOutputs = outputs.filter((o) => o.extension === ".cjs");
+  for (const output of cjsOutputs) {
+    output.contents = output.contents.replace(
+      /require\((["'])(.*)(["'])\)/g,
+      (_, head, id, tail) => "require(" + head + resolveId(output.path, id, cjsResolveExtensions) + tail + ")"
+    );
+  }
+  const outputsToWrite = outputs.filter((o) => !o.skip);
+  relinka("info", `Writing ${outputsToWrite.length} output files...`);
+  const writtenFiles = [];
+  const errors = [];
+  let writtenCount = 0;
+  await Promise.all(
+    outputsToWrite.map(async (output) => {
+      try {
+        const outFile = join(options.distDir, output.path);
+        await fsp.mkdir(dirname(outFile), { recursive: true });
+        await (output.raw ? (
+          // @ts-expect-error TODO: fix ts
+          copyFileWithStream(output.srcPath, outFile)
+        ) : (
+          // @ts-expect-error TODO: fix ts
+          fsp.writeFile(outFile, output.contents, "utf8")
+        ));
+        writtenFiles.push(outFile);
+        if (output.errors) {
+          errors.push({ filename: outFile, errors: output.errors });
+        }
+      } catch (error) {
+        const errorMessage = `Failed to write file ${output.path}: ${error instanceof Error ? error.message : "Unknown error"}`;
+        errors.push({
+          filename: output.path,
+          errors: [new TypeError(errorMessage)]
+        });
+      }
+      writtenCount++;
+      const progressUpdateInterval = Math.max(10, Math.floor(outputsToWrite.length / 10));
+      if (writtenCount % progressUpdateInterval === 0 || writtenCount === outputsToWrite.length) {
+        relinka("verbose", `Written ${writtenCount}/${outputsToWrite.length} files`);
+      }
+    })
+  );
+  const duration = Date.now() - startTime;
+  if (errors.length > 0) {
+    relinka("warn", `Build completed with ${errors.length} errors`);
+    for (const error of errors.slice(0, 5)) {
+      relinka(
+        "error",
+        `Error in ${error.filename}: ${error.errors[0]?.message || "Unknown error"}`
+      );
+    }
+    if (errors.length > 5) {
+      relinka("error", `... and ${errors.length - 5} more errors`);
+    }
+  } else {
+    relinka("success", "Build completed successfully!");
+  }
+  return {
+    result: {
+      errors,
+      writtenFiles
+    },
+    duration
+  };
+}

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/mkdist/mkdist-impl/utils/dts.d.ts

@@ -1,6 +1,6 @@
 import type { TSConfig } from "pkg-types";
 import type { CompilerHost, EmitResult } from "typescript";
-import type { MkdistOptions } from "../../../../../../sdk-types.js";
+import type { MkdistOptions } from "../../../../../sdk-types.js";
 export declare function normalizeCompilerOptions(_options: TSConfig["compilerOptions"]): Promise<any>;
 export type DeclarationOutput = Record<string, {
     contents: string;

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/mkdist/mkdist-impl/utils/vue-dts.d.ts

@@ -1,3 +1,3 @@
-import type { MkdistOptions } from "../../../../../../sdk-types.js";
+import type { MkdistOptions } from "../../../../../sdk-types.js";
 import type { DeclarationOutput } from "./dts";
 export declare function getVueDeclarations(vfs: Map<string, string>, opts?: MkdistOptions): Promise<DeclarationOutput>;

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/mkdist/mkdist-impl/utils/vue-dts.js

@@ -108,7 +108,6 @@ async function emitVueTscV2(vfs, inputFiles, originFiles, opts) {
   const createProgram = volarTs.proxyCreateProgram(ts, ts.createProgram, (ts2, options) => {
     const vueLanguagePlugin = vueLanguageCore.createVueLanguagePlugin(
       ts2,
-      // @ts-expect-error TODO: fix ts
       (id) => id,
       () => "",
       (fileName) => {
@@ -118,8 +117,8 @@ async function emitVueTscV2(vfs, inputFiles, originFiles, opts) {
         }
         return fileMap.has(fileName);
       },
-      // @ts-expect-error TODO: fix ts
       options.options,
+      // @ts-expect-error TODO: fix ts
       {}
     );
     return [vueLanguagePlugin];

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/mkdist/mkdist-mod.d.ts

@@ -1,2 +1,2 @@
-import type { BuildContext } from "../../../../sdk-types.js";
+import type { BuildContext } from "../../../sdk-types.js";
 export declare function mkdistBuild(ctx: BuildContext): Promise<void>;

package/bin/libs/sdk/sdk-impl/build/providers/mkdist/mkdist-mod.js

@@ -0,0 +1,92 @@
+import { relative, dirname as pathDirname } from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import { rmdir, symlink, warn } from "../utils.js";
+import { mkdist } from "./mkdist-impl/make.js";
+export async function mkdistBuild(ctx) {
+  const entries = ctx.options.entries.filter((e) => e.builder === "mkdist");
+  if (entries.length === 0) {
+    return;
+  }
+  await ctx.hooks.callHook("mkdist:entries", ctx, entries);
+  let processedEntries = 0;
+  let totalWrittenFiles = 0;
+  let totalErrors = 0;
+  relinka("info", `Processing ${entries.length} mkdist entries...`);
+  for (const entry of entries) {
+    processedEntries++;
+    relinka("info", `Processing entry ${processedEntries}/${entries.length}: ${entry.input}`);
+    const distDir = entry.outDir || entry.input;
+    if (ctx.options.transpileStub) {
+      await rmdir(distDir);
+      await symlink(entry.input, distDir);
+      continue;
+    }
+    let srcDir;
+    if (typeof entry.input === "string" && !entry.input.endsWith("/")) {
+      srcDir = ctx.options.isLib ? pathDirname(entry.input) : entry.input;
+      relinka(
+        "verbose",
+        `[mkdist] Using directory from file path: ${srcDir} (from: ${entry.input})`
+      );
+    } else {
+      srcDir = entry.input;
+      relinka("verbose", `[mkdist] Using directory directly: ${srcDir}`);
+    }
+    const mkdistOptions = {
+      cleanDist: false,
+      distDir,
+      rootDir: ctx.options.rootDir,
+      srcDir,
+      format: "esm",
+      ext: entry.ext || "js",
+      ...entry
+    };
+    relinka(
+      "info",
+      `[mkdist] Building with options: srcDir=${mkdistOptions.srcDir}, distDir=${mkdistOptions.distDir}, rootDir=${mkdistOptions.rootDir}`
+    );
+    await ctx.hooks.callHook("mkdist:entry:options", ctx, entry, mkdistOptions);
+    try {
+      const { result: output, duration } = await mkdist(mkdistOptions);
+      relinka("verbose", `[mkdist] Entry ${processedEntries} completed in ${duration}ms`);
+      totalWrittenFiles += output.writtenFiles.length;
+      ctx.buildEntries.push({
+        chunks: output.writtenFiles.map((p) => relative(ctx.options.outDir, p)),
+        path: distDir,
+        isLib: ctx.options.isLib
+      });
+      await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
+      if (output.errors && output.errors.length > 0) {
+        totalErrors += output.errors.length;
+        for (const error of output.errors) {
+          warn(
+            ctx,
+            `mkdist build failed for \`${relative(ctx.options.rootDir, error.filename)}\`:
+${error.errors.map((e) => `  - ${e}`).join("\n")}`
+          );
+        }
+      }
+    } catch (error) {
+      totalErrors++;
+      warn(
+        ctx,
+        `mkdist build failed for entry ${entry.input}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  await ctx.hooks.callHook("mkdist:done", ctx);
+  if (entries.length > 0 && ctx.options.transpileWatch) {
+    relinka("warn", "`mkdist` builder does not support transpileWatch mode yet.");
+  }
+  if (totalErrors > 0) {
+    relinka(
+      "warn",
+      `Processed ${entries.length} entries with ${totalErrors} errors. ${totalWrittenFiles} files written.`
+    );
+  } else {
+    relinka(
+      "success",
+      `Successfully processed ${entries.length} entries. ${totalWrittenFiles} files written.`
+    );
+  }
+}

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/rollup/build.d.ts

@@ -1,2 +1,2 @@
-import type { BuildContext } from "../../../../sdk-types.js";
+import type { BuildContext } from "../../../sdk-types.js";
 export declare function rollupBuild(ctx: BuildContext): Promise<void>;

package/bin/libs/sdk/sdk-impl/build/providers/rollup/config.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext, RollupOptions } from "../../../sdk-types.js";
+export declare function getRollupOptions(ctx: BuildContext): RollupOptions;

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/rollup/plugins/cjs.d.ts

@@ -1,4 +1,4 @@
 import type { Plugin } from "rollup";
-import type { BuildContext } from "../../../../../sdk-types.js";
+import type { BuildContext } from "../../../../sdk-types.js";
 export declare function cjsPlugin(): Plugin;
 export declare function fixCJSExportTypePlugin(ctx: BuildContext): Plugin;

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/rollup/plugins/esbuild.d.ts

@@ -1,3 +1,3 @@
 import type { Plugin } from "rollup";
-import type { EsbuildOptions } from "../../../../../sdk-types.js";
+import type { EsbuildOptions } from "../../../../sdk-types.js";
 export declare function esbuild(options: EsbuildOptions): Plugin;

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/rollup/stub.d.ts

@@ -1,2 +1,2 @@
-import type { BuildContext } from "../../../../sdk-types.js";
+import type { BuildContext } from "../../../sdk-types.js";
 export declare function rollupStub(ctx: BuildContext): Promise<void>;

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/rollup/utils.d.ts

@@ -1,5 +1,5 @@
 import type { PreRenderedChunk } from "rollup";
-import type { BuildContext } from "../../../../sdk-types.js";
+import type { BuildContext } from "../../../sdk-types.js";
 export declare const DEFAULT_EXTENSIONS: string[];
 export declare function getChunkFilename(ctx: BuildContext, chunk: PreRenderedChunk, ext: string): string;
 export declare function resolveAliases(ctx: BuildContext): Record<string, string>;

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/rollup/watch.d.ts

@@ -1,2 +1,2 @@
-import type { RollupOptions } from "../../../../sdk-types.js";
+import type { RollupOptions } from "../../../sdk-types.js";
 export declare function rollupWatch(rollupOptions: RollupOptions): void;

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/untyped/untyped-mod.d.ts

@@ -1,2 +1,2 @@
-import type { BuildContext } from "../../../../sdk-types.js";
+import type { BuildContext } from "../../../sdk-types.js";
 export declare function typesBuild(ctx: BuildContext): Promise<void>;

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/utils.d.ts

@@ -1,5 +1,5 @@
 import type { PackageJson } from "pkg-types";
-import type { BuildContext, BuildPreset, UnifiedBuildConfig } from "../../../sdk-types.js";
+import type { BuildContext, BuildPreset, UnifiedBuildConfig } from "../../sdk-types.js";
 interface OutputDescriptor {
     file: string;
     type?: "cjs" | "esm";

package/bin/libs/sdk/sdk-impl/build/{bundlers/unified → providers}/validate.d.ts

@@ -1,4 +1,4 @@
 import type { PackageJson } from "pkg-types";
-import type { BuildContext } from "../../../sdk-types.js";
+import type { BuildContext } from "../../sdk-types.js";
 export declare function validateDependencies(ctx: BuildContext): void;
 export declare function validatePackage(pkg: PackageJson, rootDir: string, ctx: BuildContext): void;

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.63";
+const version = "1.7.65";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/bin/libs/sdk/sdk-impl/utils/exec/exec-mod.js

@@ -180,13 +180,15 @@ export class ExecProcess {
       this._args
     );
     const crossResult = _parse(normalisedCommand, normalisedArgs, nodeOptions);
-    let handle;
-    if (process.versions.bun) {
-      const bunSpawn = Bun.spawn;
-      handle = bunSpawn(crossResult.command, crossResult.args, crossResult.options);
-    } else {
-      handle = spawn(crossResult.command, crossResult.args, crossResult.options);
-    }
+    console.log("DEBUG: spawn parameters:", {
+      command: crossResult.command,
+      args: crossResult.args,
+      commandType: typeof crossResult.command,
+      argsType: typeof crossResult.args,
+      isArgsArray: Array.isArray(crossResult.args),
+      bunVersion: process.versions.bun
+    });
+    const handle = spawn(crossResult.command, crossResult.args, crossResult.options);
     if (handle.stderr) {
       this._streamErr = handle.stderr;
     }

package/bin/libs/sdk/sdk-impl/utils/exec/exec-parse.js

@@ -34,6 +34,14 @@ async function parseNonShell(parsed) {
   return parsed;
 }
 export async function parse(command, args, options) {
+  console.log("DEBUG: parse function called with:", {
+    command,
+    args,
+    options,
+    commandType: typeof command,
+    argsType: typeof args,
+    isArgsArray: Array.isArray(args)
+  });
   let actualArgs = args;
   let actualOptions = options;
   if (actualArgs && !Array.isArray(actualArgs)) {
@@ -52,5 +60,12 @@ export async function parse(command, args, options) {
       args: actualArgs
     }
   };
+  console.log("DEBUG: parse function returning:", {
+    command: parsed.command,
+    args: parsed.args,
+    commandType: typeof parsed.command,
+    argsType: typeof parsed.args,
+    isArgsArray: Array.isArray(parsed.args)
+  });
   return actualOptions.shell ? parsed : await parseNonShell(parsed);
 }

package/bin/libs/sdk/sdk-impl/utils/pm/pm-meta.d.ts

@@ -0,0 +1,27 @@
+interface PackageJsonOptions {
+    version?: string;
+    omitDeprecated?: boolean;
+    registryUrl?: string;
+    fullMetadata?: boolean;
+    allVersions?: boolean;
+}
+interface PackageData {
+    "dist-tags": Record<string, string>;
+    versions: Record<string, PackageVersion>;
+    time?: Record<string, string>;
+}
+interface PackageVersion {
+    version: string;
+    deprecated?: boolean;
+    time?: Record<string, string>;
+    [key: string]: any;
+}
+export declare class PackageNotFoundError extends Error {
+    constructor(packageName: string);
+}
+export declare class VersionNotFoundError extends Error {
+    constructor(packageName: string, version: string);
+}
+export default function packageJson(packageName: string, options?: PackageJsonOptions): Promise<PackageData | PackageVersion>;
+export declare function latestVersion(packageName: string, options?: PackageJsonOptions): Promise<string>;
+export {};

package/bin/libs/sdk/sdk-impl/utils/pm/pm-meta.js

@@ -0,0 +1,86 @@
+import ky from "ky";
+import registryAuthToken from "registry-auth-token";
+import registryUrl from "registry-url";
+import semver from "semver";
+export class PackageNotFoundError extends Error {
+  constructor(packageName) {
+    super(`Package \`${packageName}\` could not be found`);
+    this.name = "PackageNotFoundError";
+  }
+}
+export class VersionNotFoundError extends Error {
+  constructor(packageName, version) {
+    super(`Version \`${version}\` for package \`${packageName}\` could not be found`);
+    this.name = "VersionNotFoundError";
+  }
+}
+export default async function packageJson(packageName, options = {}) {
+  let { version = "latest" } = options;
+  const { omitDeprecated = true } = options;
+  const scope = packageName.split("/")[0];
+  const registryUrl_ = options.registryUrl ?? registryUrl(scope);
+  const packageUrl = new URL(encodeURIComponent(packageName).replace(/^%40/, "@"), registryUrl_);
+  const authInfo = registryAuthToken(registryUrl_.toString(), { recursive: true });
+  const headers = {
+    accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
+  };
+  if (options.fullMetadata) {
+    delete headers.accept;
+  }
+  if (authInfo) {
+    headers.authorization = `${authInfo.type} ${authInfo.token}`;
+  }
+  let data;
+  try {
+    data = await ky(packageUrl, { headers, keepalive: true }).json();
+  } catch (error) {
+    if (error?.response?.status === 404) {
+      throw new PackageNotFoundError(packageName);
+    }
+    throw error;
+  }
+  if (options.allVersions) {
+    return data;
+  }
+  const versionError = new VersionNotFoundError(packageName, version);
+  if (version && data["dist-tags"][version]) {
+    const { time } = data;
+    const versionTag = data["dist-tags"][version];
+    if (versionTag) {
+      const packageVersion = data.versions[versionTag];
+      if (packageVersion) {
+        packageVersion.time = time;
+        return packageVersion;
+      }
+    }
+  } else if (version) {
+    const versionExists = Boolean(data.versions[version]);
+    if (omitDeprecated && !versionExists) {
+      for (const [metadataVersion, metadata] of Object.entries(data.versions)) {
+        if (metadata.deprecated) {
+          delete data.versions[metadataVersion];
+        }
+      }
+    }
+    if (!versionExists) {
+      const versions = Object.keys(data.versions);
+      const resolvedVersion = semver.maxSatisfying(versions, version);
+      if (!resolvedVersion) {
+        throw versionError;
+      }
+      version = resolvedVersion;
+    }
+    const { time } = data;
+    const packageVersion = data.versions[version];
+    if (!packageVersion) {
+      throw versionError;
+    }
+    packageVersion.time = time;
+    return packageVersion;
+  }
+  throw versionError;
+}
+export async function latestVersion(packageName, options = {}) {
+  const { version } = await packageJson(packageName.toLowerCase(), options);
+  return version;
+}

package/bin/libs/sdk/sdk-impl/utils/pm/pm-utils.js

@@ -26,7 +26,26 @@ const hasCorepack = cached(async () => {
   }
 });
 export async function executeCommand(command, args, options = {}) {
+  console.log("DEBUG: executeCommand called with:", {
+    command,
+    args,
+    options,
+    commandType: typeof command,
+    argsType: typeof args,
+    isArgsArray: Array.isArray(args)
+  });
+  if (!Array.isArray(args)) {
+    throw new Error(`executeCommand: args must be an array, got ${typeof args}: ${args}`);
+  }
   const xArgs = command === "npm" || command === "bun" || command === "deno" || !await hasCorepack() ? [command, args] : ["corepack", [command, ...args]];
+  console.log("DEBUG: executeCommand xArgs:", {
+    xArgs,
+    command: xArgs[0],
+    args: xArgs[1],
+    commandType: typeof xArgs[0],
+    argsType: typeof xArgs[1],
+    isArgsArray: Array.isArray(xArgs[1])
+  });
   const { exitCode, stdout, stderr } = await x(xArgs[0], xArgs[1], {
     nodeOptions: {
       cwd: resolve(options.cwd || process.cwd()),