@miraj181/ipingyou 2.0.13 → 2.1.0

package/README.md

@@ -22,6 +22,11 @@ No firewalls to configure. No port forwarding. No plaintext leakage.
 * 📡 **Hardware Telemetry Verification**: Clients silently generate hardware footprint reports (OS, RAM, CPU, IP), encrypt them locally with the session password, and send them to the Host for authorization.
 * 🚨 **Panic Kill-Switch**: Type `ipingyou panic` to instantly vaporize all associated keys, wipe all alias configs, and send a `SIGKILL` to every active tunnel and SSH shell.
 * 👻 **Daemonization**: Run `ipingyou service install` to quietly install and run the Host listener in the background (survives system reboots using PM2).
+* 🧭 **Approval Gate**: Require the Host to explicitly approve clients before they receive tunnel/key material.
+* 📦 **One-Time File Share**: Serve a single file/folder over SCP and revoke after use.
+* 🌐 **HTTP & TCP Exposure**: Share a local web app or any TCP service (DB/RDP/VNC) beyond SSH.
+* 📂 **Shared Drop Folder**: Auto-prepared dropbox folder for safe file transfers (macOS friendly).
+* 🧾 **Live Session Logs**: Host/client/broker write ephemeral per-session logs with actions and request/response status, removed on exit.
 
 ---
 
