@teambit/scripts 0.0.0-00df84d7db07c10ea89ca52e1dfa26599e0b6049

package/dist/exceptions/index.d.ts

@@ -0,0 +1 @@
+export { ScriptNotFound } from './script-not-found';

package/dist/exceptions/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ScriptNotFound", {
+  enumerable: true,
+  get: function () {
+    return _scriptNotFound().ScriptNotFound;
+  }
+});
+function _scriptNotFound() {
+  const data = require("./script-not-found");
+  _scriptNotFound = function () {
+    return data;
+  };
+  return data;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/exceptions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_scriptNotFound","data","require"],"sources":["index.ts"],"sourcesContent":["export { ScriptNotFound } from './script-not-found';\n"],"mappings":";;;;;;;;;;;AAAA,SAAAA,gBAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,eAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA","ignoreList":[]}

package/dist/exceptions/script-not-found.d.ts

@@ -0,0 +1,6 @@
+import { BitError } from '@teambit/bit-error';
+export declare class ScriptNotFound extends BitError {
+    readonly scriptName: string;
+    readonly envId: string;
+    constructor(scriptName: string, envId: string);
+}

package/dist/exceptions/script-not-found.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScriptNotFound = void 0;
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+class ScriptNotFound extends _bitError().BitError {
+  constructor(scriptName, envId) {
+    super(`script "${scriptName}" was not found in environment "${envId}"`);
+    this.scriptName = scriptName;
+    this.envId = envId;
+  }
+}
+exports.ScriptNotFound = ScriptNotFound;
+
+//# sourceMappingURL=script-not-found.js.map

package/dist/exceptions/script-not-found.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_bitError","data","require","ScriptNotFound","BitError","constructor","scriptName","envId","exports"],"sources":["script-not-found.ts"],"sourcesContent":["import { BitError } from '@teambit/bit-error';\n\nexport class ScriptNotFound extends BitError {\n  constructor(\n    readonly scriptName: string,\n    readonly envId: string\n  ) {\n    super(`script \"${scriptName}\" was not found in environment \"${envId}\"`);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,UAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,SAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAME,cAAc,SAASC,oBAAQ,CAAC;EAC3CC,WAAWA,CACAC,UAAkB,EAClBC,KAAa,EACtB;IACA,KAAK,CAAC,WAAWD,UAAU,mCAAmCC,KAAK,GAAG,CAAC;IAAC,KAH/DD,UAAkB,GAAlBA,UAAkB;IAAA,KAClBC,KAAa,GAAbA,KAAa;EAGxB;AACF;AAACC,OAAA,CAAAL,cAAA,GAAAA,cAAA","ignoreList":[]}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { ScriptsAspect } from './scripts.aspect';
+export type { ScriptsMain } from './scripts.main.runtime';
+export { Scripts } from './scripts';
+export type { ScriptHandler, ScriptDefinition, ScriptsMap } from './script-definition';
+export { ScriptNotFound } from './exceptions';
+export default ScriptsAspect;
+export { ScriptsAspect };

package/dist/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ScriptNotFound", {
+  enumerable: true,
+  get: function () {
+    return _exceptions().ScriptNotFound;
+  }
+});
+Object.defineProperty(exports, "Scripts", {
+  enumerable: true,
+  get: function () {
+    return _scripts2().Scripts;
+  }
+});
+Object.defineProperty(exports, "ScriptsAspect", {
+  enumerable: true,
+  get: function () {
+    return _scripts().ScriptsAspect;
+  }
+});
+exports.default = void 0;
+function _scripts() {
+  const data = require("./scripts.aspect");
+  _scripts = function () {
+    return data;
+  };
+  return data;
+}
+function _scripts2() {
+  const data = require("./scripts");
+  _scripts2 = function () {
+    return data;
+  };
+  return data;
+}
+function _exceptions() {
+  const data = require("./exceptions");
+  _exceptions = function () {
+    return data;
+  };
+  return data;
+}
+var _default = exports.default = _scripts().ScriptsAspect;
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_scripts","data","require","_scripts2","_exceptions","_default","exports","default","ScriptsAspect"],"sources":["index.ts"],"sourcesContent":["import { ScriptsAspect } from './scripts.aspect';\n\nexport type { ScriptsMain } from './scripts.main.runtime';\nexport { Scripts } from './scripts';\nexport type { ScriptHandler, ScriptDefinition, ScriptsMap } from './script-definition';\nexport { ScriptNotFound } from './exceptions';\nexport default ScriptsAspect;\nexport { ScriptsAspect };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAAA,SAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,QAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAGA,SAAAE,UAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,SAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAG,YAAA;EAAA,MAAAH,IAAA,GAAAC,OAAA;EAAAE,WAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA8C,IAAAI,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAC/BC,wBAAa","ignoreList":[]}

package/dist/preview-1760387564381.js

@@ -0,0 +1,7 @@
+;
+;
+
+export const compositions = [];
+export const overview = [];
+
+export const compositions_metadata = {"compositions":[]};

package/dist/script-definition.d.ts

@@ -0,0 +1,12 @@
+import type { Component } from '@teambit/component';
+export interface ScriptExecuteContext {
+    components: Component[];
+}
+export type ScriptHandler = string | ((context?: ScriptExecuteContext) => void | Promise<void>);
+export interface ScriptDefinition {
+    name: string;
+    handler: ScriptHandler;
+}
+export interface ScriptsMap {
+    [scriptName: string]: ScriptHandler;
+}

package/dist/script-definition.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=script-definition.js.map

package/dist/script-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["script-definition.ts"],"sourcesContent":["import type { Component } from '@teambit/component';\n\nexport interface ScriptExecuteContext {\n  components: Component[];\n}\n\nexport type ScriptHandler = string | ((context?: ScriptExecuteContext) => void | Promise<void>);\n\nexport interface ScriptDefinition {\n  name: string;\n  handler: ScriptHandler;\n}\n\nexport interface ScriptsMap {\n  [scriptName: string]: ScriptHandler;\n}\n"],"mappings":"","ignoreList":[]}

