@garyr/pt-cli 0.32.1 → 0.36.4

package/src/index.ts

@@ -14,6 +14,7 @@ import { variablesCommand } from './commands/variablesCommand.js';
 import { addCommand } from './commands/addCommand.js';
 import { removeCommand } from './commands/removeCommand.js';
 import { defaultPostConfigCommand } from './commands/defaultPostConfigCommand.js';
+import { securityResponseCommand } from './commands/securityResponseCommand.js';
 
 import pkg from '../package.json' with { type: 'json' };
 
@@ -32,8 +33,21 @@ program
   .option('--name <name>', 'Template name (skip prompt)')
   .option('--desc <description>', 'Template description (skip prompt)')
   .option('--json', 'Output template structure as JSON for sharing instead of saving')
+  .option('--allow-untrusted', 'Bypass the trusted-source check for remote URLs (set by GUI after user confirmation)')
   .action(async (pathArg: string | undefined, options) => {
-    await learn(pathArg || '.', null, options);
+    try {
+      await learn(pathArg || '.', null, options);
+    } catch (err: any) {
+      if (options.json) {
+        console.log(JSON.stringify({
+          type: 'error',
+          message: err.message || String(err)
+        }));
+      } else {
+        console.error(chalk.red(`Error: ${err.message || err}`));
+      }
+      process.exit(1);
+    }
   });
 
 program
@@ -43,7 +57,12 @@ program
   .option('-y, --yes', 'Automatically confirm prompts')
   .option('--desc <description>', 'Template description (skip prompt)')
   .action(async (templateName: string, sourcePath: string | undefined, options) => {
-    await learn(sourcePath || '.', templateName, options);
+    try {
+      await learn(sourcePath || '.', templateName, options);
+    } catch (err: any) {
+      console.error(chalk.red(`Error: ${err.message || err}`));
+      process.exit(1);
+    }
   });
 
 program
@@ -98,4 +117,11 @@ program
   .option('-y, --yes', 'Automatically confirm removal')
   .action(removeCommand);
 
+program
+  .command('security-response <response>')
+  .description('Handle security response from GUI')
+  .action(async (response: string) => {
+    await securityResponseCommand(response);
+  });
+
 program.parse(process.argv);

package/src/postconfig.ts

@@ -1,9 +1,19 @@
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
 import { execSync } from 'child_process';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { PostConfigTask } from './config.js';