@@ -100,13 +105,15 @@ These alerts (e.g., "AI-detected potential code anomaly", "Shell access", "Netwo
 | `ipingyou` | Interactive CLI dashboard wizard. |
 | `ipingyou host` | Start hosting and exposing your local machine securely. |
 | `ipingyou connect -u <UID>` | Connect directly to a specific UID. |
+| `ipingyou ai` | Groq-powered task assistant with guarded local/remote tools. |
+| `ipingyou doctor` | Diagnostics for dependencies, SSH, broker, SCP, AI, and tests. |
 | `ipingyou panic` | 🚨 Self-destruct mode. Wipes configs, memory, and kills all processes. |
 | `ipingyou service install` | 👻 Installs Host mode as an always-on background daemon. |
 | `ipingyou service stop` | Stops and removes the background daemon. |
+| `ipingyou service status` | Shows background daemon status. |
 
 ---
 
 ## 📜 License
 
 [MIT License](LICENSE) © Sk Mirajul Islam
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraj181/ipingyou",
-  "version": "2.0.13",
+  "version": "2.1.0",
   "description": "SecureLink-CLI — Secure peer-to-peer remote access via SSH & Cloudflare Tunnels",
   "main": "src/cli.js",
   "bin": {
@@ -18,6 +18,7 @@
   "scripts": {
     "start": "node src/server.js",
     "dev:cli": "node src/cli.js",
+    "test": "node test/test_ai_helpers.js",
     "prepublishOnly": "node -e \"require('fs').accessSync('LICENSE')\" && node src/cli.js --help"
   },
   "keywords": [
@@ -44,16 +45,16 @@
   },
   "dependencies": {
     "chalk": "^5.3.0",
-    "commander": "^12.1.0",
+    "commander": "^14.0.3",
     "execa": "^9.5.2",
-    "inquirer": "^12.3.2",
+    "inquirer": "^13.4.3",
     "nanoid": "^5.0.9",
     "open": "^11.0.0",
-    "ora": "^8.1.1",
+    "ora": "^9.4.0",
     "tree-kill": "^1.2.2",
     "ws": "^8.20.1",
-    "express": "^4.19.2",
-    "express-rate-limit": "^7.3.1",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.5.2",
     "helmet": "^7.1.0"
   },
   "devDependencies": {

package/src/cli.js

@@ -29,6 +29,8 @@ import { detectOS, checkDependencies } from './lib/platform.js';
 import { cleanupAll, installShutdownHandlers, executePanicMode } from './lib/cleanup.js';
 import { startHostMode } from './modes/host.js';
 import { startClientMode } from './modes/client.js';
+import { startAIMode } from './modes/ai.js';
+import { startDoctorMode } from './modes/doctor.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
@@ -112,6 +114,8 @@ function showRichHelp() {
   console.log(`    ${chalk.green('host')}    : Generates a secure session UID and exposes your local machine.`);
   console.log(`    ${chalk.blue('connect')} : Prompts for a UID to connect to a remote host.`);
   console.log(`              ${chalk.dim('Supports Interactive SSH Shell & SCP File Transfers')}`);
+  console.log(`    ${chalk.magenta('ai')}      : Groq-powered task assistant with guarded local/remote tools.`);
+  console.log(`    ${chalk.yellow('doctor')}  : Run diagnostics for dependencies, SSH, broker, SCP, AI, and tests.`);
   console.log('');
   
   console.log(chalk.bold.white('  🔒 Security Architecture:'));
@@ -132,8 +136,12 @@ function showRichHelp() {
   console.log(`    $ npx ipingyou                  ${chalk.dim('# Interactive wizard (Recommended)')}`);
   console.log(`    $ npx ipingyou host             ${chalk.dim('# Quick start as Host')}`);
   console.log(`    $ npx ipingyou connect          ${chalk.dim('# Quick start as Client')}`);
+  console.log(`    $ npx ipingyou ai               ${chalk.dim('# Start AI task assistant')}`);
+  console.log(`    $ npx ipingyou doctor           ${chalk.dim('# Diagnose local setup')}`);
   console.log(`    $ npx ipingyou panic            ${chalk.dim('# Self-destruct and wipe memory/traces')}`);
   console.log(`    $ npx ipingyou service install  ${chalk.dim('# Install Host mode as a background daemon')}`);
+  console.log(`    $ npx ipingyou allowlist        ${chalk.dim('# Manage AI command allowlist')}`);
+  console.log(`    $ npx ipingyou history          ${chalk.dim('# View session event logs')}`);
   console.log('');
 }
 
@@ -192,6 +200,14 @@ async function interactiveMode() {
           name: `${chalk.blue('🌐 Access a Remote Machine')}  ${chalk.dim('— Connect to a host via their UID (SSH/SCP)')}`,
           value: 'client',
         },
+        {
+          name: `${chalk.magenta('🤖 AI Task Assistant')}  ${chalk.dim('— Use Groq LLMs with guarded local/remote tools')}`,
+          value: 'ai',
+        },
+        {
+          name: `${chalk.yellow('🩺 Run Doctor')}  ${chalk.dim('— Diagnose setup and project health')}`,
+          value: 'doctor',
+        },
         new inquirer.Separator(),
         {
           name: `${chalk.magenta('📖 Help / Information')}   ${chalk.dim('— Learn how iPingYou works')}`,
@@ -208,6 +224,12 @@ async function interactiveMode() {
     case 'client':
       await startClientMode();
       break;
+    case 'ai':
+      await startAIMode();
+      break;
+    case 'doctor':
+      await startDoctorMode();
+      break;
     case 'help':
       showRichHelp();
       break;
@@ -265,6 +287,40 @@ program
     }
   });
 
+program
+  .command('ai')
+  .description('Start AI mode — Groq-powered local/remote task assistant with guarded tools')
+  .action(async () => {
+    try {
+      const opts = program.opts();
+      if (opts.broker) process.env.BROKER_URL = opts.broker;
+
+      showBanner();
+      showSystemInfo();
+      installShutdownHandlers();
+      await startAIMode();
+    } catch (err) {
+      fatal('ai', err);
+    }
+  });
+
+program
+  .command('doctor')
+  .description('Run non-invasive diagnostics for dependencies, SSH, broker, SCP, AI, and tests')
+  .option('--full', 'Run full diagnostics, including broker integration if a local broker is running')
+  .action(async (commandOptions) => {
+    try {
+      const opts = program.opts();
+      if (opts.broker) process.env.BROKER_URL = opts.broker;
+
+      showBanner();
+      showSystemInfo();
+      await startDoctorMode({ full: commandOptions.full });
+    } catch (err) {
+      fatal('doctor', err);
+    }
+  });
+
 program
   .command('panic')
   .description('🚨 Self-destruct mode: wipe all configs, kill tunnels, and remove traces')
@@ -310,6 +366,166 @@ program
     }
   });
 
