@garyr/pt-cli 0.32.0 → 0.33.0

package/doc/testing.md

@@ -8,18 +8,36 @@ The test suite uses Node.js's native test runner (`node:test`) and assertion lib
 
 ## Running Tests
 
+### 0. Security Testing
+
+Security features can be tested by:
+
+1. **Testing command blocks**: Try running templates with dangerous commands like `sudo rm -rf` or `dd`
+2. **Testing remote downloads**: Use untrusted URLs to verify source verification
+3. **Testing rate limiting**: Execute more than 50 commands in a single init session
+4. **Testing timeouts**: Run commands that hang to verify timeout behavior
+5. **Reviewing audit logs**: Check `~/.pt/security-audit.log` for security events
+
+For more details, see the [Security Guide](security.md).
+
 ### 1. Run the Entire Test Suite
+
 To execute all tests:
+
 ```bash
 npm test
 ```
+
 This runs the underlying command:
+
 ```bash
 node --import tsx --test tests/**/*.test.ts
 ```
 
 ### 2. Run Individual Test Files
+
 To run a specific test suite, use `tsx`:
+
 ```bash
 npx tsx --test tests/config.test.ts
 npx tsx --test tests/learn.test.ts
@@ -27,7 +45,9 @@ npx tsx --test tests/substitute.test.ts
 ```
 
 ### 3. Run with Test Coverage
+
 To generate a test coverage report directly in the terminal:
+
 ```bash
 node --experimental-test-coverage --import tsx --test tests/**/*.test.ts
 ```
@@ -42,7 +62,7 @@ When writing new tests, please adhere to these guidelines:
 2. **ESM Imports**: Since this is an ESM (ECMAScript Modules) project, file imports within tests must use the `.js` extension (e.g., `import { learn } from '../src/commands/learnCommand.js';`).
 3. **Environment Isolation**: The configuration path relies on `process.env.HOME`. To prevent tests from polluting your user config directory, override the home directory before importing any CLI files:
    ```typescript
-   const testHome = path.join(process.cwd(), '.test-home-custom');
+   const testHome = path.join(process.cwd(), ".test-home-custom");
    process.env.HOME = testHome;
    ```
 4. **Cleanup**: Always ensure temporary files, workspace directories, and test home directories are deleted after tests complete (e.g., in a `finally` block or `after` hook).

package/doc/usage.md

@@ -22,26 +22,24 @@ pt learn /path/to/PROJECT --name my_template --desc "My new template" --yes
 
 ### Remote Template Learning
 
-`pt learn` supports learning templates directly from a remote Git repository or tarball archive by passing an `http://` or `https://` URL:
+`pt learn` supports learning templates directly from a remote Git repository or tarball archive by passing an `http://` or `https://` URL. **Security is enforced**: only downloads from `trustedSources` (configured in `~/.pt/config.yaml`) are allowed by default. Untrusted sources trigger a warning and require explicit confirmation.
 
 ```bash
 # Learn a template directly from a GitHub repository
 pt learn https://github.com/username/my-template
-
-# Learn a template from a Gitea repository
-pt learn https://gitea.example.com/username/my-template
 ```
 
 #### How it works:
-1. **URL Translation:** If a GitHub or Gitea URL is provided, `pt` automatically translates the repository URL to its corresponding tarball download endpoint (e.g., `/archive/refs/heads/main.tar.gz`).
-2. **Download & Extraction:** The tool downloads the archive into a secure temporary folder and extracts it.
-3. **Template Discovery:** The extracted directory is scanned for metadata (`.pt-template.json`, `template.json`, `.info.md`, `post_config.sh`, `post_config.bat`) and variable placeholders (`{{ var }}`), matching local learn functionality exactly.
-4. **Save Config:** The template config (skeleton structure, files, variables) is saved to the local configuration, pointing to the temporary folder as the `templateRoot`.
 
