piral-cli 0.15.0-alpha.4098 → 0.15.0-alpha.4257

package/src/common/package.ts

@@ -8,11 +8,12 @@ import { checkAppShellCompatibility } from './compatibility';
 import { deepMerge } from './merge';
 import { applyTemplate } from './template';
 import { readImportmap } from './importmap';
-import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makePiletExternals, makeExternals } from './npm';
 import { filesTar, filesOnceTar, declarationEntryExtensions, bundlerNames } from './constants';
 import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
-import { Framework, FileInfo, PiletsInfo, TemplateFileLocation } from '../types';
+import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath } from './npm';
+import { makePiletExternals, makeExternals, findPackageRoot } from './npm';
+import { Framework, FileInfo, PiletsInfo, TemplateFileLocation, PackageData } from '../types';
 
 function appendBundler(devDependencies: Record<string, string>, bundler: string, version: string) {
   if (bundler && bundler !== 'none') {
@@ -113,26 +114,13 @@ async function getMatchingFiles(
 }
 
 export function getPiralPath(root: string, name: string) {
-  try {
-    const path = require.resolve(`${name}/package.json`, {
-      paths: [root],
-    });
-    return dirname(path);
-  } catch (ex) {
-    log('generalDebug_0003', `Could not resolve the Piral path of "${name}" in "${root}": ${ex}.`);
+  const path = findPackageRoot(name, root);
+
+  if (!path) {
     fail('invalidPiralReference_0043');
   }
-}
 
-export function findPackageRoot(pck: string, baseDir: string) {
-  try {
-    return require.resolve(`${pck}/package.json`, {
-      paths: [baseDir],
-    });
-  } catch (ex) {
-    log('generalDebug_0003', `Could not find the package root in "${baseDir}": ${ex}.`);
-    return undefined;
-  }
+  return dirname(path);
 }
 
 function findPackage(pck: string | Array<string>, baseDir: string) {
@@ -161,7 +149,7 @@ function findPackage(pck: string | Array<string>, baseDir: string) {
   return undefined;
 }
 
-export function readPiralPackage(root: string, name: string) {
+export function readPiralPackage(root: string, name: string): Promise<PackageData> {
   log('generalDebug_0003', `Reading the piral package in "${root}" ...`);
   const path = getPiralPath(root, name);
   return readJson(path, 'package.json');
@@ -196,7 +184,12 @@ export function getPiralPackage(
     },
     importmap: {
       imports: {},
-      inherit: ['piral-base', framework !== 'piral-base' && 'piral-core'].filter(Boolean),
+      inherit: [
+        'piral-base', // this we take in any case
+        framework !== 'piral-base' && 'piral-core', // this we take unless we selected piral-base, then obviously core is not invited to the party
+        framework === 'piral' && 'piral', // this we take only if we selected piral
+        framework === 'piral-native' && 'piral-native', // this we also only take if we selected piral-native
+      ].filter(Boolean),
     },
     pilets: getPiletsInfo({}),
     dependencies,
@@ -325,10 +318,19 @@ function isTemplateFileLocation(item: string | TemplateFileLocation): item is Te
   return typeof item === 'object';
 }
 
+function tryFindPackageVersion(packageName: string): string {
+  try {
+    const { version } = require(`${packageName}/package.json`);
+    return version;
+  } catch {
+    return undefined;
+  }
+}
+
 export async function copyPiralFiles(
   root: string,
   name: string,
-  piralInfo: any,
+  piralInfo: PackageData,
   forceOverwrite: ForceOverwrite,
   variables: Record<string, string>,
   originalFiles?: Array<FileInfo>,
@@ -348,7 +350,7 @@ export async function copyPiralFiles(
   await copyFiles(files, forceOverwrite, originalFiles, variables);
 }
 
-export function getPiletsInfo(piralInfo: any): PiletsInfo {
+export function getPiletsInfo(piralInfo: Partial<PackageData>): PiletsInfo {
   const {
     files = [],
     scripts = {},
@@ -457,7 +459,7 @@ export async function retrieveExternals(root: string, packageInfo: any) {
       ...packageInfo.dependencies,
     };
     const deps = packageInfo.pilets?.externals;
-    return makeExternals(allDeps, deps);
+    return makeExternals(root, allDeps, deps);
   }
 
   return sharedDependencies.map((m) => m.name);
@@ -476,9 +478,9 @@ export async function retrievePiletsInfo(entryFile: string) {
     fail('packageJsonMissing_0074');
   }
 
+  const root = dirname(packageJson);
   const packageInfo = require(packageJson);
   const info = getPiletsInfo(packageInfo);
-  const root = dirname(packageJson);
   const externals = await retrieveExternals(root, packageInfo);
 
   return {
@@ -507,7 +509,7 @@ export async function patchPiletPackage(
   root: string,
   name: string,
   version: string,
-  piralInfo: any,
+  piralInfo: PackageData,
   fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
 ) {
@@ -531,7 +533,7 @@ export async function patchPiletPackage(
       }
     : info.scripts;
   const peerModules = [];
-  const allExternals = makePiletExternals(piralDependencies, externals, fromEmulator, piralInfo);
+  const allExternals = makePiletExternals(root, piralDependencies, externals, fromEmulator, piralInfo);
   const peerDependencies = {
     ...allExternals.reduce((deps, name) => {
       const valid = isValidDependency(name);
@@ -555,7 +557,7 @@ export async function patchPiletPackage(
       return deps;
     }, {}),
     ...allExternals.filter(isValidDependency).reduce((deps, name) => {
-      const version = piralDependencies[name];
+      const version = piralDependencies[name] || tryFindPackageVersion(name);
 
       if (version || newInfo) {
         // set only if we have an explicit version or we are in the scaffolding case
@@ -592,7 +594,7 @@ export async function patchPiletPackage(
 /**
  * Returns true if its an emulator package, otherwise it has to be a "raw" app shell.
  */
-export function checkAppShellPackage(appPackage: any) {
+export function checkAppShellPackage(appPackage: PackageData) {
   const { piralCLI = { generated: false, version: cliVersion } } = appPackage;
 
   if (piralCLI.generated) {

package/src/common/scaffold.ts

@@ -1,5 +1,5 @@
 import { join, dirname, resolve, basename, isAbsolute } from 'path';
-import { installPackage } from './clients/npm';
+import { installNpmPackage } from './npm';
 import { ForceOverwrite, SourceLanguage } from './enums';
 import { createDirectory, createFileIfNotExists, updateExistingJson } from './io';
 import { cliVersion, isWindows } from './info';
@@ -37,7 +37,11 @@ async function getTemplateFiles(
   if (templatePackageName.startsWith('.')) {
     templatePackageName = resolve(process.cwd(), templatePackageName);
   } else {
-    await installPackage(templatePackageName, __dirname, '--registry', registry);
+    if (templatePackageName.indexOf('@', 1) === -1) {
+      templatePackageName = `${templatePackageName}@latest`;
+    }
+
+    await installNpmPackage('npm', templatePackageName, __dirname, '--registry', registry);
   }
 
   const templateRunner = getTemplatePackage(templatePackageName);

package/src/common/version.ts

@@ -16,15 +16,15 @@ function indexOrEnd(str: string, q: string) {
 }
 
 function splitVersion(v: string) {
-  var c = v.replace(/^v/, '').replace(/\+.*$/, '');
-  var patchIndex = indexOrEnd(c, '-');
-  var arr = c.substring(0, patchIndex).split('.');
+  const c = v.replace(/^v/, '').replace(/\+.*$/, '');
+  const patchIndex = indexOrEnd(c, '-');
+  const arr = c.substring(0, patchIndex).split('.');
   arr.push(c.substring(patchIndex + 1));
   return arr;
 }
 
 function parseSegment(v: string) {
-  var n = parseInt(v, 10);
+  const n = parseInt(v, 10);
   return isNaN(n) ? v : n;
 }
 

package/src/external/index.ts

@@ -1,6 +1,7 @@
 import logger = require('@parcel/logger');
 import stripAnsi = require('strip-ansi');
 import inquirer = require('inquirer');
+import jju = require('jju');
 import glob = require('glob');
 import tar = require('tar');
 import FormData = require('form-data');
@@ -10,4 +11,4 @@ import mime = require('mime');
 import getPort = require('get-port');
 import open = require('open');
 
-export { logger, inquirer, glob, tar, FormData, rc, axios, mime, stripAnsi, getPort, open };
+export { logger, inquirer, glob, tar, FormData, rc, axios, mime, stripAnsi, getPort, open, jju };

package/src/helpers.test.ts

@@ -1,4 +1,4 @@
-import { keyOfForceOverwrite, keyOfPiletLanguage, valueOfForceOverwrite, valueOfPiletLanguage } from './helpers';
+import { keyOfForceOverwrite, keyOfSourceLanguage, valueOfForceOverwrite, valueOfSourceLanguage } from './helpers';
 import { ForceOverwrite, SourceLanguage } from './common/enums';
 
 describe('Piral CLI Command Helpers Module', () => {
@@ -13,12 +13,12 @@ describe('Piral CLI Command Helpers Module', () => {
   });
 
   it('correct value of keyOfPiletLanguage results in same key', () => {
-    const result = keyOfPiletLanguage(SourceLanguage.ts);
+    const result = keyOfSourceLanguage(SourceLanguage.ts);
     expect(result).toBe('ts');
   });
 
   it('incorrect value of keyOfPiletLanguage results in key for TS', () => {
-    const result = keyOfPiletLanguage(5);
+    const result = keyOfSourceLanguage(5);
     expect(result).toBe('ts');
   });
 
@@ -33,12 +33,12 @@ describe('Piral CLI Command Helpers Module', () => {
   });
 
   it('correct key of valueOfPiletLanguage results in same value', () => {
-    const result = valueOfPiletLanguage('ts');
+    const result = valueOfSourceLanguage('ts');
     expect(result).toBe(SourceLanguage.ts);
   });
 
   it('incorrect key of valueOfPiletLanguage results in value for TS', () => {
-    const result = valueOfPiletLanguage('foo');
+    const result = valueOfSourceLanguage('foo');
     expect(result).toBe(SourceLanguage.ts);
   });
 });

package/src/helpers.ts

@@ -1,6 +1,6 @@
 import { ForceOverwrite, SourceLanguage } from './common/enums';
 import { bundlerNames, frameworkLibs } from './common/constants';
-import {
+import type {
   Framework,
   NpmClientType,
   PiletSchemaVersion,
@@ -15,7 +15,7 @@ export const publishModeKeys: Array<PiletPublishScheme> = ['none', 'basic', 'bea
 export const fromKeys: Array<PiletPublishSource> = ['local', 'remote', 'npm'];
 export const piralBuildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
 export const piletBuildTypeKeys: Array<PiletBuildType> = ['default', 'standalone', 'manifest'];
-export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn'];
+export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn', 'lerna', 'rush'];
 export const bundlerKeys: Array<string> = ['none', ...bundlerNames];
 export const availableBundlers: Array<string> = [];
 export const availableReleaseProviders: Array<string> = [];
@@ -42,10 +42,10 @@ export function keyOfForceOverwrite(value: ForceOverwrite) {
   return forceOverwriteKeys[0];
 }
 
-export const piletLanguageKeys = Object.keys(SourceLanguage).filter((m) => typeof SourceLanguage[m] === 'number');
+export const sourceLanguageKeys = Object.keys(SourceLanguage).filter((m) => typeof SourceLanguage[m] === 'number');
 
-export function valueOfPiletLanguage(key: string): SourceLanguage {
-  for (const piletLanguageKey of piletLanguageKeys) {
+export function valueOfSourceLanguage(key: string): SourceLanguage {
+  for (const piletLanguageKey of sourceLanguageKeys) {
     if (piletLanguageKey === key) {
       return SourceLanguage[piletLanguageKey];
     }
@@ -54,12 +54,12 @@ export function valueOfPiletLanguage(key: string): SourceLanguage {
   return SourceLanguage.ts;
 }
 
-export function keyOfPiletLanguage(value: SourceLanguage) {
-  for (const piletLanguageKey of piletLanguageKeys) {
+export function keyOfSourceLanguage(value: SourceLanguage) {
+  for (const piletLanguageKey of sourceLanguageKeys) {
     if (SourceLanguage[piletLanguageKey] === value) {
       return piletLanguageKey;
     }
   }
 
-  return piletLanguageKeys[0];
+  return sourceLanguageKeys[0];
 }

package/src/injectors/{pilet.test.ts → pilet-injector.test.ts}

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
 import { KrasRequest } from 'kras';
-import PiletInjector from './pilet';
+import PiletInjector from './pilet-injector';
 
 const optionsMock = {
   pilets: [],
@@ -9,6 +9,9 @@ const optionsMock = {
   api: '',
   app: '',
   active: true,
+  publicUrl: '/',
+  meta: '',
+  headers: {},
 };
 
 const configMock: any = {
@@ -89,6 +92,9 @@ describe('Piral-CLI piral injector', () => {
       publicUrl: '/',
       api: 'http://someFakeApi:1234',
       app: '',
+      publicUrl: '/',
+      meta: '',
+      headers: {},
       active: true,
     };
 
@@ -118,6 +124,9 @@ describe('Piral-CLI piral injector', () => {
       publicUrl: '/',
       api: 'http://someFakeApi:1234',
       app: '',
+      publicUrl: '/',
+      meta: '',
+      headers: {},
       active: true,
     };
     const core = new EventEmitter();

package/src/injectors/{pilet.ts → pilet-injector.ts}

@@ -6,7 +6,7 @@ import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig, KrasConfig
 import { log } from '../common/log';
 import { getPiletSpecMeta } from '../common/spec';
 import { config } from '../common/config';
-import { axios, mime } from '../external';
+import { axios, mime, jju } from '../external';
 import { Bundler } from '../types';
 
 const { host } = config;
@@ -24,6 +24,7 @@ export interface PiletInjectorConfig extends KrasInjectorConfig {
   api: string;
   app: string;
   feed?: string;
+  headers: Record<string, string>;
 }
 
 interface PiletMetadata {
@@ -35,8 +36,8 @@ function fillPiletMeta(pilet: Pilet, basePath: string, metaFile: string) {
   const { root, bundler } = pilet;
   const metaPath = join(root, metaFile);
   const packagePath = join(root, 'package.json');
-  const def = JSON.parse(readFileSync(packagePath, 'utf8'));
-  const metaOverride = existsSync(metaPath) ? JSON.parse(readFileSync(metaPath, 'utf8')) : undefined;
+  const def = jju.parse(readFileSync(packagePath, 'utf8'));
+  const metaOverride = existsSync(metaPath) ? jju.parse(readFileSync(metaPath, 'utf8')) : undefined;
   const file = bundler.bundle.name.replace(/^[\/\\]/, '');
   const target = join(bundler.bundle.dir, file);
   const url = new URL(file, basePath);
@@ -79,40 +80,44 @@ export default class PiletInjector implements KrasInjector {
 
   constructor(options: PiletInjectorConfig, config: KrasConfiguration, core: EventEmitter) {
     this.config = options;
-    // either take a full URI or make it an absolute path relative to the current origin
-    this.piletApi = /^https?:/.test(options.api)
-      ? options.api
-      : `${config.ssl ? 'https' : 'http'}://${host}:${config.port}${options.api}`;
-
-    const { pilets, api, publicUrl } = options;
-    this.indexPath = `${publicUrl}index.html`;
-    const cbs = {};
-
-    core.on('user-connected', (e) => {
-      if (e.target === '*' && e.url === api.substring(1)) {
-        cbs[e.id] = (msg: string) => e.ws.send(msg);
-      }
-    });
 
-    core.on('user-disconnected', (e) => {
-      delete cbs[e.id];
-    });
+    if (this.config.active) {
+      // either take a full URI or make it an absolute path relative to the current origin
+      this.piletApi = /^https?:/.test(options.api)
+        ? options.api
+        : `${config.ssl ? 'https' : 'http'}://${host}:${config.port}${options.api}`;
 
-    pilets.forEach((p, i) =>
-      p.bundler.on(() => {
-        const basePath = `${this.piletApi}/${i}/`;
-        const meta = fillPiletMeta(p, basePath, options.meta);
+      const { pilets, api, publicUrl } = options;
+      this.indexPath = `${publicUrl}index.html`;
+      const cbs = {};
 
-        for (const id of Object.keys(cbs)) {
-          cbs[id](meta);
+      core.on('user-connected', (e) => {
+        if (e.target === '*' && e.url === api.substring(1)) {
+          cbs[e.id] = (msg: string) => e.ws.send(msg);
         }
-      }),
-    );
+      });
+
+      core.on('user-disconnected', (e) => {
+        delete cbs[e.id];
+      });
+
+      pilets.forEach((p, i) =>
+        p.bundler.on(() => {
+          const basePath = `${this.piletApi}/${i}/`;
+          const meta = fillPiletMeta(p, basePath, options.meta);
+
+          for (const id of Object.keys(cbs)) {
+            cbs[id](meta);
+          }
+        }),
+      );
+    }
   }
 
   get active() {
     return this.config.active;
   }
+
   set active(value) {
     this.config.active = value;
   }
@@ -159,9 +164,12 @@ export default class PiletInjector implements KrasInjector {
   }
 
   sendContent(content: Buffer | string, type: string, url: string): KrasResponse {
+    const { headers } = this.config;
+
     return {
       injector: { name: this.name },
       headers: {
+        ...headers,
         'content-type': type,
         'cache-control': 'no-cache, no-store, must-revalidate',
         pragma: 'no-cache',

package/src/injectors/{piral.test.ts → piral-injector.test.ts}

@@ -1,4 +1,4 @@
-import PiralInjector from './piral';
+import PiralInjector from './piral-injector';
 import { KrasRequest, KrasResult } from 'kras';
 import { EventEmitter } from 'events';
 
@@ -37,6 +37,7 @@ describe('Piral-CLI piral injector', () => {
       bundler,
       publicUrl: '/',
       active: true,
+      headers: {},
     };
     const injector = new PiralInjector(config, undefined, new EventEmitter());
     expect(injector.active).toBeTruthy();
@@ -48,6 +49,7 @@ describe('Piral-CLI piral injector', () => {
       bundler: bundlerMock,
       publicUrl: '/',
       active: true,
+      headers: {},
     };
     const injector = new PiralInjector(config, undefined, new EventEmitter());
 
@@ -67,6 +69,7 @@ describe('Piral-CLI piral injector', () => {
       bundler: bundlerMock,
       publicUrl: '/',
       active: true,
+      headers: {},
     };
     const injector = new PiralInjector(config, undefined, new EventEmitter());
 
@@ -83,6 +86,7 @@ describe('Piral-CLI piral injector', () => {
       bundler: bundlerMock,
       publicUrl: '/',
       active: true,
+      headers: {},
     };
     const injector = new PiralInjector(config, undefined, new EventEmitter());
     const request: KrasRequest = {

package/src/injectors/{piral.ts → piral-injector.ts}

@@ -14,6 +14,7 @@ export interface PiralInjectorConfig extends KrasInjectorConfig {
   bundler: Bundler;
   publicUrl: string;
   feed?: string;
+  headers: Record<string, string>;
 }
 
 export default class PiralInjector implements KrasInjector {
@@ -21,29 +22,33 @@ export default class PiralInjector implements KrasInjector {
 
   constructor(options: PiralInjectorConfig, _config: KrasConfiguration, core: EventEmitter) {
     this.config = options;
-    const api = '/$events';
-    const cbs = {};
 
-    core.on('user-connected', (e) => {
-      if (e.target === '*' && e.url === api.substring(1)) {
-        cbs[e.id] = (msg: string) => e.ws.send(msg);
-      }
-    });
-
-    core.on('user-disconnected', (e) => {
-      delete cbs[e.id];
-    });
-
-    this.config.bundler.on((args) => {
-      for (const id of Object.keys(cbs)) {
-        cbs[id](JSON.stringify(args));
-      }
-    });
+    if (this.config.active) {
+      const api = '/$events';
+      const cbs = {};
+
+      core.on('user-connected', (e) => {
+        if (e.target === '*' && e.url === api.substring(1)) {
+          cbs[e.id] = (msg: string) => e.ws.send(msg);
+        }
+      });
+
+      core.on('user-disconnected', (e) => {
+        delete cbs[e.id];
+      });
+
+      this.config.bundler.on((args) => {
+        for (const id of Object.keys(cbs)) {
+          cbs[id](JSON.stringify(args));
+        }
+      });
+    }
   }
 
   get active() {
     return this.config.active;
   }
+
   set active(value) {
     this.config.active = value;
   }
@@ -59,9 +64,11 @@ export default class PiralInjector implements KrasInjector {
   setOptions() {}
 
   sendContent(content: Buffer | string, type: string, url: string): KrasResponse {
+    const { headers } = this.config;
     return {
       injector: { name: this.name },
       headers: {
+        ...headers,
         'content-type': type,
         'cache-control': 'no-cache, no-store, must-revalidate',
         pragma: 'no-cache',

package/src/messages.ts

@@ -549,7 +549,11 @@ export function importMapVersionSpecInvalid_0026(depName: string): QuickMessage
  * node modules are most likely not installed (correctly).
  */
 export function importMapReferenceNotFound_0027(dir: string, reference: string): QuickMessage {
-  return [LogLevels.error, '0027', `The reference to "${reference}" could not be resolved from "${dir}". Are you sure the file or package exists?`];
+  return [
+    LogLevels.error,
+    '0027',
+    `The reference to "${reference}" could not be resolved from "${dir}". Are you sure the file or package exists?`,
+  ];
 }
 
 /**
@@ -1842,7 +1846,7 @@ export function packageJsonMissing_0075(): QuickMessage {
  * The TypeScript declaration generator will take all files as input to
  * gather all required information for constructing the API declaration.
  */
-export function declarationCouldNotBeGenerated_0076(rootDir: string, error: Error): QuickMessage {
+export function declarationCouldNotBeGenerated_0076(rootDir: string, error: Error | string): QuickMessage {
   return [LogLevels.error, '0076', `Could not create the declaration in "${rootDir}". Error: ${error}`];
 }
 

package/src/plugin.ts

@@ -1,10 +1,39 @@
 import { readdir, stat } from 'fs';
-import { join, resolve } from 'path';
-import { log } from './common';
+import { join, resolve, sep, posix } from 'path';
+import { cliName, cliVersion, log } from './common';
 import { inject } from './inject';
 
-function getLocalPackageDir() {
-  return resolve(__dirname, '..', '..');
+function getContainerDir() {
+  const currentDir = __dirname.split(sep).join(posix.sep);
+
+  if (!currentDir.includes(`/.pnpm/${cliName}@${cliVersion}/node_modules/${cliName}/`)) {
+    return resolve(__dirname, '..', '..');
+  }
+
+  return undefined;
+}
+
+async function getLocalPackageDir() {
+  const proposedDirs = [
+    getContainerDir(),
+    resolve(process.cwd(), 'node_modules'),
+    resolve(process.cwd(), '..', 'node_modules'),
+    resolve(process.cwd(), '..', '..', 'node_modules'),
+    resolve(process.cwd(), '..', '..', '..', 'node_modules'),
+  ];
+
+  // Right now we always take the first one, but in the future this may be different
+  // once we come up with more / better criteria to identify if its a good/valid
+  // plugin root directory
+  for (const dir of proposedDirs.filter(Boolean)) {
+    log('generalDebug_0003', `Checking for potential plugin directory "${dir}" ...`);
+
+    if (await isDirectory(dir)) {
+      return dir;
+    }
+  }
+
+  return undefined;
 }
 
 function isDirectory(dir: string) {
@@ -83,7 +112,7 @@ async function getAllPlugins(rootDir: string): Promise<Array<string>> {
 }
 
 export async function loadPlugins() {
-  const localDir = getLocalPackageDir();
+  const localDir = await getLocalPackageDir();
   const allPlugins = await getAllPlugins(localDir);
 
   for (const pluginPath of allPlugins) {

package/src/release.ts

@@ -21,6 +21,9 @@ const providers: Record<string, ReleaseProvider> = {
 
     await Promise.all(files.map(async (file) => copy(file, resolve(target, basename(file)))));
   },
+  async feed(files, args, interactive) {
+    //TODO post files to Piral Feed Service
+  },
 };
 
 function findReleaseProvider(providerName: string) {
@@ -43,7 +46,12 @@ export function setReleaseProvider(provider: QualifiedReleaseProvider) {
   }
 }
 
-export function publishArtifacts(providerName: string, files: Array<string>, args: Record<string, string>) {
+export function publishArtifacts(
+  providerName: string,
+  files: Array<string>,
+  args: Record<string, string>,
+  interactive: boolean,
+) {
   const runRelease = findReleaseProvider(providerName);
-  return runRelease(files, args);
+  return runRelease(files, args, interactive);
 }

package/src/types/common.ts

@@ -42,7 +42,7 @@ export interface Bundler {
 }
 
 export interface ReleaseProvider {
-  (files: Array<string>, args: Record<string, string>): Promise<void>;
+  (files: Array<string>, args: Record<string, string>, interactive: boolean): Promise<void>;
 }
 
 export interface TemplateFileLocation {