+import {
+  isBlockedCommand,
+  isDangerousCommand,
+  executeWithTimeout,
+  logSecurityEvent,
+  canExecute,
+  showDangerousCommandWarning,
+  getSecurityPolicy,
+} from './safety.js';
 
 export interface PostConfigOptions {
   skipPostConfig?: boolean;
@@ -22,6 +32,16 @@ export async function runPostConfig(
 ): Promise<void> {
   if (options.skipPostConfig) return;
 
+  // Load security policy
+  const configPath = path.join(process.env.HOME || os.homedir(), '.pt', 'config.yaml');
+  const securityPolicy = getSecurityPolicy(configPath);
+
+  // Check rate limiting
+  if (!canExecute('init', securityPolicy.maxCommandsPerRun)) {
+    console.log(chalk.yellow('⚠️  Rate limit reached: max commands per run exceeded'));
+    return;
+  }
+
   // 1. Filter tasks by type
   const applicableTasks = tasks.filter(t => !t.type || t.type === projectType);
 
@@ -54,18 +74,59 @@ export async function runPostConfig(
     const progress = `[${i + 1}/${applicableTasks.length}]`;
 
     if (task.command) {
+      // SECURITY CHECK 1: Blocklist check (NEVER allow these)
+      if (isBlockedCommand(task.command)) {
+        console.log(chalk.red(`${progress} ⚠️  BLOCKED: ${task.command}`));
+        logSecurityEvent('command_blocked', task.command, projectType, 'blocked');
+        continue;
+      }
+
+      // SECURITY CHECK 2: Dangerous command warning (but allow execution)
+      if (isDangerousCommand(task.command)) {
+        console.log(chalk.yellow(`${progress} ⚠️  WARNING: This command may be dangerous: ${task.command}`));
+        console.log(chalk.yellow(`   Press CTRL+C to cancel, or wait 5s to continue...`));
+        
+        // Wait for user to cancel or timeout
+        const allowContinue = await showDangerousCommandWarning(task.command, 5);
+        if (!allowContinue) {
+          console.log(chalk.yellow(`${progress} ⊘ Command cancelled by user`));
+          logSecurityEvent('command_blocked', task.command, projectType, 'blocked');
+          continue;
+        }
+      }
+
+      // SECURITY CHECK 3: Rate limiting
+      if (!canExecute(task.command, securityPolicy.maxCommandsPerRun)) {
+        console.log(chalk.red(`${progress} ⚠️  Rate limited: too many commands executed`));
+        continue;
+      }
+
       if (options.dryRun) {
         console.log(chalk.gray(`  [DRY RUN] Would run: ${task.command}`));
       } else {
         try {
           console.log(chalk.yellow(`\n${progress} Running: ${task.command}`));
-          execSync(task.command, {
-            cwd: destPath,
-            stdio: 'inherit'
-          });
-          console.log(chalk.green('  ✓ Command completed successfully'));
+          
+          // SECURITY CHECK 4: Execution timeout
+          const result = await executeWithTimeout(
+            task.command,
+            destPath,
+            securityPolicy.maxExecutionTime
+          );
+
+          if (result.timedOut) {
+            console.log(chalk.red(`  ✗ Command timed out after ${securityPolicy.maxExecutionTime / 1000}s`));
+            logSecurityEvent('command_timed_out', task.command, projectType, 'timedout');
+          } else if (result.success) {
+            console.log(chalk.green('  ✓ Command completed successfully'));
+            logSecurityEvent('command_executed', task.command, projectType, 'success');
+          } else {
+            console.log(chalk.red(`  ✗ Command failed: ${result.stderr}`));
+            logSecurityEvent('command_executed', task.command, projectType, 'failed');
+          }
         } catch (err) {
           console.log(chalk.red('  ✗ Command failed'));
+          logSecurityEvent('command_executed', task.command, projectType, 'failed');
         }
       }
     }

package/src/remote.ts

@@ -5,8 +5,51 @@ import os from 'os';
 import { Readable } from 'stream';
 import { finished } from 'stream/promises';
 import { extract } from 'tar'; // You'll need: npm install tar
+import chalk from 'chalk';
+import { isTrustedSource, logSecurityEvent, getSecurityPolicy } from './safety.js';
+import { loadConfig } from './config.js';
+
+export async function downloadAndExtract(url: string, isJsonMode: boolean = false, allowUntrusted: boolean = false): Promise<string> {
+    // Load security policy
+    const configPath = path.join(process.env.HOME || os.homedir(), '.pt', 'config.yaml');
+    const config = loadConfig();
+    const securityPolicy = config.security || {
+        trustedSources: ['github.com/garyritchie', 'gitea.lyonritchie.com/garyritchie', 'github.com/lyonritchie'],
+    };
+
+    // SECURITY CHECK: Verify source is trusted (skipped when --allow-untrusted is passed)
+    if (!allowUntrusted && !isTrustedSource(url, securityPolicy.trustedSources)) {
+        if (isJsonMode) {
+            // In JSON mode, output warning as JSON for GUI consumption.
+            // The GUI will show a confirmation dialog and, if the user says YES,
+            // re-run `pt learn <url> --json --yes --allow-untrusted`.
+            console.log(JSON.stringify({
+                type: 'security_warning',
+                url: url,
+                message: `Template from untrusted source: ${url}`,
+                warning: 'Only use templates from trusted sources.',
+                prompt: 'Continue anyway?',
+                default: false
+            }));
+            process.exit(1);
+        } else {
+            console.log(chalk.yellow(`⚠️  Warning: Template from untrusted source: ${url}`));
+            console.log(chalk.yellow('   Only use templates from trusted sources'));
+            
+            const inquirer = (await import('inquirer')).default;
+            const response = await inquirer.prompt({
+                type: 'confirm',
+                name: 'proceed',
+                message: chalk.red('Continue anyway?'),
+                default: false
+            });
+            
+            if (!response.proceed) {
+                throw new Error('Download cancelled by user due to untrusted source');
+            }
+        }
+    }
 
-export async function downloadAndExtract(url: string): Promise<string> {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pt-template-'));
     let downloadUrl = url;
 
@@ -27,10 +70,21 @@ export async function downloadAndExtract(url: string): Promise<string> {
     const fileStream = fs.createWriteStream(dest);
     await finished(Readable.fromWeb(response.body as any).pipe(fileStream));
 
+    // SECURITY: Validate downloaded file before extraction
+    const stats = fs.statSync(dest);
+    if (stats.size > 50 * 1024 * 1024) { // 50MB limit
+        throw new Error('Downloaded template is too large (>50MB)');
+    }
+
     // Extract tarball
     await extract({ file: dest, cwd: tempDir });
     
     // Find the actual content folder (archives usually wrap content in a folder)
     const dirs = fs.readdirSync(tempDir).filter(f => fs.statSync(path.join(tempDir, f)).isDirectory());
-    return path.join(tempDir, dirs[0]); 
+    const extractedPath = path.join(tempDir, dirs[0]);
+    
+    // SECURITY: Log successful download
+    logSecurityEvent('template_loaded', downloadUrl, 'remote', 'success');
+    
+    return extractedPath;
 }

package/src/safety.ts

@@ -0,0 +1,331 @@
+// pt-cli/src/safety.ts
+// Security warnings and safeguards for post_config command execution
+import crypto from 'crypto';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+// === BLOCKLIST ===
+// Commands that are NEVER allowed (safety-critical operations)
+const BLOCKED_COMMANDS = [
+  // Privilege escalation
+  'sudo', 'su', 'su -', 'su root',
+  // Disk operations that could destroy data
+  'dd', 'mkfs', 'fdisk', 'mount', 'umount',
+  // Shell injection patterns - removed from blocklist to allow command chaining.
+  // These are validated as warnings instead.
+  // Dangerous chmod
+  'chmod 777', 'chmod -R 777', 'chmod 666',
+  // System commands that could kill processes
+  'kill', 'killall', 'pkill', 'fuser',
+  // Network operations that could exfiltrate data
+  'nc', 'netcat', 'socat',
+  // Package manager with dangerous flags
+  'apt purge', 'apt remove', 'yum remove', 'brew uninstall',
+];
+
+// === DANGEROUS PATTERNS ===
+// Commands that should trigger a warning but are NOT blocked
+const DANGEROUS_PATTERNS = [
+  // Remote downloads + execution
+  'curl', 'wget', 'wget -O', 'curl |', 'wget |',
+  // Script execution
+  'bash', 'sh', 'python', 'python3', 'node -e', 'node -p',
+  // Shell operations
+  'eval', 'exec', 'source',
+  // File system manipulation
+  'chmod -R', 'chown -R', 'chgrp -R',
+  // PowerShell (Windows)
+  'powershell', 'pwsh', 'Invoke-Expression', 'IEX',
+  // macOS-specific
+  'diskutil', 'hdiutil', 'csrutil',
+];
+
+// === DEFAULT CONFIGURATION ===
+export interface SecurityPolicy {
+  maxExecutionTime: number; // milliseconds
+  enableAuditLogging: boolean;
+  trustedSources: string[];
+  maxCommandsPerRun: number;
+  securityLevel: 'warn' | 'strict';
+}
+
+// Default security policy - warning focused
+const DEFAULT_SECURITY_POLICY: SecurityPolicy = {
+  maxExecutionTime: 30000, // 30 seconds
+  enableAuditLogging: true,
+  trustedSources: [
+    'github.com/garyritchie',
+    'git.lyonritchie.com',
+    'github.com/lyonritchie',
+  ],
+  maxCommandsPerRun: 50,
+  securityLevel: 'warn', // Warning-focused mode
+};
+
+/**
+ * Check if a command is in the blocklist (NEVER allowed)
+ * Only truly dangerous operations that could destroy data
+ */
+export function isBlockedCommand(command: string): boolean {
+  for (const blocked of BLOCKED_COMMANDS) {
+    if (command.includes(blocked)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a command should trigger a warning (but is allowed)
+ */
+export function isDangerousCommand(command: string): boolean {
+  // Check for destructive file operations targeting absolute paths
+  // Regex matches 'rm', 'rmdir', or Windows 'del' followed by optional flags and then an absolute path.
+  // Absolute path matches:
+  // - Unix: starting with '/' (e.g. /tmp, /usr)
+  // - Windows: starting with drive letter (e.g. C:\) or UNC path (\\) or drive-relative '\'
+  const parts = command.split(/\s+/);
+  const rmIndex = parts.findIndex(p => p === 'rm' || p === 'rmdir' || p === 'del');
+  if (rmIndex !== -1) {
+    // Check subsequent arguments
+    for (let i = rmIndex + 1; i < parts.length; i++) {
+      const arg = parts[i];
+      if (!arg) continue;
+      // Skip flags (starting with - or /flag on Windows)
+      if (arg.startsWith('-') || (process.platform === 'win32' && arg.startsWith('/'))) {
+        continue;
+      }
+      // Check absolute path patterns
+      const isAbsolute = arg.startsWith('/') || 
+                         (process.platform === 'win32' && (/^[a-zA-Z]:\\/.test(arg) || arg.startsWith('\\\\') || arg.startsWith('\\')));
+      if (isAbsolute) {
+        return true;
+      }
+    }
+  }
+
+  for (const pattern of DANGEROUS_PATTERNS) {
+    if (command.includes(pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Execute a command with timeout and error handling
+ */
+export async function executeWithTimeout(
+  command: string,
+  cwd: string,
+  timeoutMs: number = 30000
+): Promise<{ success: boolean; stdout?: string; stderr?: string; timedOut?: boolean }> {
+  const { execSync } = await import('child_process');
+
+  try {
+    const output = execSync(command, {
+      cwd,
+      stdio: 'pipe',
+      timeout: timeoutMs,
+      encoding: 'utf-8',
+    });
+    return { success: true, stdout: output };
+  } catch (err: any) {
+    if (err.code === 'ETIMEDOUT') {
+      return { success: false, timedOut: true };
+    }
+    return {
+      success: false,
+      stderr: err.stderr || err.message,
+    };
+  }
+}
+
+/**
+ * Log a security event to audit log
+ */
+export function logSecurityEvent(
+  eventType: 'command_executed' | 'command_blocked' | 'command_timed_out' | 'template_loaded',
+  command: string,
+  templateName: string,
+  result: 'success' | 'failed' | 'timedout' | 'blocked'
+): void {
+  const logEntry = {
+    timestamp: new Date().toISOString(),
+    eventType,
+    command,
+    template: templateName,
+    user: os.userInfo().username,
+    result,
+    hostname: os.hostname(),
+  };
+
+  const logDir = path.join(os.homedir(), '.pt');
+  const logFile = path.join(logDir, 'security-audit.log');
+
+  try {
+    // Ensure log directory exists
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    // Append to audit log
+    fs.appendFileSync(logFile, JSON.stringify(logEntry) + '\n');
+  } catch (err) {
+    // Silently fail if logging fails
+    console.warn('Warning: Failed to write security audit log');
+  }
+}
+
+/**
+ * Check if a URL is from a trusted source
+ */
+export function isTrustedSource(url: string, trustedSources: string[] = DEFAULT_SECURITY_POLICY.trustedSources): boolean {
+  return trustedSources.some(source => url.includes(source));
+}
+
+/**
+ * Rate limiting: track the last execution timestamp per command hash
+ */
+const lastExecutionTimes = new Map<string, number>();
+const RATE_LIMIT_MS = 1000; // 1 second between identical commands
+
+export function canExecute(command: string, maxCommandsPerRun: number = 50): boolean {
+  // Check total commands executed this run
+  const totalExecuted = lastExecutionTimes.size;
+  if (totalExecuted >= maxCommandsPerRun) {
+    return false;
+  }
+
+  // Check rate limit for this specific command
+  const hash = crypto.createHash('md5').update(command).digest('hex');
+  const lastTime = lastExecutionTimes.get(hash) || 0;
+  if (Date.now() - lastTime < RATE_LIMIT_MS) {
+    return false;
+  }
+
+  // Record execution timestamp
+  lastExecutionTimes.set(hash, Date.now());
+  return true;
+}
+
+/**
+ * Reset execution timestamps (for testing or between runs)
+ */
+export function resetExecutionCounts(): void {
+  lastExecutionTimes.clear();
+}
+
+/**
+ * Validate a template's security before execution
+ */
+export function validateTemplateSecurity(
+  templateConfig: any,
+  securityPolicy: SecurityPolicy = DEFAULT_SECURITY_POLICY
+): { valid: boolean; errors: string[]; warnings: string[] } {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  // Check post_config tasks
+  const postConfigTasks = templateConfig.post_config || [];
+  for (const task of postConfigTasks) {
+    const command = task.command;
+    if (!command) continue;
+
+    // Check for blocked commands
+    if (isBlockedCommand(command)) {
+      errors.push(`Blocked command in template: ${command}`);
+    }
+
+    // Warn about dangerous commands
+    if (isDangerousCommand(command)) {
+      warnings.push(`Dangerous command in template: ${command}`);
+    }
+
+    // Check for shell injection patterns
+    if (command.includes(';') || command.includes('|') || command.includes('&')) {
+      warnings.push(`Shell injection pattern in command: ${command}`);
+    }
+
+    // Check for remote downloads
+    if (command.includes('curl') || command.includes('wget')) {
+      warnings.push(`Remote download in command: ${command}`);
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+/**
+ * Get security policy from config or use defaults
+ */
+export function getSecurityPolicy(configPath?: string): SecurityPolicy {
+  // Try to load from config
+  if (configPath) {
+    try {
+      const YAML = require('yaml');
+      const config = YAML.parse(fs.readFileSync(configPath, 'utf-8'));
+      if (config.security) {
+        return { ...DEFAULT_SECURITY_POLICY, ...config.security };
+      }
+    } catch (err) {
+      // Fall back to defaults
+    }
+  }
+
+  return DEFAULT_SECURITY_POLICY;
+}
+
+/**
+ * Show warning about dangerous command and wait for user to cancel.
+ * Resolves true after the timeout (continue), or false immediately on CTRL+C (cancel).
+ */
+export async function showDangerousCommandWarning(command: string, timeoutSeconds: number = 5): Promise<boolean> {
+  const readline = await import('readline');
+
+  console.log(chalk.red('\n⚠️  DANGEROUS COMMAND DETECTED'));
+  console.log(chalk.red(`   Command: ${command}`));
+  console.log(chalk.red('   This could potentially harm your system.'));
+  console.log(chalk.yellow(`   Press CTRL+C to cancel, or wait ${timeoutSeconds}s to continue...`));
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      rl.close();
+      resolve(true);
+    }, timeoutSeconds * 1000);
+
+    rl.on('SIGINT', () => {
+      clearTimeout(timer);
+      rl.close();
+      console.log(chalk.yellow('\n⚠️  Command cancelled by user'));
+      resolve(false);
+    });
+  });
+}
+
+// Security response handling for GUI integration
+export async function handleSecurityResponse(response: string): Promise<boolean> {
+  // Normalize response
+  const normalized = response.trim().toLowerCase();
+  
+  // Accept 'y' or 'yes' as positive response
+  if (normalized === 'y' || normalized === 'yes') {
+    console.log('Security response: ALLOWED');
+    return true;
+  }
+  
+  // Reject any other response
+  console.log('Security response: DENIED');
+  return false;
+}

package/src/substitute.ts

@@ -44,14 +44,26 @@ export async function processCopyFiles(
       if (dryRun) {
         console.log(chalk.gray(`  [DRY RUN] Would recursively copy directory ${copyFile.src} → ${copyFile.dest}`));
       } else {
-        copyDirRecursive(srcPath, destPath, variables, copyFile.substitute_variables || false, copyFile.chmod);
+        const dirSubstitute = !!(copyFile.substitute_variables === true || (
+          copyFile.substitute_variables === undefined &&
+          template.variables &&
+          template.variables.length > 0 &&
+          Object.keys(variables).length > 0
+        ));
+        copyDirRecursive(srcPath, destPath, variables, dirSubstitute, copyFile.chmod);
       }
       console.log(chalk.green(`  ✓ ${copyFile.dest} (recursive)`));
     } else {
       // Single file copy
       if (dryRun) {
         console.log(chalk.gray(`  [DRY RUN] Would copy ${copyFile.src} → ${copyFile.dest}`));
-        if (copyFile.substitute_variables) {
+        const drySubstitute = !!(copyFile.substitute_variables === true || (
+          copyFile.substitute_variables === undefined &&
+          template.variables &&
+          template.variables.length > 0 &&
+          Object.keys(variables).length > 0
+        ));
+        if (drySubstitute) {
           console.log(chalk.gray(`  [DRY RUN] Would substitute variables in ${copyFile.dest}`));
         }
         if (copyFile.chmod) {
@@ -64,7 +76,15 @@ export async function processCopyFiles(
       fs.mkdirSync(path.dirname(destPath), { recursive: true });
 
       let content = fs.readFileSync(srcPath, 'utf-8');
-      if (copyFile.substitute_variables) {
+      // Default to substituting if substitute_variables is true, OR if it's undefined AND the template defines variables.
+      // If substitute_variables is explicitly false, do not substitute.
+      const shouldSubstitute = !!(copyFile.substitute_variables === true || (
+        copyFile.substitute_variables === undefined &&
+        template.variables &&
+        template.variables.length > 0 &&
+        Object.keys(variables).length > 0
+      ));
+      if (shouldSubstitute) {
         content = substituteVariables(content, variables);
       }
 

package/test-direct-template.json

@@ -1,24 +0,0 @@
-{
-  "name": "direct-json-test",
-  "description": "A mock template for direct JSON scaffolding test",
-  "folders": [
-    {
-      "name": "src",
-      "info": "contains sources",
-      "children": [
-        {
-          "name": "components",
-          "info": "reusable components"
-        },
-        {
-          "name": "utils",
-          "info": "utility functions"
-        }
-      ]
-    },
-    {
-      "name": "docs",
-      "info": "documentation folder"
-    }
-  ]
-}