piral-cli 1.4.0-beta.6243 → 1.4.0-beta.6250

package/src/apps/upgrade-pilet.ts

@@ -107,6 +107,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
   }
 
   for (const { appPackage } of apps) {
+    //TODO distinguish if it's a website / remote emulator or an npm package
     const sourceName = appPackage.name;
     const language = /\.jsx?$/.test(source) ? 'js' : 'ts';
 
@@ -121,7 +122,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     }
 
     const monorepoRef = await isMonorepoPackageRef(sourceName, fullBase);
-    const [packageRef, packageVersion] = await getCurrentPackageDetails(
+    const [packageRef] = await getCurrentPackageDetails(
       fullBase,
       sourceName,
       currentVersion,
@@ -162,7 +163,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
       await copyScaffoldingFiles(packageRoot, root, notOnceFiles, piralInfo, data);
     }
 
-    await patchPiletPackage(root, sourceName, packageVersion, piralInfo, isEmulator);
+    await patchPiletPackage(root, piralInfo, isEmulator);
 
     if (install) {
       progress(`Updating dependencies ...`);

package/src/build/bundler-calls.ts

@@ -55,10 +55,10 @@ function createBundler(cwd: string, ps: ChildProcess, args: any) {
   return bundler;
 }
 
-export function callDynamic<T extends BaseBundleParameters>(name: string, path: string, args: T) {
+export function callDynamic<T extends BaseBundleParameters>(name: string, path: string, args: T, exec?: string) {
   const cwd = args.root;
   return new Promise<Bundler>((resolve, reject) => {
-    const ps = fork(getPath(name), [], { cwd, stdio: 'pipe', env: process.env });
+    const ps = fork(getPath(name), [], { cwd, stdio: 'pipe', env: process.env, execPath: exec });
     const bundler = createBundler(cwd, ps, args);
     const setup = {
       type: 'init',
@@ -97,10 +97,10 @@ export function callDynamic<T extends BaseBundleParameters>(name: string, path:
   });
 }
 
-export function callStatic<T extends BaseBundleParameters>(name: string, path: string, args: T) {
+export function callStatic<T extends BaseBundleParameters>(name: string, path: string, args: T, exec?: string) {
   const cwd = args.root;
   return new Promise<Bundler>((resolve, reject) => {
-    const ps = fork(getPath(name), [], { cwd, stdio: 'pipe', env: process.env });
+    const ps = fork(getPath(name), [], { cwd, stdio: 'pipe', env: process.env, execPath: exec });
     const bundler = createBundler(cwd, ps, args);
     const setup = {
       type: 'init',

package/src/bundler.test.ts

@@ -92,7 +92,7 @@ describe('Piral CLI Bundler Module', () => {
 
     const args = { root: undefined };
     await callPiletBuild(args as any, 'foo1');
-    expect(callStatic).toHaveBeenCalledWith('build-pilet', '1', args);
+    expect(callStatic).toHaveBeenCalledWith('build-pilet', '1', args, undefined);
   });
 
   it('setting the bundler with optimize modules calls optimize modules', async () => {
@@ -134,7 +134,7 @@ describe('Piral CLI Bundler Module', () => {
 
     const args = { root: undefined };
     await callPiralBuild(args as any, 'foo2');
-    expect(callStatic).toHaveBeenCalledWith('build-piral', '3', args);
+    expect(callStatic).toHaveBeenCalledWith('build-piral', '3', args, undefined);
   });
 
   it('setting the bundler can resolve it properly for call pilet debug', async () => {
@@ -153,7 +153,7 @@ describe('Piral CLI Bundler Module', () => {
 
     const args = { root: undefined };
     await callPiletDebug(args as any, 'foo3');
-    expect(callDynamic).toHaveBeenCalledWith('debug-pilet', '1', args);
+    expect(callDynamic).toHaveBeenCalledWith('debug-pilet', '1', args, undefined);
   });
 
   it('setting the bundler can resolve it properly for call piral debug', async () => {
@@ -172,7 +172,7 @@ describe('Piral CLI Bundler Module', () => {
 
     const args = { root: undefined };
     await callPiralDebug(args as any, 'foo4');
-    expect(callDynamic).toHaveBeenCalledWith('debug-piral', '10', args);
+    expect(callDynamic).toHaveBeenCalledWith('debug-piral', '10', args, undefined);
   });
 
   it('setting the bundler can resolve it properly for call piral watch', async () => {
@@ -191,7 +191,7 @@ describe('Piral CLI Bundler Module', () => {
 
     const args = { root: undefined };
     await callDebugPiralFromMonoRepo(args as any, 'foo5');
-    expect(callStatic).toHaveBeenCalledWith('debug-mono-piral', '7', args);
+    expect(callStatic).toHaveBeenCalledWith('debug-mono-piral', '7', args, undefined);
   });
 
   it('using a non-available bundler should fail', () => {

package/src/bundler.ts

@@ -122,7 +122,7 @@ export async function callPiralDebug(args: DebugPiralParameters, bundlerName?: s
   try {
     const action = bundler.actions.debugPiral;
     const params = await prepareArgs(action, args);
-    return await callDynamic('debug-piral', action.path, params);
+    return await callDynamic('debug-piral', action.path, params, action.exec);
   } catch (err) {
     fail('bundlingFailed_0174', err);
   }
@@ -134,7 +134,7 @@ export async function callPiletDebug(args: DebugPiletParameters, bundlerName?: s
   try {
     const action = bundler.actions.debugPilet;
     const params = await prepareArgs(action, args);
-    return await callDynamic('debug-pilet', action.path, params);
+    return await callDynamic('debug-pilet', action.path, params, action.exec);
   } catch (err) {
     fail('bundlingFailed_0174', err);
   }
@@ -146,7 +146,7 @@ export async function callPiralBuild(args: BuildPiralParameters, bundlerName?: s
   try {
     const action = bundler.actions.buildPiral;
     const params = await prepareArgs(action, args);
-    const instance = await callStatic('build-piral', action.path, params);
+    const instance = await callStatic('build-piral', action.path, params, action.exec);
     return instance.bundle;
   } catch (err) {
     fail('bundlingFailed_0174', err);
@@ -159,7 +159,7 @@ export async function callPiletBuild(args: BuildPiletParameters, bundlerName?: s
   try {
     const action = bundler.actions.buildPilet;
     const params = await prepareArgs(action, args);
-    const instance = await callStatic('build-pilet', action.path, params);
+    const instance = await callStatic('build-pilet', action.path, params, action.exec);
     return instance.bundle;
   } catch (err) {
     fail('bundlingFailed_0174', err);
@@ -175,7 +175,7 @@ export async function callDebugPiralFromMonoRepo(
   try {
     const action = bundler.actions.watchPiral;
     const params = await prepareArgs(action, args);
-    const instance = await callStatic('debug-mono-piral', action.path, params);
+    const instance = await callStatic('debug-mono-piral', action.path, params, action.exec);
     return instance.bundle;
   } catch (err) {
     fail('bundlingFailed_0174', err);

package/src/common/emulator.ts

@@ -9,7 +9,7 @@ import { ForceOverwrite } from './enums';
 import { createTarball } from './archive';
 import { createDirectory, removeDirectory, matchFiles, removeAny, getFileNames } from './io';
 import { updateExistingJson, readJson, writeJson, createFileIfNotExists } from './io';
-import { LogLevels, SharedDependency, PiletsInfo, TemplateFileLocation } from '../types';
+import { EmulatorWebsiteManifest, LogLevels, SharedDependency, PiletsInfo, TemplateFileLocation } from '../types';
 
 export async function createEmulatorSources(
   sourceDir: string,
@@ -102,7 +102,7 @@ export async function createEmulatorSources(
     },
     main: `./${join(appDir, 'index.js')}`,
     typings: `./${join(appDir, 'index.d.ts')}`,
-    app: `./${join(appDir, '/index.html')}`,
+    app: `./${join(appDir, 'index.html')}`,
     peerDependencies: {},
     optionalDependencies,
     devDependencies: {
@@ -211,38 +211,34 @@ export async function createEmulatorWebsite(
   }, {} as Record<string, string>);
 
   const allFiles = await matchFiles(targetDir, '*');
-
-  await writeJson(
-    targetDir,
-    'emulator.json',
-    {
-      name: piralPkg.name,
-      description: piralPkg.description,
-      version: piralPkg.version,
-      timestamp: new Date().toISOString(),
-      scaffolding: {
-        pilets,
-        cli: cliVersion,
-      },
-      files: {
-        typings: 'index.d.ts',
-        main: basename(targetFile),
-        app: 'index.html',
-        assets: allFiles.map(file => relative(targetDir, file)),
-      },
-      importmap: {
-        imports: importmapEntries,
-      },
-      dependencies: {
-        optional: optionalDependencies,
-        included: {
-          ...allDeps,
-          ...externalDependencies,
-        },
+  const data: EmulatorWebsiteManifest = {
+    name: piralPkg.name,
+    description: piralPkg.description,
+    version: piralPkg.version,
+    timestamp: new Date().toISOString(),
+    scaffolding: {
+      pilets,
+      cli: cliVersion,
+    },
+    files: {
+      typings: 'index.d.ts',
+      main: basename(targetFile),
+      app: 'index.html',
+      assets: allFiles.map((file) => relative(targetDir, file)),
+    },
+    importmap: {
+      imports: importmapEntries,
+    },
+    dependencies: {
+      optional: optionalDependencies,
+      included: {
+        ...allDeps,
+        ...externalDependencies,
       },
     },
-    true,
-  );
+  };
+
+  await writeJson(targetDir, 'emulator.json', data, true);
 
   // generate the associated index.d.ts
   await createPiralDeclaration(sourceDir, piralPkg.app ?? `./src/index.html`, targetDir, ForceOverwrite.yes, logLevel);

package/src/common/index.ts

@@ -36,3 +36,4 @@ export * from './template';
 export * from './url';
 export * from './version';
 export * from './watcher';
+export * from './website';

package/src/common/npm.ts

@@ -195,7 +195,7 @@ export function publishNpmPackage(
   interactive = false,
 ): Promise<string> {
   const { publishPackage, loginUser } = clients.npm;
-  return publishPackage(target, file, ...flags).catch(err => {
+  return publishPackage(target, file, ...flags).catch((err) => {
     if (!interactive) {
       throw err;
     }
@@ -266,13 +266,13 @@ export function makeNpmAlias(name: string, version: string) {
 }
 
 export function isGitPackage(fullName: string) {
-  log('generalDebug_0003', 'Checking if its a Git package ...');
+  log('generalDebug_0003', 'Checking if its a git package ...');
 
   if (fullName) {
     const gitted = fullName.startsWith(gitPrefix);
 
     if (gitted || /^(https?|ssh):\/\/.*\.git$/.test(fullName)) {
-      log('generalDebug_0003', 'Found a Git package by name.');
+      log('generalDebug_0003', 'Found a git package by name.');
       return true;
     }
   }
@@ -280,6 +280,17 @@ export function isGitPackage(fullName: string) {
   return false;
 }
 
+export function isRemotePackage(fullName: string) {
+  log('generalDebug_0003', 'Checking if its a remote package ...');
+
+  if (fullName && /^https?:\/\/.*/.test(fullName)) {
+    log('generalDebug_0003', 'Found a remote package by name.');
+    return true;
+  }
+
+  return false;
+}
+
 export function makeGitUrl(fullName: string) {
   const gitted = fullName.startsWith(gitPrefix);
   return gitted ? fullName : `${gitPrefix}${fullName}`;
@@ -309,6 +320,8 @@ export async function dissectPackageName(
   if (isGitPackage(fullName)) {
     const gitUrl = makeGitUrl(fullName);
     return [gitUrl, 'latest', false, 'git'];
+  } else if (isRemotePackage(fullName)) {
+    return [fullName, 'latest', false, 'remote'];
   } else if (isLocalPackage(baseDir, fullName)) {
     const fullPath = resolveAbsPath(baseDir, fullName);
     const exists = await checkExists(fullPath);

package/src/common/package.ts

@@ -11,34 +11,15 @@ import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
 import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, tryResolvePackage, isNpmPackage } from './npm';
 import { makePiletExternals, makeExternals, findPackageRoot, findSpecificVersion, makeNpmAlias } from './npm';
-import { getModulePath } from '../external';
+import { scaffoldFromEmulatorWebsite } from './website';
 import { getDependencies, getDependencyPackages, getDevDependencies } from './language';
 import { getDevDependencyPackages, getFrameworkDependencies } from './language';
-import {
-  declarationEntryExtensions,
-  piralJsonSchemaUrl,
-  piletJsonSchemaUrl,
-  filesTar,
-  filesOnceTar,
-  bundlerNames,
-  frameworkLibs,
-  piralJson,
-  piletJson,
-  packageJson,
-} from './constants';
-import {
-  SourceLanguage,
-  Framework,
-  FileInfo,
-  PiletsInfo,
-  TemplateFileLocation,
-  PiletPackageData,
-  PiralPackageData,
-  SharedDependency,
-  PiletDefinition,
-  AppDefinition,
-  PiralInstancePackageData,
-} from '../types';
+import { piralJsonSchemaUrl, filesTar, filesOnceTar, bundlerNames, packageJson } from './constants';
+import { frameworkLibs, declarationEntryExtensions, piralJson, piletJson } from './constants';
+import { getModulePath } from '../external';
+import { PiletsInfo, SharedDependency, PiletDefinition, AppDefinition } from '../types';
+import { SourceLanguage, PiralInstancePackageData, PiralInstanceDetails } from '../types';
+import { Framework, FileInfo, TemplateFileLocation, PiletPackageData, PiralPackageData } from '../types';
 
 export interface PiralInstanceData {
   packageName: Framework;
@@ -168,10 +149,10 @@ export function getPiralPath(root: string, name: string) {
 
 export async function findPiralInstance(
   proposedApp: string,
-  baseDir: string,
-  port: number,
+  rootDir: string,
+  details?: PiralInstanceDetails,
 ): Promise<PiralInstancePackageData> {
-  const path = findPackageRoot(proposedApp, baseDir);
+  const path = findPackageRoot(proposedApp, rootDir);
 
   if (path) {
     log('generalDebug_0003', `Following the app package in "${path}" ...`);
@@ -180,8 +161,13 @@ export async function findPiralInstance(
     const relPath = appPackage && appPackage.app;
     appPackage.app = relPath && resolve(root, relPath);
     appPackage.root = root;
-    appPackage.port = port;
+    appPackage.port = details?.port || 0;
     return appPackage;
+  } else if (details?.url) {
+    const { url, ...rest } = details;
+    log('generalDebug_0003', `Piral instance not installed yet - trying from remote "${url}" ...`);
+    await scaffoldFromEmulatorWebsite(rootDir, url);
+    return await findPiralInstance(proposedApp, rootDir, rest);
   }
 
   fail('appInstanceNotFound_0010', proposedApp);
@@ -191,7 +177,7 @@ export async function findPiralInstances(
   proposedApps: Array<string>,
   piletPackage: PiletPackageData,
   piletDefinition: undefined | PiletDefinition,
-  baseDir: string,
+  rootDir: string,
 ) {
   if (proposedApps) {
     // do nothing
@@ -209,7 +195,7 @@ export async function findPiralInstances(
   if (proposedApps.length > 0) {
     return Promise.all(
       proposedApps.map((proposedApp) =>
-        findPiralInstance(proposedApp, baseDir, piletDefinition?.piralInstances?.[proposedApp]?.port ?? 0),
+        findPiralInstance(proposedApp, rootDir, piletDefinition?.piralInstances?.[proposedApp]),
       ),
     );
   }
@@ -220,7 +206,7 @@ export async function findPiralInstances(
 export function readPiralPackage(root: string, name: string): Promise<PiralPackageData> {
   log('generalDebug_0003', `Reading the piral package in "${root}" ...`);
   const path = getPiralPath(root, name);
-  return readJson(path, 'package.json');
+  return readJson(path, packageJson);
 }
 
 export async function patchPiralPackage(
@@ -230,11 +216,11 @@ export async function patchPiralPackage(
   version: string,
   bundler?: string,
 ) {
-  log('generalDebug_0003', `Patching the package.json in "${root}" ...`);
+  log('generalDebug_0003', `Patching the ${packageJson} in "${root}" ...`);
   const pkg = await getPiralPackage(app, data, version, bundler);
 
-  await updateExistingJson(root, 'package.json', pkg);
-  log('generalDebug_0003', `Succesfully patched the package.json.`);
+  await updateExistingJson(root, packageJson, pkg);
+  log('generalDebug_0003', `Succesfully patched the ${packageJson}.`);
 
   await updateExistingJson(root, piralJson, {
     $schema: piralJsonSchemaUrl,
@@ -367,7 +353,7 @@ export async function copyScaffoldingFiles(
 }
 
 async function extendPackageOverridesFromTemplateFragment(root: string, piralInfo: any, files: Array<FileDescriptor>) {
-  const packageTarget = resolve(root, 'package.json');
+  const packageTarget = resolve(root, packageJson);
 
   for (let i = files.length; i--; ) {
     const file = files[i];
@@ -398,7 +384,7 @@ function isTemplateFileLocation(item: string | TemplateFileLocation): item is Te
 
 function tryFindPackageVersion(packageName: string): string {
   try {
-    const { version } = require(`${packageName}/package.json`);
+    const { version } = require(`${packageName}/${packageJson}`);
     return version;
   } catch {
     return undefined;
@@ -461,7 +447,7 @@ export async function retrievePiralRoot(baseDir: string, entry: string) {
   log('generalDebug_0003', `Retrieving Piral root from "${rootDir}" ...`);
 
   if (!declarationEntryExtensions.includes(extname(rootDir).toLowerCase())) {
-    const packageName = basename(rootDir) === 'package.json' ? rootDir : join(rootDir, 'package.json');
+    const packageName = basename(rootDir) === packageJson ? rootDir : join(rootDir, packageJson);
     log('generalDebug_0003', `Trying to get entry point from "${packageName}".`);
     const exists = await checkExists(packageName);
 
@@ -541,9 +527,9 @@ export async function findPackageVersion(rootPath: string, packageName: string |
     try {
       log('generalDebug_0003', `Finding the version of "${packageName}" in "${rootPath}".`);
       const moduleName = getModulePath(rootPath, pckg);
-      const packageJson = await findFile(moduleName, 'package.json');
-      const root = dirname(packageJson);
-      const { version } = await readJson(root, 'package.json');
+      const packageJsonPath = await findFile(moduleName, packageJson);
+      const root = dirname(packageJsonPath);
+      const { version } = await readJson(root, packageJson);
       return version;
     } catch {}
   }
@@ -649,31 +635,18 @@ export function isValidDependency(name: string) {
 
 export async function patchPiletPackage(
   root: string,
-  name: string,
-  version: string,
   piralInfo: PiralPackageData,
   fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
 ) {
-  log('generalDebug_0003', `Patching the package.json in "${root}" ...`);
-  const pkg = await getPiletPackage(root, name, version, piralInfo, fromEmulator, newInfo);
-
+  log('generalDebug_0003', `Patching the ${packageJson} in "${root}" ...`);
+  const pkg = await getPiletPackage(root, piralInfo, fromEmulator, newInfo);
   await updateExistingJson(root, packageJson, pkg);
-  log('generalDebug_0003', `Succesfully patched the package.json.`);
-
-  await updateExistingJson(root, piletJson, {
-    $schema: piletJsonSchemaUrl,
-    piralInstances: {
-      [name]: {},
-    },
-  });
-  log('generalDebug_0003', `Succesfully patched the pilet.json.`);
+  log('generalDebug_0003', `Succesfully patched the ${packageJson}.`);
 }
 
 async function getPiletPackage(
   root: string,
-  name: string,
-  version: string,
   piralInfo: PiralPackageData,
   fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
@@ -715,11 +688,9 @@ async function getPiletPackage(
 
       return deps;
     }, {}),
-    [name]: `${version || piralInfo.version}`,
     ['piral-cli']: toolVersion,
   };
   const dependencies: Record<string, string> = {
-    [name]: undefined,
     ['piral-cli']: undefined,
   };
 
@@ -730,7 +701,7 @@ async function getPiletPackage(
   return deepMerge(packageOverrides, {
     importmap: {
       imports: {},
-      inherit: [name],
+      inherit: [],
     },
     devDependencies,
     dependencies,
@@ -782,22 +753,22 @@ export function combinePiletExternals(
 }
 
 export async function findPiletRoot(proposedRoot: string) {
-  const packageJson = await findFile(proposedRoot, 'package.json');
+  const packageJsonPath = await findFile(proposedRoot, packageJson);
 
-  if (!packageJson) {
+  if (!packageJsonPath) {
     fail('packageJsonMissing_0075');
   }
 
-  return dirname(packageJson);
+  return dirname(packageJsonPath);
 }
 
 export async function retrievePiletData(target: string, app?: string) {
   const piletJsonPath = await findFile(target, piletJson);
   const proposedRoot = piletJsonPath ? dirname(piletJsonPath) : target;
   const root = await findPiletRoot(proposedRoot);
-  const piletPackage = await readJson(root, 'package.json');
+  const piletPackage = await readJson(root, packageJson);
   const piletDefinition: PiletDefinition = piletJsonPath && (await readJson(proposedRoot, piletJson));
-  const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, target);
+  const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, root);
   const apps: Array<AppDefinition> = [];
 
   for (const appPackage of appPackages) {

package/src/common/shell.ts

@@ -1,34 +1,76 @@
 import { progress } from './log';
-import {
-  combinePackageRef,
-  dissectPackageName,
-  getPackageName,
-  getPackageVersion,
-  installNpmPackage,
-  isLinkedPackage,
-} from './npm';
-import { NpmClientType } from '../types';
+import { packageJson, piletJson } from './constants';
+import { readJson, updateExistingJson, writeJson } from './io';
+import { scaffoldFromEmulatorWebsite } from './website';
+import { combinePackageRef, getPackageName, getPackageVersion } from './npm';
+import { dissectPackageName, installNpmPackage, isLinkedPackage } from './npm';
+import { NpmClientType, PackageType, PiralInstanceDetails } from '../types';
 
-export async function installPiralInstance(
-  usedSource: string,
-  baseDir: string,
+async function updatePiletJson(target: string, appName: string, appDetails: PiralInstanceDetails) {
+  const oldContent = await readJson(target, piletJson);
+  const newContent = {
+    ...oldContent,
+    piralInstances: {
+      ...oldContent.piralInstances,
+      [appName]: appDetails,
+    },
+  };
+  await writeJson(target, piletJson, newContent, true);
+  await updateExistingJson(target, packageJson, {
+    importmap: {
+      inherit: [appName],
+    },
+  });
+}
+
+async function setupPiralInstance(
+  sourceName: string,
+  type: PackageType,
+  hadVersion: boolean,
   rootDir: string,
+  sourceVersion: string,
   npmClient: NpmClientType,
-): Promise<[name: string, version: string]> {
-  const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(baseDir, usedSource);
-  const isLocal = isLinkedPackage(sourceName, type, hadVersion, rootDir);
-
-  if (!isLocal) {
+) {
+  if (!isLinkedPackage(sourceName, type, hadVersion, rootDir)) {
     const packageRef = combinePackageRef(sourceName, sourceVersion, type);
 
     progress(`Installing npm package %s ...`, packageRef);
     await installNpmPackage(npmClient, packageRef, rootDir, '--save-dev', '--save-exact');
+    return await getPackageName(rootDir, sourceName, type);
   } else {
     progress(`Using locally available npm package %s ...`, sourceName);
+    const packageName = await getPackageName(rootDir, sourceName, type);
+    const packageVersion = getPackageVersion(hadVersion, sourceName, sourceVersion, type, rootDir);
+    await updateExistingJson(rootDir, packageJson, {
+      devDependencies: {
+        [packageName]: packageVersion,
+      },
+    });
+    return packageName;
   }
+}
 
-  const packageName = await getPackageName(rootDir, sourceName, type);
-  const packageVersion = getPackageVersion(hadVersion, sourceName, sourceVersion, type, rootDir);
+export async function installPiralInstance(
+  usedSource: string,
+  baseDir: string,
+  rootDir: string,
+  npmClient: NpmClientType,
+  selected?: boolean,
+): Promise<string> {
+  const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(baseDir, usedSource);
 
-  return [packageName, packageVersion];
+  if (type === 'remote') {
+    const packageName = await scaffoldFromEmulatorWebsite(rootDir, sourceName);
+    await updatePiletJson(rootDir, packageName, {
+      selected,
+      url: sourceName,
+    });
+    return packageName;
+  } else {
+    const packageName = await setupPiralInstance(sourceName, type, hadVersion, rootDir, sourceVersion, npmClient);
+    await updatePiletJson(rootDir, packageName, {
+      selected,
+    });
+    return packageName;
+  }
 }