package/dist/script.cmd.d.ts

@@ -0,0 +1,20 @@
+import type { Command, CommandOptions } from '@teambit/cli';
+import type { ScriptsMain } from './scripts.main.runtime';
+export type ScriptOptions = {
+    list?: boolean;
+};
+export declare class ScriptCmd implements Command {
+    private scripts;
+    name: string;
+    description: string;
+    extendedDescription: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    alias: string;
+    group: string;
+    options: CommandOptions;
+    constructor(scripts: ScriptsMain);
+    report(args: string[], options: ScriptOptions): Promise<string>;
+}

package/dist/script.cmd.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScriptCmd = void 0;
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class ScriptCmd {
+  constructor(scripts) {
+    this.scripts = scripts;
+    _defineProperty(this, "name", 'script [script-name]');
+    _defineProperty(this, "description", 'run a script defined by the environment');
+    _defineProperty(this, "extendedDescription", `executes custom scripts defined by component environments.
+scripts can be shell commands or JavaScript functions defined in env.scripts().
+runs the script for all components grouped by their environment.
+use --list to see all available scripts.`);
+    _defineProperty(this, "arguments", [{
+      name: 'script-name',
+      description: 'the name of the script to run (e.g., "generate-svg", "pre-snap")'
+    }]);
+    _defineProperty(this, "alias", '');
+    _defineProperty(this, "group", 'development');
+    _defineProperty(this, "options", [['l', 'list', 'list all available scripts from all environments']]);
+  }
+  async report(args, options) {
+    const [scriptName] = args;
+    if (options.list) {
+      return this.scripts.listAllScripts();
+    }
+    if (!scriptName) {
+      throw new Error('script name is required. Use --list to see available scripts.');
+    }
+    return this.scripts.runScript(scriptName);
+  }
+}
+exports.ScriptCmd = ScriptCmd;
+
+//# sourceMappingURL=script.cmd.js.map