+program
+  .command('allowlist')
+  .description('Manage AI command allowlist — add, remove, or list safe regex patterns')
+  .argument('[action]', 'Action: list, add, remove', 'list')
+  .argument('[pattern]', 'Regex pattern to add or remove')
+  .action(async (action, pattern) => {
+    try {
+      showBanner();
+      const fs = await import('node:fs');
+      const os = await import('node:os');
+      const path = await import('node:path');
+      const { ensureAllowlistFile, getAllowlistRegexes } = await import('./lib/allowlist.js');
+
+      const allowlistPath = ensureAllowlistFile();
+
+      if (action === 'list' || !action) {
+        const patterns = getAllowlistRegexes();
+        console.log(chalk.bold.cyan('  📋 AI Command Allowlist'));
+        console.log(chalk.dim('  ─────────────────────────────────────'));
+        console.log(chalk.dim(`  File: ${allowlistPath}`));
+        console.log('');
+        if (patterns.length === 0) {
+          console.log(chalk.dim('  No patterns configured.'));
+        } else {
+          try {
+            const raw = JSON.parse(fs.readFileSync(allowlistPath, 'utf8'));
+            raw.forEach((p, i) => {
+              console.log(`  ${chalk.green(i + 1)}. ${chalk.white(p)}`);
+            });
+          } catch (e) {
+            console.log(chalk.red('  ❌ Allowlist file is corrupted.'));
+          }
+        }
+        console.log('');
+        console.log(chalk.dim('  Usage: ipingyou allowlist add "^my-safe-command"'));
+        console.log(chalk.dim('         ipingyou allowlist remove "^my-safe-command"'));
+      } else if (action === 'add') {
+        if (!pattern) {
+          console.log(chalk.red('  ❌ Missing pattern. Usage: ipingyou allowlist add "^my-command"'));
+          process.exit(1);
+        }
+        // Validate regex
+        try { new RegExp(pattern); } catch (err) {
+          console.log(chalk.red(`  ❌ Invalid regex: ${err.message}`));
+          process.exit(1);
+        }
+        let raw = [];
+        try { raw = JSON.parse(fs.readFileSync(allowlistPath, 'utf8')); } catch {}
+        if (raw.includes(pattern)) {
+          console.log(chalk.yellow(`  ⚠️  Pattern already exists: ${pattern}`));
+        } else {
+          raw.push(pattern);
+          fs.writeFileSync(allowlistPath, JSON.stringify(raw, null, 2), { mode: 0o600 });
+          console.log(chalk.green(`  ✅ Added: ${chalk.white(pattern)}`));
+        }
+      } else if (action === 'remove') {
+        if (!pattern) {
+          console.log(chalk.red('  ❌ Missing pattern. Usage: ipingyou allowlist remove "^my-command"'));
+          process.exit(1);
+        }
+        let raw = [];
+        try { raw = JSON.parse(fs.readFileSync(allowlistPath, 'utf8')); } catch {}
+        const idx = raw.indexOf(pattern);
+        if (idx === -1) {
+          console.log(chalk.yellow(`  ⚠️  Pattern not found: ${pattern}`));
+        } else {
+          raw.splice(idx, 1);
+          fs.writeFileSync(allowlistPath, JSON.stringify(raw, null, 2), { mode: 0o600 });
+          console.log(chalk.green(`  ✅ Removed: ${chalk.white(pattern)}`));
+        }
+      } else {
+        console.log(chalk.red(`  ❌ Unknown action: ${action}. Use list, add, or remove.`));
+      }
+    } catch (err) {
+      fatal('allowlist', err);
+    }
+  });
+
+program
+  .command('history')
+  .description('View session event logs from ~/.ipingyou/logs')
+  .option('-n, --lines <count>', 'Number of recent events to show', '25')
+  .option('--type <type>', 'Filter by event type (e.g. ssh, scp, ai)')
+  .option('--json', 'Output raw JSON lines')
+  .action(async (commandOptions) => {
+    try {
+      showBanner();
+      const fs = await import('node:fs');
+      const os = await import('node:os');
+      const pathMod = await import('node:path');
+
+      const logFile = pathMod.default.join(os.default.homedir(), '.ipingyou', 'logs', 'session-events.jsonl');
+
+      console.log(chalk.bold.cyan('  📜 Session Event History'));
+      console.log(chalk.dim('  ─────────────────────────────────────'));
+
+      if (!fs.existsSync(logFile)) {
+        console.log(chalk.dim('  No session history found yet.'));
+        console.log(chalk.dim(`  Events are recorded to: ${logFile}`));
+        return;
+      }
+
+      const raw = fs.readFileSync(logFile, 'utf8').trim();
+      if (!raw) {
+        console.log(chalk.dim('  Log file is empty.'));
+        return;
+      }
+
+      let events = raw.split('\n').map(line => {
+        try { return JSON.parse(line); } catch { return null; }
+      }).filter(Boolean);
+
+      // Filter by type if specified
+      if (commandOptions.type) {
+        const filter = commandOptions.type.toLowerCase();
+        events = events.filter(e => (e.type || '').toLowerCase().includes(filter));
+      }
+
+      // Take last N events
+      const count = parseInt(commandOptions.lines) || 25;
+      events = events.slice(-count);
+
+      if (events.length === 0) {
+        console.log(chalk.dim('  No matching events found.'));
+        return;
+      }
+
+      console.log(chalk.dim(`  Showing last ${events.length} event(s)${commandOptions.type ? ` matching "${commandOptions.type}"` : ''}:`));
+      console.log('');
+
+      if (commandOptions.json) {
+        events.forEach(e => console.log(JSON.stringify(e)));
+      } else {
+        const levelColors = {
+          info: chalk.blue,
+          warn: chalk.yellow,
+          error: chalk.red,
+        };
+
+        events.forEach(e => {
+          const time = e.time ? new Date(e.time).toLocaleString() : '?';
+          const level = (e.level || 'info').toUpperCase().padEnd(5);
+          const colorFn = levelColors[e.level] || chalk.white;
+          const type = chalk.cyan((e.type || 'unknown').padEnd(35));
+          const details = e.details && Object.keys(e.details).length > 0
+            ? chalk.dim(JSON.stringify(e.details))
+            : '';
+
+          console.log(`  ${chalk.dim(time)}  ${colorFn(level)}  ${type}  ${details}`);
+        });
+      }
+
+      console.log('');
+      console.log(chalk.dim(`  Log file: ${logFile}`));
+      console.log(chalk.dim(`  Total events in file: ${raw.split('\n').length}`));
+    } catch (err) {
+      fatal('history', err);
+    }
+  });
+
 // ─── Default: interactive mode ──────────────────────────────
 program.action(async () => {
   try {

package/src/lib/ai/groq.js

@@ -0,0 +1,116 @@
+const GROQ_API_BASE = 'https://api.groq.com/openai/v1';
+
+export const DEFAULT_AI_MODEL = 'qwen/qwen3-32b';
+
+export function getGroqApiKey() {
+  return process.env.GROQ_API_KEY || null;
+}
+
+export async function listGroqModels(apiKey) {
+  const res = await fetch(`${GROQ_API_BASE}/models`, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!res.ok) {
+    const message = await res.text().catch(() => '');
+    throw new Error(`Groq model lookup failed: HTTP ${res.status} ${message}`.trim());
+  }
+
+  const data = await res.json();
+  return Array.isArray(data.data) ? data.data : [];
+}
+
+export async function createGroqChatCompletion(apiKey, body) {
+  const res = await fetch(`${GROQ_API_BASE}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    const message = await res.text().catch(() => '');
+    const err = new Error(`Groq chat completion failed: HTTP ${res.status} ${message}`.trim());
+    err.status = res.status;
+    err.rateLimit = parseGroqRateLimitHeaders(res.headers);
+    throw err;
+  }
+
+  const data = await res.json();
+  data._rateLimit = parseGroqRateLimitHeaders(res.headers);
+  return data;
+}
+
+export function parseGroqRateLimitHeaders(headers) {
+  const readNumber = (name) => {
+    const value = headers.get(name);
+    if (!value) return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  };
+
+  return {
+    limitRequests: readNumber('x-ratelimit-limit-requests'),
+    remainingRequests: readNumber('x-ratelimit-remaining-requests'),
+    resetRequests: headers.get('x-ratelimit-reset-requests') || null,
+    limitTokens: readNumber('x-ratelimit-limit-tokens'),
+    remainingTokens: readNumber('x-ratelimit-remaining-tokens'),
+    resetTokens: headers.get('x-ratelimit-reset-tokens') || null,
+    retryAfter: headers.get('retry-after') || null,
+  };
+}
+
+// Lightweight token estimator: approximate tokens by characters/4
+export function estimateTokensForMessages(messages = [], completionText = '') {
+  try {
+    let chars = 0;
+    for (const m of messages || []) {
+      if (!m) continue;
+      chars += String(m).length;
+    }
+    chars += String(completionText || '').length;
+    return Math.max(0, Math.ceil(chars / 4));
+  } catch {
+    return 0;
+  }
+}
+
+export function getRateLimitWarnings(rateLimit, threshold = 0.8) {
+  if (!rateLimit) return [];
+
+  const warnings = [];
+  const checks = [
+    {
+      label: 'daily request',
+      limit: rateLimit.limitRequests,
+      remaining: rateLimit.remainingRequests,
+      reset: rateLimit.resetRequests,
+    },
+    {
+      label: 'per-minute token',
+      limit: rateLimit.limitTokens,
+      remaining: rateLimit.remainingTokens,
+      reset: rateLimit.resetTokens,
+    },
+  ];
+
+  for (const item of checks) {
+    if (!item.limit || item.remaining === null || item.remaining === undefined) continue;
+    const used = Math.max(0, item.limit - item.remaining);
+    const ratio = used / item.limit;
+    if (ratio >= threshold) {
+      warnings.push({
+        ...item,
+        used,
+        percent: Math.round(ratio * 100),
+      });
+    }
+  }
+
+  return warnings;
+}

package/src/lib/ai/safety.js

@@ -0,0 +1,114 @@
+const SECRET_PATTERNS = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  /\b(gsk_[A-Za-z0-9_-]{20,})\b/g,
+  /\b(sk-[A-Za-z0-9_-]{20,})\b/g,
+  /\b(ghp_[A-Za-z0-9_]{20,})\b/g,
+  /\b(xox[baprs]-[A-Za-z0-9-]{20,})\b/g,
+  /(["']?(?:api[_-]?key|token|password|secret|private[_-]?key)["']?\s*[:=]\s*["']?)[^\s"',}]+/gi,
+];
+
+const BLOCKED_PATH_PATTERNS = [
+  /(^|[\s~/])\.ssh(\/|$)/,
+  /(^|[\s~/])\.gnupg(\/|$)/,
+  /(^|[\s~/])\.aws(\/|$)/,
+  /(^|[\s~/])\.config\/gh(\/|$)/,
+  /(^|[\s~/])\.ipingyou(\/|$)/,
+  /(^|[\s~/])\.npmrc($|\s)/,
+  /(^|[\s~/])\.netrc($|\s)/,
+  /(^|[\s~/])\.pypirc($|\s)/,
+  /(^|[\s~/])\.env($|[\s.]|\/)/,
+  /id_(rsa|dsa|ecdsa|ed25519)(\.pub)?$/,
+];
+
+const BLOCKED_COMMAND_PATTERNS = [
+  /^\s*(env|printenv|set)\b/,
+  /\b(export|declare)\s+-p\b/,
+  /\bsecurity\s+find-generic-password\b/,
+  /\bpass\s+show\b/,
+];
+
+const DANGEROUS_COMMAND_PATTERNS = [
+  /\brm\s+(-[^\s]*[rf][^\s]*|--recursive|--force)/,
+  /\bsudo\b/,
+  /\bchmod\b/,
+  /\bchown\b/,
+  /\bmv\b/,
+  /\bcp\b/,
+  /\binstall\b/,
+  /\bnpm\s+(i|install|uninstall|remove|rm)\b/,
+  /\b(pnpm|yarn)\s+(add|remove|install)\b/,
+  /\b(git\s+(reset|clean|checkout|switch|merge|rebase|push|commit))\b/,
+  /\b(curl|wget)\b/,
+  />|>>|\btee\b/,
+];
+
+import { getAllowlistRegexes } from '../allowlist.js';
+
+const READ_ONLY_COMMAND_PATTERNS = [
+  /^\s*(pwd|ls|find|rg|grep|sed|cat|head|tail|wc|git status|git diff|git log|git show|node --version|npm --version|which|date|uname)\b/,
+];
+
+export function redactSensitive(value) {
+  let output = String(value ?? '');
+  for (const pattern of SECRET_PATTERNS) {
+    output = output.replace(pattern, (match, prefix) => prefix ? `${prefix}[REDACTED]` : '[REDACTED]');
+  }
+  return output;
+}
+
+export function truncateForModel(value, maxChars = 12000) {
+  const text = redactSensitive(value);
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}\n[TRUNCATED ${text.length - maxChars} chars]`;
+}
+
+export function commandTouchesBlockedPath(command) {
+  return BLOCKED_PATH_PATTERNS.some(pattern => pattern.test(command));
+}
+
+export function classifyCommand(command) {
+  const text = String(command || '').trim();
+  if (!text) return { blocked: true, needsApproval: true, reason: 'Empty command' };
+
+  if (commandTouchesBlockedPath(text)) {
+    return {
+      blocked: true,
+      needsApproval: true,
+      reason: 'Command references a protected secret/config path',
+    };
+  }
+
+  // Check user-provided allowlist first (if present)
+  try {
+    const userPatterns = getAllowlistRegexes();
+    if (Array.isArray(userPatterns) && userPatterns.some(p => p.test(text))) {
+      return { blocked: false, needsApproval: false, reason: 'Matched user allowlist' };
+    }
+  } catch {
+    // ignore allowlist errors and fall back to defaults
+  }
+
+  if (BLOCKED_COMMAND_PATTERNS.some(pattern => pattern.test(text))) {
+    return {
+      blocked: true,
+      needsApproval: true,
+      reason: 'Command could dump environment variables or credential stores',
+    };
+  }
+
+  if (DANGEROUS_COMMAND_PATTERNS.some(pattern => pattern.test(text))) {
+    return { blocked: false, needsApproval: true, reason: 'Command may modify files, install packages, or access the network' };
+  }
+
+  if (READ_ONLY_COMMAND_PATTERNS.some(pattern => pattern.test(text))) {
+    return { blocked: false, needsApproval: false, reason: 'Read-only command' };
+  }
+
+  return { blocked: false, needsApproval: true, reason: 'Command is not known to be read-only' };
+}
+
+export function sanitizeUserTask(task) {
+  return redactSensitive(task)
+    .replace(/session password\s*[:=]\s*\S+/gi, 'session password: [REDACTED]')
+    .replace(/private key\s*[:=]\s*\S+/gi, 'private key: [REDACTED]');
+}

package/src/lib/allowlist.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const ALLOWLIST_PATH = path.join(os.homedir(), '.ipingyou', 'allowlist.json');
+
+export function getAllowlistRegexes() {
+    try {
+        if (!fs.existsSync(ALLOWLIST_PATH)) return [];
+        const raw = fs.readFileSync(ALLOWLIST_PATH, 'utf8');
+        const data = JSON.parse(raw || '[]');
+        if (!Array.isArray(data)) return [];
+        return data.map(s => {
+            try { return new RegExp(s); } catch { return null; }
+        }).filter(Boolean);
+    } catch {
+        return [];
+    }
+}
+
+export function ensureAllowlistFile() {
+    try {
+        if (!fs.existsSync(path.dirname(ALLOWLIST_PATH))) {
+            fs.mkdirSync(path.dirname(ALLOWLIST_PATH), { recursive: true, mode: 0o700 });
+        }
+        if (!fs.existsSync(ALLOWLIST_PATH)) {
+            fs.writeFileSync(ALLOWLIST_PATH, JSON.stringify([
+                '^\\s*(pwd|ls|find|rg|grep|sed|cat|head|tail|wc|git status|git diff|git log|git show|node --version|npm --version|which|date|uname)\\b'
+            ], null, 2), { mode: 0o600 });
+        }
+        return ALLOWLIST_PATH;
+    } catch {
+        return ALLOWLIST_PATH;
+    }
+}