+1. **URL Translation:** If a GitHub or Gitea URL is provided, `pt` automatically translates the repository URL to its corresponding tarball download endpoint (e.g., `/archive/refs/heads/main.tar.gz`).
+2. **Security Verification:** Downloads are restricted to trusted sources (configured in `~/.pt/config.yaml`). Untrusted sources trigger a warning and require explicit confirmation.
+3. **Download & Extraction:** The tool downloads the archive into a secure temporary folder and extracts it. File size is validated (max 50MB).
+4. **Template Discovery:** The extracted directory is scanned for metadata (`.pt-template.json`, `template.json`, `.info.md`, `post_config.sh`, `post_config.bat`) and variable placeholders (`{{ var }}`), matching local learn functionality exactly.
+5. **Save Config:** The template config (skeleton structure, files, variables) is saved to the local configuration, pointing to the temporary folder as the `templateRoot`.
 
 ### Automatic Variable Detection
 
-During `pt learn` or `pt update`, the tool automatically scans text files at the root and in the first-level subdirectories for variable placeholders using the `{{ variable_name }}` syntax. 
+During `pt learn` or `pt update`, the tool automatically scans text files at the root and in the first-level subdirectories for variable placeholders using the `{{ variable_name }}` syntax.
 
 - **Detection Range:** Root files and 1st-level subfolder files (e.g., `README.md`, `.makerc`, `DOC/closedown.md`).
 - **Registration:** Any detected variables are automatically added to the template's configuration with default prompts (e.g., `Enter variable_name:`).
@@ -141,7 +139,12 @@ The JSON template config file is the recommended way to make a template director
   "name": "my-web-app",
   "description": "A Node.js web application with Express",
   "variables": [
-    { "name": "project_name", "prompt": "Project name:", "default": "my-app", "required": true },
+    {
+      "name": "project_name",
+      "prompt": "Project name:",
+      "default": "my-app",
+      "required": true
+    },
     { "name": "author", "prompt": "Author name:", "default": "" }
   ],
   "folders": [
@@ -149,16 +152,18 @@ The JSON template config file is the recommended way to make a template director
     { "name": "tests", "children": [] }
   ],
   "copy_files": [
-    { "src": "package.json", "dest": "package.json", "substitute_variables": true },
+    {
+      "src": "package.json",
+      "dest": "package.json",
+      "substitute_variables": true
+    },
     { "src": "README.md", "dest": "README.md", "substitute_variables": true }
   ],
   "post_config": [
     { "command": "git init", "description": "Initialize git repository" },
     { "command": "npm install", "description": "Install dependencies" }
   ],
-  "post_copy": [
-    { "src": "bin/start.sh", "dest": "bin/start.sh" }
-  ]
+  "post_copy": [{ "src": "bin/start.sh", "dest": "bin/start.sh" }]
 }
 ```
 
@@ -189,30 +194,39 @@ pt init ./new-project --file .pt-template.json --yes
 For a more portable, text-based approach, you can export and import templates as JSON strings or files.
 
 #### Exporting a Template to JSON
+
 To export an existing template from your configuration as JSON:
+
 ```bash
 pt config <template_name> --json > my_template.json
 ```
 
 #### Importing a Template from JSON
+
 To add a template from a JSON file:
+
 ```bash
 pt add <template_name> --file my_template.json
 ```
 
 Or from a JSON string:
+
 ```bash
 pt add <template_name> '{"description":"My Template","files":{...}}'
 ```
 
 #### Direct JSON Scaffolding (no config registration)
+
 To scaffold a project directly from a JSON file without adding the template to your config:
+
 ```bash
 pt init ./destination --file my_template.json --yes
 ```
 
 #### Exporting Full Config
+
 To see your entire configuration (including all templates) in JSON format:
+
 ```bash
 pt config --json
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@garyr/pt-cli",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "Project Template CLI - Learn structures and initialize projects",
   "main": "dist/index.js",
   "bin": {
@@ -14,9 +14,9 @@
     "test": "node --import tsx --test tests/**/*.test.ts",
     "test:sequential": "node --import tsx --test tests/config.test.ts && node --import tsx --test tests/init.test.ts && node --import tsx --test tests/learn.test.ts && node --import tsx --test tests/substitute.test.ts && node --import tsx --test tests/config-utils.test.ts",
     "prepublishOnly": "npm run build",
-    "build:linux": "bun build ./src/index.ts --compile --target=bun-linux-x64   --outfile ../BUILD/pt-cli/pt-linux",
-    "build:macos": "bun build ./src/index.ts --compile --target=bun-darwin-x64  --outfile ../BUILD/pt-cli/pt-macos",
-    "build:windows": "bun build ./src/index.ts --compile --target=bun-windows-x64 --outfile ../BUILD/pt-cli/pt-win.exe",
+    "build:linux": "bun build ./src/index.ts --compile --minify --target=bun-linux-x64   --outfile ../BUILD/pt-cli/pt-linux",
+    "build:macos": "bun build ./src/index.ts --compile --minify --target=bun-darwin-x64  --outfile ../BUILD/pt-cli/pt-macos",
+    "build:windows": "bun build ./src/index.ts --compile --minify --target=bun-windows-x64 --outfile ../BUILD/pt-cli/pt-win.exe",
     "build:all": "npm run build:linux && npm run build:macos && npm run build:windows"
   },
   "license": "MIT",