package/dist/script.cmd.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ScriptCmd","constructor","scripts","_defineProperty","name","description","report","args","options","scriptName","list","listAllScripts","Error","runScript","exports"],"sources":["script.cmd.ts"],"sourcesContent":["import type { Command, CommandOptions } from '@teambit/cli';\nimport type { ScriptsMain } from './scripts.main.runtime';\n\nexport type ScriptOptions = {\n  list?: boolean;\n};\n\nexport class ScriptCmd implements Command {\n  name = 'script [script-name]';\n  description = 'run a script defined by the environment';\n  extendedDescription = `executes custom scripts defined by component environments.\nscripts can be shell commands or JavaScript functions defined in env.scripts().\nruns the script for all components grouped by their environment.\nuse --list to see all available scripts.`;\n  arguments = [\n    {\n      name: 'script-name',\n      description: 'the name of the script to run (e.g., \"generate-svg\", \"pre-snap\")',\n    },\n  ];\n  alias = '';\n  group = 'development';\n  options = [['l', 'list', 'list all available scripts from all environments']] as CommandOptions;\n\n  constructor(private scripts: ScriptsMain) {}\n\n  async report(args: string[], options: ScriptOptions): Promise<string> {\n    const [scriptName] = args;\n\n    if (options.list) {\n      return this.scripts.listAllScripts();\n    }\n\n    if (!scriptName) {\n      throw new Error('script name is required. Use --list to see available scripts.');\n    }\n\n    return this.scripts.runScript(scriptName);\n  }\n}\n"],"mappings":";;;;;;;;;AAOO,MAAMA,SAAS,CAAoB;EAiBxCC,WAAWA,CAASC,OAAoB,EAAE;IAAA,KAAtBA,OAAoB,GAApBA,OAAoB;IAAAC,eAAA,eAhBjC,sBAAsB;IAAAA,eAAA,sBACf,yCAAyC;IAAAA,eAAA,8BACjC;AACxB;AACA;AACA,yCAAyC;IAAAA,eAAA,oBAC3B,CACV;MACEC,IAAI,EAAE,aAAa;MACnBC,WAAW,EAAE;IACf,CAAC,CACF;IAAAF,eAAA,gBACO,EAAE;IAAAA,eAAA,gBACF,aAAa;IAAAA,eAAA,kBACX,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,kDAAkD,CAAC,CAAC;EAElC;EAE3C,MAAMG,MAAMA,CAACC,IAAc,EAAEC,OAAsB,EAAmB;IACpE,MAAM,CAACC,UAAU,CAAC,GAAGF,IAAI;IAEzB,IAAIC,OAAO,CAACE,IAAI,EAAE;MAChB,OAAO,IAAI,CAACR,OAAO,CAACS,cAAc,CAAC,CAAC;IACtC;IAEA,IAAI,CAACF,UAAU,EAAE;MACf,MAAM,IAAIG,KAAK,CAAC,+DAA+D,CAAC;IAClF;IAEA,OAAO,IAAI,CAACV,OAAO,CAACW,SAAS,CAACJ,UAAU,CAAC;EAC3C;AACF;AAACK,OAAA,CAAAd,SAAA,GAAAA,SAAA","ignoreList":[]}

package/dist/scripts.aspect.d.ts

@@ -0,0 +1,2 @@
+import { Aspect } from '@teambit/harmony';
+export declare const ScriptsAspect: Aspect;

package/dist/scripts.aspect.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScriptsAspect = void 0;
+function _harmony() {
+  const data = require("@teambit/harmony");
+  _harmony = function () {
+    return data;
+  };
+  return data;
+}
+const ScriptsAspect = exports.ScriptsAspect = _harmony().Aspect.create({
+  id: 'teambit.workspace/scripts'
+});
+
+//# sourceMappingURL=scripts.aspect.js.map

package/dist/scripts.aspect.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_harmony","data","require","ScriptsAspect","exports","Aspect","create","id"],"sources":["scripts.aspect.ts"],"sourcesContent":["import { Aspect } from '@teambit/harmony';\n\nexport const ScriptsAspect = Aspect.create({\n  id: 'teambit.workspace/scripts',\n});\n"],"mappings":";;;;;;AAAA,SAAAA,SAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,QAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAME,aAAa,GAAAC,OAAA,CAAAD,aAAA,GAAGE,iBAAM,CAACC,MAAM,CAAC;EACzCC,EAAE,EAAE;AACN,CAAC,CAAC","ignoreList":[]}

package/dist/scripts.d.ts

@@ -0,0 +1,12 @@
+import type { EnvHandler } from '@teambit/envs';
+import type { ScriptHandler, ScriptsMap } from './script-definition';
+export declare class Scripts {
+    private scriptsMap;
+    constructor(scriptsMap: ScriptsMap);
+    static from(scripts: ScriptsMap): EnvHandler<Scripts>;
+    get(name: string): ScriptHandler | undefined;
+    has(name: string): boolean;
+    list(): string[];
+    getAll(): ScriptsMap;
+    isEmpty(): boolean;
+}

