piral-cli 1.4.0-beta.6228 → 1.4.0-beta.6247

package/lib/types/public.d.ts

@@ -118,6 +118,7 @@ export interface BundlerPrepareArgs<T> {
 }
 export interface BaseBundlerDefinition<T> {
     path: string;
+    exec?: string;
     prepare?: BundlerPrepareArgs<T>;
 }
 export interface WatchPiralBundlerDefinition extends BaseBundlerDefinition<WatchPiralParameters> {
@@ -197,9 +198,9 @@ export type PiletSchemaVersion = 'none' | 'v0' | 'v1' | 'v2' | 'v3';
 export type SourceLanguage = 'js' | 'ts';
 export type PiletPublishScheme = 'none' | 'digest' | 'bearer' | 'basic';
 export type PiletPublishSource = 'local' | 'npm' | 'remote';
-export type PiralBuildType = 'all' | 'release' | 'emulator' | 'emulator-sources';
+export type PiralBuildType = 'all' | 'release' | 'emulator' | 'emulator-sources' | 'emulator-website';
 export type PiletBuildType = 'default' | 'standalone' | 'manifest';
-export type PackageType = 'registry' | 'file' | 'git';
+export type PackageType = 'registry' | 'file' | 'git' | 'remote';
 export type NpmClientType = 'npm' | 'yarn' | 'pnp' | 'pnpm' | 'lerna' | 'rush' | 'bun';
 export type Framework = 'piral' | 'piral-core' | 'piral-base';
 export interface StandardEnvProps {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "piral-cli",
-  "version": "1.4.0-beta.6228",
+  "version": "1.4.0-beta.6247",
   "description": "The standard CLI for creating and building a Piral instance or a Pilet.",
   "keywords": [
     "portal",
@@ -81,5 +81,5 @@
     "typescript": "^5.0.0",
     "yargs": "^15.0.0"
   },
-  "gitHead": "cbcd72a90e216dfa92f4a36f75208a1a11d840a5"
+  "gitHead": "31188a71482165dea7606cfafd7f9b77ce919331"
 }

package/src/apps/add-piral-instance-pilet.ts

@@ -74,13 +74,14 @@ export async function addPiralInstancePilet(baseDir = process.cwd(), options: Ad
       const piletJsonDir = dirname(piletJsonPath);
       const root = await findPiletRoot(piletJsonDir);
       const oldContent = await readJson(piletJsonDir, piletJson);
-      const [appName] = await installPiralInstance(app, fullBase, root, npmClient);
+      const [appName, _, appDetails] = await installPiralInstance(app, fullBase, root, npmClient);
 
       const newContent = {
         ...oldContent,
         piralInstances: {
           ...oldContent.piralInstances,
           [appName]: {
+            ...appDetails,
             selected,
           },
         },

package/src/apps/build-piral.ts

@@ -19,11 +19,14 @@ import {
   getDestination,
   validateSharedDependencies,
   flattenExternals,
+  createEmulatorWebsite,
 } from '../common';
 
+const allName = 'all';
 const releaseName = 'release';
 const emulatorName = 'emulator';
 const emulatorSourcesName = 'emulator-sources';
+const emulatorWebsiteName = 'emulator-website';
 
 export interface BuildPiralOptions {
   /**
@@ -118,7 +121,7 @@ export const buildPiralDefaults: BuildPiralOptions = {
   logLevel: LogLevels.info,
   fresh: false,
   minify: true,
-  type: 'all',
+  type: allName,
   subdir: true,
   sourceMaps: true,
   watch: false,
@@ -177,10 +180,11 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
     await removeDirectory(dest.outDir);
   }
 
-  // everything except release -> build emulator
-  if (type !== releaseName) {
+  // either 'emulator-*' or 'all'
+  if (type === emulatorName || type === emulatorSourcesName || type === emulatorWebsiteName || type === allName) {
     const emulatorPublicUrl = '/';
     const targetDir = useSubdir ? join(dest.outDir, emulatorName) : dest.outDir;
+    const appDir = type !== emulatorWebsiteName ? join(targetDir, 'app') : targetDir;
     progress('Starting emulator build ...');
 
     // since we create this anyway let's just pretend we want to have it clean!
@@ -209,7 +213,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
         entryFiles,
         logLevel,
         ignored,
-        outDir: join(targetDir, 'app'),
+        outDir: appDir,
         outFile: dest.outFile,
         _,
       },
@@ -233,24 +237,28 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
 
     await hooks.beforeEmulator?.({ root, externals, targetDir, outDir });
 
-    const rootDir = await createEmulatorSources(root, externals, outDir, outFile, logLevel);
+    const rootDir = await (type !== emulatorWebsiteName
+      ? createEmulatorSources(root, externals, outDir, outFile, logLevel)
+      : createEmulatorWebsite(root, externals, outDir, outFile, logLevel));
 
     await hooks.afterEmulator?.({ root, externals, targetDir, outDir, rootDir });
 
-    if (type !== emulatorSourcesName) {
+    if (type === allName || type === emulatorName) {
       await hooks.beforePackage?.({ root, externals, targetDir, outDir, rootDir });
       await packageEmulator(rootDir);
       await hooks.afterPackage?.({ root, externals, targetDir, outDir, rootDir });
       logDone(`Emulator package available in "${rootDir}".`);
-    } else {
+    } else if (type === emulatorSourcesName) {
       logDone(`Emulator sources available in "${rootDir}".`);
+    } else if (type === emulatorWebsiteName) {
+      logDone(`Emulator website available in "${rootDir}".`);
     }
 
     logReset();
   }
 
-  // everything except emulator and emulator-soruces -> build release
-  if (type !== emulatorName && type !== emulatorSourcesName) {
+  // either 'release' or 'all'
+  if (type === releaseName || type === allName) {
     const targetDir = useSubdir ? join(dest.outDir, releaseName) : dest.outDir;
     progress('Starting release build ...');
 

package/src/apps/new-pilet.ts

@@ -184,7 +184,7 @@ always-auth=true`,
       ),
     );
 
-    const [packageName, packageVersion] = await installPiralInstance(
+    const [packageName, packageVersion, packageDetails] = await installPiralInstance(
       source || `empty-piral@${cliVersion}`,
       fullBase,
       root,
@@ -209,6 +209,7 @@ always-auth=true`,
     await patchPiletPackage(root, packageName, packageVersion, piralInfo, isEmulator, {
       language,
       bundler: bundlerName,
+      details: packageDetails,
     });
 
     const chosenTemplate = template || preSelectedTemplate || 'default';

package/src/apps/run-emulator-piral.ts

@@ -117,7 +117,9 @@ always-auth=true`,
 
   const npmClient = await determineNpmClient(appRoot, defaultNpmClient);
   const [packageName] = await installPiralInstance(app, fullBase, appRoot, npmClient);
-  const piral = await findPiralInstance(packageName, appRoot, originalPort);
+  const piral = await findPiralInstance(packageName, appRoot, {
+    port: originalPort,
+  });
   const port = await getAvailablePort(piral.port);
 
   const krasBaseConfig = resolve(fullBase, krasrc);

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

@@ -1,4 +1,4 @@
-import { join, resolve, relative } from 'path';
+import { join, resolve, relative, basename } from 'path';
 import { findDependencyVersion, copyScaffoldingFiles, isValidDependency, flattenExternals } from './package';
 import { createPiralStubIndexIfNotExists } from './template';
 import { filesTar, filesOnceTar, packageJson, piralJson } from './constants';
@@ -7,16 +7,9 @@ import { createNpmPackage } from './npm';
 import { createPiralDeclaration } from './declaration';
 import { ForceOverwrite } from './enums';
 import { createTarball } from './archive';
-import { LogLevels, SharedDependency, PiletsInfo, TemplateFileLocation } from '../types';
-import {
-  createDirectory,
-  removeDirectory,
-  createFileIfNotExists,
-  updateExistingJson,
-  getFileNames,
-  removeAny,
-  readJson,
-} from './io';
+import { createDirectory, removeDirectory, matchFiles, removeAny, getFileNames } from './io';
+import { updateExistingJson, readJson, writeJson, createFileIfNotExists } from './io';
+import { EmulatorWebsiteManifest, LogLevels, SharedDependency, PiletsInfo, TemplateFileLocation } from '../types';
 
 export async function createEmulatorSources(
   sourceDir: string,
@@ -107,9 +100,9 @@ export async function createEmulatorSources(
       version: cliVersion,
       generated: true,
     },
-    main: `./${appDir}/index.js`,
-    typings: `./${appDir}/index.d.ts`,
-    app: `./${appDir}/index.html`,
+    main: `./${join(appDir, 'index.js')}`,
+    typings: `./${join(appDir, 'index.d.ts')}`,
+    app: `./${join(appDir, 'index.html')}`,
     peerDependencies: {},
     optionalDependencies,
     devDependencies: {
@@ -148,7 +141,7 @@ export async function createEmulatorSources(
   // actually including this one hints that the app shell should have been included - which is forbidden
   await createPiralStubIndexIfNotExists(targetDir, 'index.js', ForceOverwrite.yes, {
     name: piralPkg.name,
-    outFile: targetFile,
+    outFile: basename(targetFile),
   });
 
   // generate the associated index.d.ts
@@ -166,6 +159,93 @@ export async function createEmulatorSources(
   return rootDir;
 }
 
+export async function createEmulatorWebsite(
+  sourceDir: string,
+  externals: Array<SharedDependency>,
+  targetDir: string,
+  targetFile: string,
+  logLevel: LogLevels,
+) {
+  const piralPkg = await readJson(sourceDir, packageJson);
+  const piralJsonPkg = await readJson(sourceDir, piralJson);
+  const pilets: PiletsInfo = {
+    ...piralPkg.pilets,
+    ...piralJsonPkg.pilets,
+  };
+  const allDeps = {
+    ...piralPkg.devDependencies,
+    ...piralPkg.dependencies,
+  };
+
+  const externalPackages = await Promise.all(
+    externals
+      .filter((ext) => ext.type === 'local' && isValidDependency(ext.name))
+      .map(async (external) => ({
+        name: external.name,
+        version: await findDependencyVersion(piralPkg, sourceDir, external),
+        optional: external.isAsync,
+      })),
+  );
+  const externalDependencies = externalPackages.reduce((deps, dep) => {
+    if (!dep.optional) {
+      deps[dep.name] = dep.version;
+    }
+
+    return deps;
+  }, {} as Record<string, string>);
+
+  const importmapEntries = externalPackages.reduce((deps, dep) => {
+    if (!dep.optional) {
+      deps[dep.name] = dep.name;
+    }
+
+    return deps;
+  }, {} as Record<string, string>);
+
+  const optionalDependencies = externalPackages.reduce((deps, dep) => {
+    if (dep.optional) {
+      deps[dep.name] = dep.name;
+    }
+
+    return deps;
+  }, {} as Record<string, string>);
+
+  const allFiles = await matchFiles(targetDir, '*');
+  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,
+      },
+    },
+  };
+
+  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);
+
+  return targetDir;
+}
+
 export async function packageEmulator(rootDir: string) {
   // finally package everything up
   await createNpmPackage(rootDir);

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, piletJsonSchemaUrl, filesTar, filesOnceTar, bundlerNames } from './constants';
+import { frameworkLibs, declarationEntryExtensions, piralJson, piletJson, packageJson } 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(
@@ -653,7 +639,7 @@ export async function patchPiletPackage(
   version: string,
   piralInfo: PiralPackageData,
   fromEmulator: boolean,
-  newInfo?: { language: SourceLanguage; bundler: string },
+  newInfo?: { language: SourceLanguage; bundler: string; details: PiralInstanceDetails },
 ) {
   log('generalDebug_0003', `Patching the package.json in "${root}" ...`);
   const pkg = await getPiletPackage(root, name, version, piralInfo, fromEmulator, newInfo);
@@ -664,7 +650,7 @@ export async function patchPiletPackage(
   await updateExistingJson(root, piletJson, {
     $schema: piletJsonSchemaUrl,
     piralInstances: {
-      [name]: {},
+      [name]: newInfo?.details || {},
     },
   });
   log('generalDebug_0003', `Succesfully patched the pilet.json.`);
@@ -797,7 +783,7 @@ export async function retrievePiletData(target: string, app?: string) {
   const root = await findPiletRoot(proposedRoot);
   const piletPackage = await readJson(root, 'package.json');
   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,24 +1,26 @@
 import { progress } from './log';
-import {
-  combinePackageRef,
-  dissectPackageName,
-  getPackageName,
-  getPackageVersion,
-  installNpmPackage,
-  isLinkedPackage,
-} from './npm';
-import { NpmClientType } from '../types';
+import { scaffoldFromEmulatorWebsite } from './website';
+import { combinePackageRef, getPackageName, getPackageVersion } from './npm';
+import { dissectPackageName, installNpmPackage, isLinkedPackage } from './npm';
+import { NpmClientType, PiralInstanceDetails } from '../types';
 
 export async function installPiralInstance(
   usedSource: string,
   baseDir: string,
   rootDir: string,
   npmClient: NpmClientType,
-): Promise<[name: string, version: string]> {
+): Promise<[name: string, version: string, details: PiralInstanceDetails]> {
   const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(baseDir, usedSource);
-  const isLocal = isLinkedPackage(sourceName, type, hadVersion, rootDir);
 
-  if (!isLocal) {
+  if (type === 'remote') {
+    progress(`Downloading emulator from %s ...`, sourceName);
+    const emulatorJson = await scaffoldFromEmulatorWebsite(rootDir, sourceName);
+    const details = {
+      url: sourceName,
+    };
+
+    return [emulatorJson.name, emulatorJson.version, details];
+  } else if (!isLinkedPackage(sourceName, type, hadVersion, rootDir)) {
     const packageRef = combinePackageRef(sourceName, sourceVersion, type);
 
     progress(`Installing npm package %s ...`, packageRef);
@@ -29,6 +31,5 @@ export async function installPiralInstance(
 
   const packageName = await getPackageName(rootDir, sourceName, type);
   const packageVersion = getPackageVersion(hadVersion, sourceName, sourceVersion, type, rootDir);
-
-  return [packageName, packageVersion];
+  return [packageName, packageVersion, {}];
 }