package/skills/agency-pt-operator/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: agency-pt-operator
-description: Specialist in using pt-cli to scaffold project templates, capture boilerplate, and maintain standardized directory structures. Includes knowledge of default_post_config, global variables, and automatic variable detection.
+description: Specialist in using pt-cli to scaffold project templates, capture boilerplate, and maintain standardized directory structures. Includes knowledge of default_post_config, global variables, automatic variable detection, JSON template configs, and portable template workflows.
 ---
 
 # `pt-cli` Operator Skill
@@ -14,26 +14,30 @@ As an agent equipped with this skill, you have the ability to rapidly scaffold,
    - Run `pt config` to view available templates, their post-config tasks, and default post-config tasks.
 
 2. **Scaffolding (`pt init`):**
-   When a matching template exists, initialize it using the non-interactive flags.
+   When a matching template exists, initialize it using the non-interactive flags. URL targets (GitHub, Gitea, etc.) are automatically translated to tarball downloads.
    - **Command:** `pt init <template_name> <destination_path> --yes`
    - If the template requires variables, pass them: `pt init <template_name> <destination_path> --yes --vars key1=value1,key2=value2`
    - **Direct JSON scaffolding:** To scaffold from a JSON template file without registering it in `config.yaml`:
      `pt init <destination_path> --file <json_path> --yes`
    - *Never* run `pt init` without `--yes`, as interactive prompts will block you.
+   - **Dry-run:** Preview what would be created without making changes: `pt init <template_name> <destination_path> --yes --dry-run`
+   - **Skip post-config:** Skip running post-config tasks: `pt init <template_name> <destination_path> --yes --skip-post-config`
    - Note any errors from auto-executed post-config tasks (like `npm install` failing) and correct them if necessary.
 
 3. **Capturing Knowledge (`pt learn`):**
-   If you spend time establishing a new, complex directory structure or configuration (e.g., a specific flavor of an Express backend with testing hooks), save it!
+   If you spend time establishing a new, complex directory structure or configuration (e.g., a specific flavor of an Express backend with testing hooks), save it! Remote URLs (GitHub, Gitea, etc.) are automatically translated to tarball downloads.
    - **Command:** `pt learn <source_path> --name <template_name> --desc "<Description>" --yes`
-   - **Remote Templates:** You can also learn from a remote Git repository or archive URL directly! Pass the HTTP/HTTPS URL as the `<source_path>`:
+   - **Update existing template:** Update an existing template with new structure/files: `pt update <template_name> <source_path> --yes`
+   - **Remote Templates:** Learn from a remote Git repository or archive URL directly! Pass the HTTP/HTTPS URL as the `<source_path>`:
      `pt learn https://github.com/username/my-template --name my_template --desc "Description" --yes`
    - Explain to the user that you've captured this template for future use.
    - **Automatic Variable Detection:** `pt learn` and `pt update` automatically scan text files (at root and one level deep) for `{{ variable_name }}` placeholders. You can add these to files (e.g., `README.md`, `.makerc`) and run `pt update <template> . --yes` to have them registered as template variables without manual configuration.
-   - **JSON Template Config:** If the source directory contains a `.pt-template.json` or `template.json` file, `pt learn` will auto-detect name, description, variables, folders, copy_files, post_config, and post_copy from it — skipping the corresponding interactive prompts.
+   - **JSON Template Config:** If the source directory contains a `.pt-template.json` or `template.json` file, `pt learn` will auto-detect name, description, variables, folders, copy_files, post_config, and post_copy from it — skipping the corresponding interactive prompts. JSON config takes precedence over `.info.md` and shell scripts.
+   - **JSON Output:** Output template structure as JSON for sharing instead of saving: `pt learn <source_path> --json`
 
 4. **Template Maintenance (`pt rm`):**
    If a template is obsolete or requested for deletion, use `pt rm`.