package/dist/scripts.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Scripts = void 0;
+class Scripts {
+  constructor(scriptsMap) {
+    this.scriptsMap = scriptsMap;
+  }
+  static from(scripts) {
+    return _context => {
+      return new Scripts(scripts);
+    };
+  }
+  get(name) {
+    return this.scriptsMap[name];
+  }
+  has(name) {
+    return name in this.scriptsMap;
+  }
+  list() {
+    return Object.keys(this.scriptsMap);
+  }
+  getAll() {
+    return this.scriptsMap;
+  }
+  isEmpty() {
+    return this.list().length === 0;
+  }
+}
+exports.Scripts = Scripts;
+
+//# sourceMappingURL=scripts.js.map

package/dist/scripts.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Scripts","constructor","scriptsMap","from","scripts","_context","get","name","has","list","Object","keys","getAll","isEmpty","length","exports"],"sources":["scripts.ts"],"sourcesContent":["import type { EnvContext, EnvHandler } from '@teambit/envs';\nimport type { ScriptHandler, ScriptsMap } from './script-definition';\n\nexport class Scripts {\n  constructor(private scriptsMap: ScriptsMap) {}\n\n  static from(scripts: ScriptsMap): EnvHandler<Scripts> {\n    return (_context: EnvContext) => {\n      return new Scripts(scripts);\n    };\n  }\n\n  get(name: string): ScriptHandler | undefined {\n    return this.scriptsMap[name];\n  }\n\n  has(name: string): boolean {\n    return name in this.scriptsMap;\n  }\n\n  list(): string[] {\n    return Object.keys(this.scriptsMap);\n  }\n\n  getAll(): ScriptsMap {\n    return this.scriptsMap;\n  }\n\n  isEmpty(): boolean {\n    return this.list().length === 0;\n  }\n}\n"],"mappings":";;;;;;AAGO,MAAMA,OAAO,CAAC;EACnBC,WAAWA,CAASC,UAAsB,EAAE;IAAA,KAAxBA,UAAsB,GAAtBA,UAAsB;EAAG;EAE7C,OAAOC,IAAIA,CAACC,OAAmB,EAAuB;IACpD,OAAQC,QAAoB,IAAK;MAC/B,OAAO,IAAIL,OAAO,CAACI,OAAO,CAAC;IAC7B,CAAC;EACH;EAEAE,GAAGA,CAACC,IAAY,EAA6B;IAC3C,OAAO,IAAI,CAACL,UAAU,CAACK,IAAI,CAAC;EAC9B;EAEAC,GAAGA,CAACD,IAAY,EAAW;IACzB,OAAOA,IAAI,IAAI,IAAI,CAACL,UAAU;EAChC;EAEAO,IAAIA,CAAA,EAAa;IACf,OAAOC,MAAM,CAACC,IAAI,CAAC,IAAI,CAACT,UAAU,CAAC;EACrC;EAEAU,MAAMA,CAAA,EAAe;IACnB,OAAO,IAAI,CAACV,UAAU;EACxB;EAEAW,OAAOA,CAAA,EAAY;IACjB,OAAO,IAAI,CAACJ,IAAI,CAAC,CAAC,CAACK,MAAM,KAAK,CAAC;EACjC;AACF;AAACC,OAAA,CAAAf,OAAA,GAAAA,OAAA","ignoreList":[]}

package/dist/scripts.main.runtime.d.ts

@@ -0,0 +1,41 @@
+import { CLIMain } from '@teambit/cli';
+import { ComponentMain } from '@teambit/component';
+import type { EnvsMain } from '@teambit/envs';
+import type { Logger, LoggerMain } from '@teambit/logger';
+import type { Workspace } from '@teambit/workspace';
+export interface ScriptsConfig {
+    envs?: string[];
+}
+export declare class ScriptsMain {
+    private workspace;
+    private envs;
+    private logger;
+    private componentAspect;
+    private config;
+    constructor(workspace: Workspace, envs: EnvsMain, logger: Logger, componentAspect: ComponentMain, config: ScriptsConfig);
+    private getConfigErrorMessage;
+    /**
+     * Run a script for all components
+     */
+    runScript(scriptName: string): Promise<string>;
+    /**
+     * List all available scripts from all environments
+     */
+    listAllScripts(): Promise<string>;
+    /**
+     * Check if an env is allowed to run scripts based on config
+     * Supports exact match with or without version
+     */
+    private isEnvAllowed;
+    private getComponents;
+    private groupComponentsByEnv;
+    private getScriptsFromEnv;
+    private executeScript;
+    private executeShellCommand;
+    private executeFunction;
+    static slots: never[];
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static provider([cli, workspace, envs, componentAspect, loggerMain]: [CLIMain, Workspace, EnvsMain, ComponentMain, LoggerMain], config: ScriptsConfig): Promise<ScriptsMain>;
+}
+export default ScriptsMain;

