@orxataguy/tyr 1.0.27 → 1.0.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"

package/src/core/sys/config.ts

@@ -59,6 +59,33 @@ function detectShellRcFile(homeDir: string): string | null {
     return fallbacks.find(p => existsSync(p)) ?? path.join(homeDir, '.bashrc');
 }
 
+function getWindowsProfilePaths(): string[] {
+    const userProfile = process.env.USERPROFILE;
+    if (!userProfile) return [];
+    return [
+        path.join(userProfile, 'Documents', 'WindowsPowerShell', 'Microsoft.PowerShell_profile.ps1'),
+        path.join(userProfile, 'Documents', 'PowerShell', 'Microsoft.PowerShell_profile.ps1'),
+    ];
+}
+
+async function checkWindowsExecutionPolicy(shell: any, logger: any): Promise<void> {
+    try {
+        const output: string = await shell.exec(
+            'powershell -NoProfile -Command "Get-ExecutionPolicy -Scope CurrentUser"',
+        );
+        const policy = String(output).trim();
+
+        if (policy === 'Restricted' || policy === 'AllSigned' || policy === 'Undefined') {
+            logger.warn(`\nCurrent Execution Policy: ${policy || 'Undefined'}`);
+            logger.warn('With this policy, PowerShell may block loading your profile (and therefore Tyr functions/aliases).');
+            logger.info('To allow it, run in a PowerShell console:');
+            logger.info('  Set-ExecutionPolicy RemoteSigned -Scope CurrentUser');
+        }
+    } catch {
+        logger.warn('Could not check PowerShell Execution Policy. Verify it manually if commands do not load.');
+    }
+}
+
 const PACKAGE_JSON_TEMPLATE = `{
   "name": "tyr-commands",
   "version": "1.0.0",
@@ -149,23 +176,30 @@ async function configureUnixShell(tyrFs: any, logger: any, homeDir: string, alia
     }
     await tyrFs.ensureLine(rcFile, `source "${aliasesPath}"`);
     await tyrFs.ensureLine(rcFile, `source "${pluginsPath}"`);
-    logger.success(`Shell configurado: ${rcFile}`);
-    logger.info(`Ejecuta: source ${rcFile}  (o abre una nueva terminal)`);
+    logger.success(`Shell configured: ${rcFile}`);
+    logger.info(`Run: source ${rcFile}  (or open a new terminal)`);
 }
 
-async function configureWindowsShell(tyrFs: any, logger: any, aliasesPath: string, pluginsPath: string): Promise<void> {
-    const psProfile = process.env.USERPROFILE
-        ? path.join(process.env.USERPROFILE, 'Documents', 'PowerShell', 'Microsoft.PowerShell_profile.ps1')
-        : null;
-    if (!psProfile) {
-        logger.warn('Could not detect PowerShell profile.');
+async function configureWindowsShell(tyrFs: any, logger: any, shell: any, aliasesPath: string, pluginsPath: string): Promise<void> {
+    const profiles = getWindowsProfilePaths();
+
+    if (profiles.length === 0) {
+        logger.warn('Could not detect PowerShell profile (USERPROFILE is not defined).');
         logger.info(`Add manually:\n  . "${aliasesPath}"\n  . "${pluginsPath}"`);
         return;
     }
-    await tyrFs.ensureLine(psProfile, `. "${aliasesPath}"`);
-    await tyrFs.ensureLine(psProfile, `. "${pluginsPath}"`);
-    logger.success(`PowerShell profile configured: ${psProfile}`);
-    logger.info('Restart PowerShell to apply the changes.');
+
+    for (const psProfile of profiles) {
+        await tyrFs.createDir(path.dirname(psProfile));
+
+        await tyrFs.ensureLine(psProfile, `. "${aliasesPath}"`);
+        await tyrFs.ensureLine(psProfile, `. "${pluginsPath}"`);
+        logger.success(`PowerShell profile configured: ${psProfile}`);
+    }
+
+    logger.info('Restart PowerShell (or open a new console) to apply the changes.');
+
+    await checkWindowsExecutionPolicy(shell, logger);
 }
 
 export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrContext) {
@@ -288,21 +322,19 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
             }
         }
 
-        // Garantizar package.json + tsconfig.json + npm install siempre,
-        // tanto en init fresh como al clonar un repo existente.
         const packageJsonPath = path.join(userRoot, 'package.json');
         const tsconfigPath    = path.join(userRoot, 'tsconfig.json');
         let needsInstall = false;
 
         if (!tyrFs.exists(packageJsonPath)) {
             await tyrFs.write(packageJsonPath, PACKAGE_JSON_TEMPLATE);
-            logger.success(`Archivo creado: ${packageJsonPath}`);
+            logger.success(`File created: ${packageJsonPath}`);
             needsInstall = true;
         }
 
         if (!tyrFs.exists(tsconfigPath)) {
             await tyrFs.write(tsconfigPath, TSCONFIG_TEMPLATE);
-            logger.success(`Archivo creado: ${tsconfigPath}`);
+            logger.success(`File created: ${tsconfigPath}`);
             needsInstall = true;
         }
 
@@ -321,9 +353,9 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
         const pluginsPath = path.join(userRoot, `plugins${ext}`);
 
         if (tyrFs.exists(aliasesPath) || tyrFs.exists(pluginsPath)) {
-            logger.info('\nConfigurando shell...');
+            logger.info('\nConfiguring shell...');
             if (isWindows) {
-                await configureWindowsShell(tyrFs, logger, aliasesPath, pluginsPath);
+                await configureWindowsShell(tyrFs, logger, shell, aliasesPath, pluginsPath);
             } else {
                 await configureUnixShell(tyrFs, logger, homeDir, aliasesPath, pluginsPath);
             }