-   - **Command:** `pt rm <template_name> --yes`
+   - **Command:** `pt rm <template_name> --yes` or `pt remove <template_name> --yes`
 
 ## Template Sharing & Portability
 
@@ -41,7 +45,7 @@ Templates are designed to be fully portable. There are two approaches to sharing
 
 ### 1. Directory-based Sharing (recommended for complete templates)
 
-Place a `.pt-template.json` at the root of your template directory. This file can include all template metadata:
+Place a `.pt-template.json` or `template.json` at the root of your template directory. This file can include all template metadata:
 
 ```json
 {
@@ -56,9 +60,9 @@ Place a `.pt-template.json` at the root of your template directory. This file ca
 }
 ```
 
-When someone runs `pt learn /path/to/shared-dir --yes`, all metadata is auto-detected from this file.
+When someone runs `pt learn /path/to/shared-dir --yes`, all metadata is auto-detected from this file. The priority order is: `.pt-template.json` > `template.json` > `.info.md` > `post_config.sh`/`.bat`.
 
-**Priority order:** `.pt-template.json` > `template.json` > `.info.md` > `post_config.sh`/`.bat`
+JSON config files also take precedence over shell scripts for post_config tasks.
 
 ### 2. JSON Export/Import (for config-only sharing)
 
@@ -75,11 +79,24 @@ pt init ./new-project --file my-template.json --yes
 
 ### Round-trip Workflow
 
-The complete portable template workflow:
-1. `pt config my-template --json > .pt-template.json` — export config
-2. Copy `.pt-template.json` into the template source directory
-3. Share the directory (zip, git repo, etc.)
-4. Recipient: `pt learn /path/to/shared-dir --yes` — auto-detects everything
+The complete portable template workflow, perfect for sharing:
+
+1. **Create template:** `pt init <template> <dest> --yes --skip-post-config` — creates structure without auto-executing post-config tasks (e.g., `git init`)
+2. **Export config:** `pt config <template> --json > <dest>/.pt-template.json` — exports portable JSON config, required to include variables
+3. **Share directory/JSON:** Share the directory or JSON file
+4. **Recipient:** `pt learn <path> --name <template> --yes` — imports the template
+5. **Or scaffold directly:** `pt init ./new-project --file .pt-template.json --yes`
+
+### JSON Output for Sharing
+
+You can output a template as JSON for sharing without saving it: `pt learn <source_path> --json`
+
+### Important Notes
+
+- **Never use manual `mkdir`/`cp` steps** — `pt init` already scaffolds directory structures, and manual file copying bypasses template registration
+- **`--skip-post-config` flag** prevents premature task execution during template creation
+- **JSON export captures all template metadata**, variables, and post-config tasks for maximum portability
+- The workflow ensures portability by bundling metadata and files together, allowing recipients to import via `pt learn` without manual directory manipulation
 
 ## Default Post-Config
 
@@ -101,7 +118,7 @@ Global variables are defined in `~/.pt/config.yaml` under `variables`. They act
 - **Purpose:** They ensure that common metadata fields (like `author`, `license`, `project_version`) are consistently offered for inclusion in every new template you create.
 - **Inheritance:** When you `learn` a new project structure, these global variables are automatically merged with any detected variables (`{{ var }}`) and offered as part of the new template's variable list.
 - **Localization:** Once a template is saved, its variables are "stamped" in. Subsequent changes to global variables in the config will **not** retroactively affect old templates, ensuring stability and portability.
-- **Management:** Use `pt variables --set key=value` to update your global defaults. For bulk updates, use `pt variables --set --json '...'`.
+- **Management:** Use `pt variables --set key=value` to update your global defaults. For bulk updates, use `pt variables --set --json '...'`. To delete a global variable, use `pt variables --delete key`.
 
 ## Workflow Optimization
 