package/dist/scripts.main.runtime.js

@@ -0,0 +1,284 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ScriptsMain = void 0;
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _component() {
+  const data = require("@teambit/component");
+  _component = function () {
+    return data;
+  };
+  return data;
+}
+function _envs() {
+  const data = require("@teambit/envs");
+  _envs = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@teambit/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _workspace() {
+  const data = require("@teambit/workspace");
+  _workspace = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _child_process() {
+  const data = require("child_process");
+  _child_process = function () {
+    return data;
+  };
+  return data;
+}
+function _scripts() {
+  const data = require("./scripts.aspect");
+  _scripts = function () {
+    return data;
+  };
+  return data;
+}
+function _scripts2() {
+  const data = require("./scripts.service");
+  _scripts2 = function () {
+    return data;
+  };
+  return data;
+}
+function _script() {
+  const data = require("./script.cmd");
+  _script = function () {
+    return data;
+  };
+  return data;
+}
+function _exceptions() {
+  const data = require("./exceptions");
+  _exceptions = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class ScriptsMain {
+  constructor(workspace, envs, logger, componentAspect, config) {
+    this.workspace = workspace;
+    this.envs = envs;
+    this.logger = logger;
+    this.componentAspect = componentAspect;
+    this.config = config;
+  }
+  getConfigErrorMessage() {
+    return _chalk().default.yellow('no envs configured. Add to workspace.jsonc:\n' + '{\n' + '  "teambit.workspace/scripts": {\n' + '    "envs": ["your-scope/your-env"]\n' + '  }\n' + '}');
+  }
+
+  /**
+   * Run a script for all components
+   */
+  async runScript(scriptName) {
+    // Filter envs based on config
+    const allowedEnvs = this.config.envs || [];
+    if (allowedEnvs.length === 0) {
+      return this.getConfigErrorMessage();
+    }
+    const components = await this.getComponents();
+    if (!components.length) {
+      return _chalk().default.yellow('no components found');
+    }
+
+    // Group components by environment, filtering only configured envs
+    const componentsByEnv = this.groupComponentsByEnv(components, allowedEnvs);
+    const results = [];
+    for (const [envId, envComponents] of Object.entries(componentsByEnv)) {
+      const env = this.envs.getEnvDefinitionByStringId(envId);
+      if (!env) continue;
+      const scripts = this.getScriptsFromEnv(env);
+      if (!scripts) continue;
+      if (!scripts.has(scriptName)) {
+        throw new (_exceptions().ScriptNotFound)(scriptName, envId);
+      }
+      const handler = scripts.get(scriptName);
+      if (!handler) continue;
+      const title = _chalk().default.green(`\nRunning script "${scriptName}" for ${envComponents.length} component(s) with env ${envId}:`);
+      results.push(title);
+      const result = await this.executeScript(handler, envComponents);
+      results.push(result);
+    }
+    return results.join('\n');
+  }
+
+  /**
+   * List all available scripts from all environments
+   */
+  async listAllScripts() {
+    // Filter envs based on config
+    const allowedEnvs = this.config.envs || [];
+    if (allowedEnvs.length === 0) {
+      return this.getConfigErrorMessage();
+    }
+    const components = await this.getComponents();
+    if (!components.length) {
+      return _chalk().default.yellow('no components found');
+    }
+
+    // Group components by environment, filtering only configured envs
+    const componentsByEnv = this.groupComponentsByEnv(components, allowedEnvs);
+    const results = [];
+    let foundAnyScripts = false;
+    for (const [envId, envComponents] of Object.entries(componentsByEnv)) {
+      const env = this.envs.getEnvDefinitionByStringId(envId);
+      if (!env) continue;
+      const scripts = this.getScriptsFromEnv(env);
+      if (!scripts || scripts.isEmpty()) {
+        continue;
+      }
+      if (!foundAnyScripts) {
+        results.push(_chalk().default.green('Available scripts:\n'));
+        foundAnyScripts = true;
+      }
+      results.push(_chalk().default.cyan(`\nEnvironment: ${envId}`));
+      results.push(_chalk().default.gray(`  (used by ${envComponents.length} component(s))`));
+      const scriptsList = scripts.list();
+      scriptsList.forEach(scriptName => {
+        const handler = scripts.get(scriptName);
+        const handlerStr = typeof handler === 'function' ? _chalk().default.gray('[function]') : _chalk().default.white(handler);
+        results.push(`  ${_chalk().default.bold(scriptName)}: ${handlerStr}`);
+      });
+    }
+    if (!foundAnyScripts) {
+      return _chalk().default.yellow('no scripts defined in the configured environments');
+    }
+    return results.join('\n');
+  }
+
+  /**
+   * Check if an env is allowed to run scripts based on config
+   * Supports exact match with or without version
+   */
+  isEnvAllowed(envId, allowedEnvs) {
+    return allowedEnvs.some(allowedEnv => {
+      // Exact match (with version): "my-scope/my-env@1.0.0" === "my-scope/my-env@1.0.0"
+      if (envId === allowedEnv) return true;
+
+      // If config has no version, match env without version part
+      // Config: "my-scope/my-env" should match "my-scope/my-env@1.0.0"
+      if (!allowedEnv.includes('@') && envId.startsWith(allowedEnv + '@')) {
+        return true;
+      }
+      return false;
+    });
+  }
+  async getComponents() {
+    const host = this.componentAspect.getHost();
+    if (!host) throw new Error('workspace not found');
+    return host.list();
+  }
+  groupComponentsByEnv(components, allowedEnvs) {
+    const grouped = (0, _lodash().groupBy)(components, component => {
+      const env = this.envs.getOrCalculateEnv(component);
+      return env.id;
+    });
+
+    // If allowedEnvs is provided, filter out envs not in the list
+    if (allowedEnvs && allowedEnvs.length > 0) {
+      const filtered = {};
+      for (const [envId, envComponents] of Object.entries(grouped)) {
+        if (this.isEnvAllowed(envId, allowedEnvs)) {
+          filtered[envId] = envComponents;
+        }
+      }
+      return filtered;
+    }
+    return grouped;
+  }
+  getScriptsFromEnv(env) {
+    if (!env.env.getScripts) return undefined;
+    return env.env.getScripts();
+  }
+  async executeScript(handler, components) {
+    if (typeof handler === 'string') {
+      // Execute shell command
+      return this.executeShellCommand(handler);
+    }
+
+    // Execute function
+    return this.executeFunction(handler, components);
+  }
+  executeShellCommand(command) {
+    try {
+      const output = (0, _child_process().execSync)(command, {
+        cwd: this.workspace.path,
+        encoding: 'utf-8',
+        stdio: 'pipe'
+      });
+      return _chalk().default.white(output);
+    } catch (error) {
+      const errorMsg = error.stderr || error.message || 'unknown error';
+      return _chalk().default.red(`Error executing script: ${errorMsg}`);
+    }
+  }
+  async executeFunction(handler, components) {
+    try {
+      const context = {
+        components
+      };
+      await handler(context);
+      return _chalk().default.green('✓ Script function executed successfully');
+    } catch (error) {
+      return _chalk().default.red(`Error executing script function: ${error.message}`);
+    }
+  }
+  static async provider([cli, workspace, envs, componentAspect, loggerMain], config) {
+    const logger = loggerMain.createLogger(_scripts().ScriptsAspect.id);
+    const scriptsService = new (_scripts2().ScriptsService)();
+    const scriptsMain = new ScriptsMain(workspace, envs, logger, componentAspect, config);
+
+    // Register service with envs
+    envs.registerService(scriptsService);
+
+    // Register CLI command
+    const scriptCmd = new (_script().ScriptCmd)(scriptsMain);
+    cli.register(scriptCmd);
+    return scriptsMain;
+  }
+}
+exports.ScriptsMain = ScriptsMain;
+_defineProperty(ScriptsMain, "slots", []);
+_defineProperty(ScriptsMain, "dependencies", [_cli().CLIAspect, _workspace().WorkspaceAspect, _envs().EnvsAspect, _component().ComponentAspect, _logger().LoggerAspect]);
+_defineProperty(ScriptsMain, "runtime", _cli().MainRuntime);
+_scripts().ScriptsAspect.addRuntime(ScriptsMain);
+var _default = exports.default = ScriptsMain;
+
+//# sourceMappingURL=scripts.main.runtime.js.map