@@ -109,3 +126,75 @@ Global variables are defined in `~/.pt/config.yaml` under `variables`. They act
 1. Identify the closest matching template (`pt config`).
 2. Scaffold it non-interactively (`pt init ... --yes`).
 3. Make the specific manual code/configuration changes requested by the user on top of that scaffolded base.
+4. If the scaffold is close but needs updates, use `pt update <template_name> . --yes` to update the saved template with your changes.
+
+## Additional Notes
+
+- JSON variables take precedence over other variable sources during `pt update`.
+- Optional whitespace is allowed around template variables in the substitute function.
+- Trailing `.git` is automatically stripped from repository URLs.
+- Atomic saves, backups, and safe initialization logic prevent data loss.
+- Platform-specific post-config scripts (`.sh`/`.bat`) are executed automatically based on the OS.
+
+## Security Configuration
+
+### Security Policy Settings
+
+Security settings are configured in `~/.pt/config.yaml` under the `security` key:
+
+```yaml
+security:
+  securityLevel: "warn"  # "warn" (default) or "strict"
+  trustedSources:
+    - "github.com/garyritchie"
+    - "git.lyonritchie.com"
+    - "github.com/lyonritchie"
+  maxExecutionTime: 30000  # 30 seconds per command
+  maxCommandsPerRun: 50    # rate limit per init session
+  enableAuditLogging: true # write events to security-audit.log
+```
+
+### Security Levels
+
+- **`warn`** (default): Warning-based approach with cancellation prompts
+- **`strict`**: More conservative defaults, enabled by default for new installations
+
+### Trusted Sources
+
+When downloading templates from remote URLs, `pt-cli` verifies the source against the `trustedSources` list. Untrusted sources trigger a warning and require explicit user confirmation before proceeding.
+
+### Command Security
+
+- **Absolute blocks**: Commands like `sudo`, `rm -rf`, `dd` are always blocked
+- **Dangerous commands**: Commands like `curl`, `python`, `chmod` trigger warnings
+- **Rate limiting**: 50 commands per run prevents runaway execution
+- **Execution timeout**: 30 seconds per command prevents hung processes
+
+### Audit Logging
+
+All security events are logged to `~/.pt/security-audit.log` for monitoring and troubleshooting.
+
+## Security Testing
+
+Security features can be tested by:
+
+1. **Testing command blocks**: Try running templates with dangerous commands like `sudo rm -rf` or `dd`
+2. **Testing remote downloads**: Use untrusted URLs to verify source verification
+3. **Testing rate limiting**: Execute more than 50 commands in a single init session
+4. **Testing timeouts**: Run commands that hang to verify timeout behavior
+5. **Reviewing audit logs**: Check `~/.pt/security-audit.log` for security events
+
+For more details, see the [Security Guide](security.md).
+
+## CLI Reference
+
+| Command | Description |
+|---------|-------------|
+| `pt learn <path>` | Learn a project structure from an existing directory |
+| `pt update <template> [path]` | Update an existing template with new structure/files |
+| `pt init [template] [dest]` | Initialize a new project from a learned template |
+| `pt config [template]` | Show current config location and list templates, or export a specific template |
+| `pt variables [pairs]` | View or set global variables (comma-separated key=value) |
+| `pt default-post-config` | View or set default post-config tasks |
+| `pt add <name> [json]` | Import/add a template from a JSON string or file |
+| `pt remove <template>` / `pt rm <template>` | Remove a learned template from the config |

package/src/commands/configCommand.ts

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { loadConfig, getTemplateNames, CONFIG_PATH } from '../config.js';
+import { loadConfig, getTemplateNames, getConfigPath } from '../config.js';
 
 export interface ConfigOptions {
   json?: boolean;
@@ -28,7 +28,7 @@ export function configCommand(templateName: string | undefined, options: ConfigO
   
   const names = getTemplateNames(config);
   
-  console.log(chalk.cyan('Config Location:'), CONFIG_PATH);
+  console.log(chalk.cyan('Config Location:'), getConfigPath());
   console.log(chalk.cyan('\nLearned Templates:'));
   if (names.length === 0) {
     console.log(chalk.gray('  (none)'));

package/src/config.ts

@@ -3,9 +3,15 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import chalk from 'chalk';
+import { SecurityPolicy } from './safety.js';
 
-export const HOME_DIR = path.join(os.homedir(), '.pt');
-export const CONFIG_PATH = path.join(HOME_DIR, 'config.yaml');
+export function getHomeDir(): string {
+  return path.join(os.homedir(), '.pt');
+}
+
+export function getConfigPath(): string {
+  return path.join(getHomeDir(), 'config.yaml');
+}
 
 export interface FolderNode {
   name: string;
@@ -60,17 +66,18 @@ export interface PtConfig {
   ignore?: string[];  // top-level folder ignore patterns for pt learn
   default_post_config?: PostConfigTask[];  // default post-config tasks applied to all projects
   variables?: TemplateVariable[];         // global variables for substitution
+  security?: SecurityPolicy;  // security policy configuration
 }
 
 export function ensureConfigDir() {
-  if (!fs.existsSync(HOME_DIR)) {
-    fs.mkdirSync(HOME_DIR, { recursive: true });
+  if (!fs.existsSync(getHomeDir())) {
+    fs.mkdirSync(getHomeDir(), { recursive: true });
   }
 }
 
 export function loadConfig(): PtConfig {
   ensureConfigDir();
-  if (!fs.existsSync(CONFIG_PATH)) {
+  if (!fs.existsSync(getConfigPath())) {
     const defaultConfig: PtConfig = {
       version: '3.0',
       templates: {},
@@ -84,7 +91,7 @@ export function loadConfig(): PtConfig {
   }
 
   try {
-    const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+    const content = fs.readFileSync(getConfigPath(), 'utf-8');
     if (!content.trim()) {
       throw new Error("Config file is empty");
     }
@@ -142,7 +149,7 @@ export function loadConfig(): PtConfig {
     const error = err as Error;
     console.error(chalk.red(`\nError loading config: ${error.message}`));
     // If we have a backup, maybe suggest using it
-    const backupPath = CONFIG_PATH + '.bak';
+    const backupPath = getConfigPath() + '.bak';
     if (fs.existsSync(backupPath)) {
       console.error(chalk.yellow(`A backup exists at ${backupPath}. You may want to restore it.`));
     }
@@ -175,20 +182,20 @@ export function saveConfig(config: PtConfig) {
   }
 
   const content = YAML.stringify(config);
-  const tempPath = CONFIG_PATH + '.tmp';
-  const backupPath = CONFIG_PATH + '.bak';
+  const tempPath = getConfigPath() + '.tmp';
+  const backupPath = getConfigPath() + '.bak';
 
   try {
     // 1. Create a backup of the current valid config if it exists
-    if (fs.existsSync(CONFIG_PATH)) {
-      fs.copyFileSync(CONFIG_PATH, backupPath);
+    if (fs.existsSync(getConfigPath())) {
+      fs.copyFileSync(getConfigPath(), backupPath);
     }
 
     // 2. Write to a temporary file first (atomic save)
     fs.writeFileSync(tempPath, content);
 
     // 3. Rename temp file to actual config path
-    fs.renameSync(tempPath, CONFIG_PATH);
+    fs.renameSync(tempPath, getConfigPath());
   } catch (err) {
     const error = err as Error;
     console.error(chalk.red(`\nFailed to save config: ${error.message}`));
@@ -216,6 +223,25 @@ export function getDefaultPostConfig(config: PtConfig): PostConfigTask[] {
   }));
 }
 
+/**
+ * Get security policy from config or use defaults
+ */
+export function getSecurityPolicy(config: PtConfig): SecurityPolicy {
+  const defaultPolicy: SecurityPolicy = {
+    maxExecutionTime: 30000, // 30 seconds
+    enableAuditLogging: true,
+    trustedSources: [
+      'github.com/garyritchie',
+      'gitea.lyonritchie.com/garyritchie',
+      'github.com/lyonritchie',
+    ],
+    maxCommandsPerRun: 50,
+    securityLevel: 'warn',
+  };
+
+  return config.security || defaultPolicy;
+}
+
 // Default exclusions for template scanning
 export const DEFAULT_EXCLUDES = [
   '.git',

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,36 @@ 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): 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
+    if (!isTrustedSource(url, securityPolicy.trustedSources)) {
+        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');
+        }
+    }
+
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pt-template-'));
     let downloadUrl = url;
 
@@ -27,10 +55,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;
 }