fss-link 1.5.7 → 1.6.0

package/scripts/check-build-status.js

@@ -0,0 +1,148 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os'; // Import os module
+
+// --- Configuration ---
+const cliPackageDir = path.resolve('packages', 'cli'); // Base directory for the CLI package
+const buildTimestampPath = path.join(cliPackageDir, 'dist', '.last_build'); // Path to the timestamp file within the CLI package
+const sourceDirs = [path.join(cliPackageDir, 'src')]; // Source directory within the CLI package
+const filesToWatch = [
+  path.join(cliPackageDir, 'package.json'),
+  path.join(cliPackageDir, 'tsconfig.json'),
+]; // Specific files within the CLI package
+const buildDir = path.join(cliPackageDir, 'dist'); // Build output directory within the CLI package
+const warningsFilePath = path.join(os.tmpdir(), 'qwen-code-warnings.txt'); // Temp file for warnings
+// ---------------------
+
+function getMtime(filePath) {
+  try {
+    return fs.statSync(filePath).mtimeMs; // Use mtimeMs for higher precision
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return null; // File doesn't exist
+    }
+    console.error(`Error getting stats for ${filePath}:`, err);
+    process.exit(1); // Exit on unexpected errors getting stats
+  }
+}
+
+function findSourceFiles(dir, allFiles = []) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    // Simple check to avoid recursing into node_modules or build dir itself
+    if (
+      entry.isDirectory() &&
+      entry.name !== 'node_modules' &&
+      fullPath !== buildDir
+    ) {
+      findSourceFiles(fullPath, allFiles);
+    } else if (entry.isFile()) {
+      allFiles.push(fullPath);
+    }
+  }
+  return allFiles;
+}
+
+console.log('Checking build status...');
+
+// Clean up old warnings file before check
+try {
+  if (fs.existsSync(warningsFilePath)) {
+    fs.unlinkSync(warningsFilePath);
+  }
+} catch (err) {
+  console.warn(
+    `[Check Script] Warning: Could not delete previous warnings file: ${err.message}`,
+  );
+}
+
+const buildMtime = getMtime(buildTimestampPath);
+if (!buildMtime) {
+  // If build is missing, write that as a warning and exit(0) so app can display it
+  const errorMessage = `ERROR: Build timestamp file (${path.relative(process.cwd(), buildTimestampPath)}) not found. Run \`npm run build\` first.`;
+  console.error(errorMessage); // Still log error here
+  try {
+    fs.writeFileSync(warningsFilePath, errorMessage);
+  } catch (writeErr) {
+    console.error(
+      `[Check Script] Error writing missing build warning file: ${writeErr.message}`,
+    );
+  }
+  process.exit(0); // Allow app to start and show the error
+}
+
+let newerSourceFileFound = false;
+const warningMessages = []; // Collect warnings here
+const allSourceFiles = [];
+
+// Collect files from specified directories
+sourceDirs.forEach((dir) => {
+  const dirPath = path.resolve(dir);
+  if (fs.existsSync(dirPath)) {
+    findSourceFiles(dirPath, allSourceFiles);
+  } else {
+    console.warn(`Warning: Source directory "${dir}" not found.`);
+  }
+});
+
+// Add specific files
+filesToWatch.forEach((file) => {
+  const filePath = path.resolve(file);
+  if (fs.existsSync(filePath)) {
+    allSourceFiles.push(filePath);
+  } else {
+    console.warn(`Warning: Watched file "${file}" not found.`);
+  }
+});
+
+// Check modification times
+for (const file of allSourceFiles) {
+  const sourceMtime = getMtime(file);
+  const relativePath = path.relative(process.cwd(), file);
+  const isNewer = sourceMtime && sourceMtime > buildMtime;
+
+  if (isNewer) {
+    const warning = `Warning: Source file "${relativePath}" has been modified since the last build.`;
+    console.warn(warning); // Keep console warning for script debugging
+    warningMessages.push(warning);
+    newerSourceFileFound = true;
+    // break; // Uncomment to stop checking after the first newer file
+  }
+}
+
+if (newerSourceFileFound) {
+  const finalWarning =
+    '\nRun "npm run build" to incorporate changes before starting.';
+  warningMessages.push(finalWarning);
+  console.warn(finalWarning);
+
+  // Write warnings to the temp file
+  try {
+    fs.writeFileSync(warningsFilePath, warningMessages.join('\n'));
+    // Removed debug log
+  } catch (err) {
+    console.error(`[Check Script] Error writing warnings file: ${err.message}`);
+    // Proceed without writing, app won't show warnings
+  }
+} else {
+  console.log('Build is up-to-date.');
+  // Ensure no stale warning file exists if build is ok
+  try {
+    if (fs.existsSync(warningsFilePath)) {
+      fs.unlinkSync(warningsFilePath);
+    }
+  } catch (err) {
+    console.warn(
+      `[Check Script] Warning: Could not delete previous warnings file: ${err.message}`,
+    );
+  }
+}
+
+process.exit(0); // Always exit successfully so the app starts

package/scripts/check-publish.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * Pre-publish safety check for FSS Link
+ * Ensures we're publishing from the correct location with a valid bundle
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '..');
+
+console.log('🔍 FSS Link Pre-Publish Safety Check');
+console.log('=====================================\n');
+
+let errors = 0;
+
+// Check 1: Publishing from project root, not packages/
+if (process.cwd().includes('packages')) {
+  console.error('❌ ERROR: Must publish from project root, not packages/!');
+  console.error('   Current directory: ' + process.cwd());
+  console.error('   Run: cd ' + projectRoot + ' && npm publish\n');
+  errors++;
+} else {
+  console.log('✅ Publishing from project root');
+}
+
+// Check 2: Bundle exists
+const bundlePath = path.join(projectRoot, 'bundle/fss-link.js');
+if (!fs.existsSync(bundlePath)) {
+  console.error('❌ ERROR: bundle/fss-link.js not found');
+  console.error('   Run: npm run bundle\n');
+  errors++;
+} else {
+  console.log('✅ Bundle exists');
+
+  // Check 3: Bundle is executable
+  const stats = fs.statSync(bundlePath);
+  if (!(stats.mode & 0o111)) {
+    console.error('❌ ERROR: Bundle is not executable');
+    console.error('   Run: chmod +x bundle/fss-link.js\n');
+    errors++;
+  } else {
+    console.log('✅ Bundle is executable');
+  }
+
+  // Check 4: Bundle has shebang
+  const firstLine = fs.readFileSync(bundlePath, 'utf8').split('\n')[0];
+  if (firstLine !== '#!/usr/bin/env node') {
+    console.error('❌ ERROR: Bundle missing shebang line');
+    console.error('   Expected: #!/usr/bin/env node');
+    console.error('   Got: ' + firstLine + '\n');
+    errors++;
+  } else {
+    console.log('✅ Bundle has correct shebang');
+  }
+
+  // Check 5: Bundle size is reasonable (> 1MB)
+  const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+  if (stats.size < 1024 * 1024) {
+    console.error(`❌ ERROR: Bundle suspiciously small (${sizeMB} MB)`);
+    console.error('   Expected: > 1 MB');
+    console.error('   This may indicate an incomplete build\n');
+    errors++;
+  } else {
+    console.log(`✅ Bundle size reasonable (${sizeMB} MB)`);
+  }
+}
+
+// Check 6: Version in bundle matches package.json
+const pkgPath = path.join(projectRoot, 'package.json');
+const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+if (fs.existsSync(bundlePath)) {
+  const bundleContent = fs.readFileSync(bundlePath, 'utf8');
+  // Check for version in various formats: "version":"1.2.8", version = "1.2.8", etc.
+  const versionPatterns = [
+    `"version":"${pkg.version}"`,
+    `version = "${pkg.version}"`,
+    `'version':'${pkg.version}'`,
+  ];
+  const hasVersion = versionPatterns.some(pattern => bundleContent.includes(pattern));
+
+  if (!hasVersion) {
+    console.error(`❌ ERROR: Bundle version mismatch`);
+    console.error(`   package.json: ${pkg.version}`);
+    console.error(`   Bundle may have different version - rebuild with: npm run bundle\n`);
+    errors++;
+  } else {
+    console.log(`✅ Bundle version matches package.json (${pkg.version})`);
+  }
+}
+
+console.log('\n=====================================');
+if (errors > 0) {
+  console.error(`❌ ${errors} error(s) found - publish blocked\n`);
+  process.exit(1);
+} else {
+  console.log('✅ All checks passed - safe to publish\n');
+  process.exit(0);
+}

package/scripts/clean.js

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { rmSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { globSync } from 'glob';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+
+// remove npm install/build artifacts
+rmSync(join(root, 'node_modules'), { recursive: true, force: true });
+rmSync(join(root, 'bundle'), { recursive: true, force: true });
+rmSync(join(root, 'packages/cli/src/generated/'), {
+  recursive: true,
+  force: true,
+});
+const RMRF_OPTIONS = { recursive: true, force: true };
+rmSync(join(root, 'bundle'), RMRF_OPTIONS);
+// Dynamically clean dist directories in all workspaces
+const rootPackageJson = JSON.parse(
+  readFileSync(join(root, 'package.json'), 'utf-8'),
+);
+for (const workspace of rootPackageJson.workspaces) {
+  const packages = globSync(join(workspace, 'package.json'), { cwd: root });
+  for (const pkgPath of packages) {
+    const pkgDir = dirname(join(root, pkgPath));
+    rmSync(join(pkgDir, 'dist'), RMRF_OPTIONS);
+  }
+}
+
+// Clean up vsix files in vscode-ide-companion
+const vsixFiles = globSync('packages/vscode-ide-companion/*.vsix', {
+  cwd: root,
+});
+for (const vsixFile of vsixFiles) {
+  rmSync(join(root, vsixFile), RMRF_OPTIONS);
+}

package/scripts/copy_bundle_assets.js

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { copyFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname, join, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { glob } from 'glob';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+const bundleDir = join(root, 'bundle');
+
+// Create the bundle directory if it doesn't exist
+if (!existsSync(bundleDir)) {
+  mkdirSync(bundleDir);
+}
+
+// Find and copy all .sb files from packages to the root of the bundle directory
+const sbFiles = glob.sync('packages/**/*.sb', { cwd: root });
+for (const file of sbFiles) {
+  copyFileSync(join(root, file), join(bundleDir, basename(file)));
+}
+
+console.log('Assets copied to bundle/');

package/scripts/copy_files.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import fs from 'fs';
+import path from 'path';
+
+const sourceDir = path.join('src');
+const targetDir = path.join('dist', 'src');
+
+const extensionsToCopy = ['.md', '.json', '.sb'];
+
+function copyFilesRecursive(source, target) {
+  if (!fs.existsSync(target)) {
+    fs.mkdirSync(target, { recursive: true });
+  }
+
+  const items = fs.readdirSync(source, { withFileTypes: true });
+
+  for (const item of items) {
+    const sourcePath = path.join(source, item.name);
+    const targetPath = path.join(target, item.name);
+
+    if (item.isDirectory()) {
+      copyFilesRecursive(sourcePath, targetPath);
+    } else if (extensionsToCopy.includes(path.extname(item.name))) {
+      fs.copyFileSync(sourcePath, targetPath);
+    }
+  }
+}
+
+if (!fs.existsSync(sourceDir)) {
+  console.error(`Source directory ${sourceDir} not found.`);
+  process.exit(1);
+}
+
+copyFilesRecursive(sourceDir, targetDir);
+console.log('Successfully copied files.');

package/scripts/create_alias.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# This script creates an alias for the Gemini CLI
+
+# Determine the project directory
+PROJECT_DIR=$(cd "$(dirname "$0")/.." && pwd)
+ALIAS_COMMAND="alias qwen='node "${PROJECT_DIR}/scripts/start.js"'"
+
+# Detect shell and set config file path
+if [[ "${SHELL}" == *"/bash" ]]; then
+    CONFIG_FILE="${HOME}/.bashrc"
+elif [[ "${SHELL}" == *"/zsh" ]]; then
+    CONFIG_FILE="${HOME}/.zshrc"
+else
+    echo "Unsupported shell. Only bash and zsh are supported."
+    exit 1
+fi
+
+echo "This script will add the following alias to your shell configuration file (${CONFIG_FILE}):"
+echo "  ${ALIAS_COMMAND}"
+echo ""
+
+# Check if the alias already exists
+if grep -q "alias qwen=" "${CONFIG_FILE}"; then
+    echo "A 'qwen' alias already exists in ${CONFIG_FILE}. No changes were made."
+    exit 0
+fi
+
+read -p "Do you want to proceed? (y/n) " -n 1 -r
+echo ""
+if [[ "${REPLY}" =~ ^[Yy]$ ]]; then
+    echo "${ALIAS_COMMAND}" >> "${CONFIG_FILE}"
+    echo ""
+    echo "Alias added to ${CONFIG_FILE}."
+    echo "Please run 'source ${CONFIG_FILE}' or open a new terminal to use the 'qwen' command."
+else
+    echo "Aborted. No changes were made."
+fi

package/scripts/emergency-kill-all-tests.sh

@@ -0,0 +1,95 @@
+#!/bin/bash
+
+# 🚨 NUCLEAR OPTION: Kill ALL test-related processes
+# Purpose: Emergency system recovery when tests cripple the PC
+# Usage: ./scripts/emergency-kill-all-tests.sh
+
+set -e
+
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+GREEN='\033[0;32m'
+NC='\033[0m'
+
+echo -e "${RED}💣 NUCLEAR TEST KILLER - EMERGENCY SYSTEM RECOVERY${NC}"
+echo -e "${YELLOW}⚠️  This will kill ALL Node.js test processes immediately${NC}"
+echo ""
+
+# Find all test-related processes
+echo "Scanning for dangerous processes..."
+
+# More comprehensive process detection
+VITEST_PIDS=$(pgrep -f "vitest" 2>/dev/null || true)
+NODE_TEST_PIDS=$(pgrep -f "node.*test" 2>/dev/null || true) 
+JEST_PIDS=$(pgrep -f "jest" 2>/dev/null || true)
+MOCHA_PIDS=$(pgrep -f "mocha" 2>/dev/null || true)
+NODE_FSS_PIDS=$(pgrep -f "node.*fss-link" 2>/dev/null || true)
+
+ALL_PIDS="${VITEST_PIDS} ${NODE_TEST_PIDS} ${JEST_PIDS} ${MOCHA_PIDS} ${NODE_FSS_PIDS}"
+
+if [ -z "$(echo $ALL_PIDS | tr -d ' ')" ]; then
+    echo -e "${GREEN}✅ No test processes found${NC}"
+    exit 0
+fi
+
+echo -e "${RED}🎯 TARGETS IDENTIFIED:${NC}"
+echo "$ALL_PIDS" | tr ' ' '\n' | while read -r pid; do
+    if [ -n "$pid" ] && [ "$pid" != " " ]; then
+        ps -p "$pid" -o pid,%cpu,%mem,cmd 2>/dev/null || true
+    fi
+done
+
+echo ""
+echo -e "${YELLOW}⚡ IMMEDIATE FORCE KILL - NO MERCY${NC}"
+echo "Killing all processes with SIGKILL..."
+
+# Nuclear option - kill everything immediately
+for pid in $ALL_PIDS; do
+    if [ -n "$pid" ] && [ "$pid" != " " ]; then
+        kill -KILL "$pid" 2>/dev/null && echo "💀 KILLED PID $pid" || true
+    fi
+done
+
+# Also kill any node processes using excessive memory (>1GB)
+echo ""
+echo -e "${YELLOW}🔍 Checking for memory hogs (>1GB)...${NC}"
+ps aux --no-headers | awk '$6 > 1000000 && /node/ {print $2, $6/1024 "MB", $11}' | while read -r line; do
+    if [ -n "$line" ]; then
+        pid=$(echo "$line" | awk '{print $1}')
+        echo -e "${RED}Found memory hog: $line${NC}"
+        kill -KILL "$pid" 2>/dev/null && echo "💀 KILLED memory hog PID $pid" || true
+    fi
+done
+
+sleep 2
+
+# Final verification
+echo ""
+echo -e "${GREEN}🔍 Final system check...${NC}"
+SURVIVORS=$(pgrep -f "vitest\|jest\|mocha\|node.*test" 2>/dev/null || true)
+if [ -n "$SURVIVORS" ]; then
+    echo -e "${RED}❌ SURVIVORS DETECTED:${NC}"
+    ps -p $SURVIVORS -o pid,%cpu,%mem,cmd 2>/dev/null || true
+    echo ""
+    echo -e "${YELLOW}Manual intervention required:${NC}"
+    echo "sudo kill -9 $SURVIVORS"
+else
+    echo -e "${GREEN}🎉 MISSION ACCOMPLISHED - All test processes eliminated${NC}"
+fi
+
+# System recovery commands
+echo ""
+echo -e "${GREEN}🚑 SYSTEM RECOVERY PROTOCOL:${NC}"
+echo "1. Clear memory caches:"
+echo "   sync && echo 3 | sudo tee /proc/sys/vm/drop_caches"
+echo ""
+echo "2. Check available memory:"
+echo "   free -h"
+echo ""
+echo "3. Check system load:"
+echo "   uptime"
+echo ""
+echo "4. Monitor for zombies:"
+echo "   ps aux | grep defunct"
+echo ""
+echo -e "${YELLOW}System should be responsive now. Monitor for 30 seconds before resuming work.${NC}"

package/scripts/emergency-kill-vitest.sh

@@ -0,0 +1,95 @@
+#!/bin/bash
+
+# 🚨 EMERGENCY VITEST KILLER - System Recovery Script
+# Purpose: Kill all vitest processes when they consume excessive memory
+# Usage: ./scripts/emergency-kill-vitest.sh [--force]
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+GREEN='\033[0;32m'
+NC='\033[0m' # No Color
+
+echo -e "${RED}🚨 EMERGENCY VITEST KILLER ACTIVATED${NC}"
+echo "Scanning for vitest processes..."
+
+# Find all vitest-related processes
+VITEST_PIDS=$(pgrep -f "vitest\|node.*test" 2>/dev/null || true)
+NODE_TEST_PIDS=$(pgrep -f "node.*\.test\." 2>/dev/null || true)
+ALL_PIDS="${VITEST_PIDS} ${NODE_TEST_PIDS}"
+
+if [ -z "$ALL_PIDS" ]; then
+    echo -e "${GREEN}✅ No vitest processes found running${NC}"
+    exit 0
+fi
+
+echo -e "${YELLOW}Found processes to kill:${NC}"
+echo "$ALL_PIDS" | tr ' ' '\n' | while read -r pid; do
+    if [ -n "$pid" ]; then
+        ps -p "$pid" -o pid,ppid,%cpu,%mem,cmd 2>/dev/null || true
+    fi
+done
+
+# Check for --force flag
+if [ "$1" = "--force" ]; then
+    echo -e "${RED}🔥 FORCE MODE: Killing immediately...${NC}"
+else
+    echo ""
+    echo -e "${YELLOW}⚠️  WARNING: This will kill ALL vitest and node test processes${NC}"
+    echo "Press ENTER to continue, or Ctrl+C to cancel..."
+    read -r
+fi
+
+# Kill processes gracefully first (SIGTERM)
+echo -e "${YELLOW}🔄 Attempting graceful shutdown (SIGTERM)...${NC}"
+for pid in $ALL_PIDS; do
+    if [ -n "$pid" ]; then
+        kill -TERM "$pid" 2>/dev/null || true
+        echo "Sent SIGTERM to PID $pid"
+    fi
+done
+
+# Wait 3 seconds for graceful shutdown
+echo "Waiting 3 seconds for graceful shutdown..."
+sleep 3
+
+# Check what's still running
+REMAINING_PIDS=$(pgrep -f "vitest\|node.*test" 2>/dev/null || true)
+if [ -n "$REMAINING_PIDS" ]; then
+    echo -e "${RED}💀 Force killing remaining processes (SIGKILL)...${NC}"
+    for pid in $REMAINING_PIDS; do
+        if [ -n "$pid" ]; then
+            kill -KILL "$pid" 2>/dev/null || true
+            echo "Sent SIGKILL to PID $pid"
+        fi
+    done
+else
+    echo -e "${GREEN}✅ All processes terminated gracefully${NC}"
+fi
+
+# Final verification
+sleep 1
+FINAL_CHECK=$(pgrep -f "vitest\|node.*test" 2>/dev/null || true)
+if [ -n "$FINAL_CHECK" ]; then
+    echo -e "${RED}❌ Some processes still running:${NC}"
+    echo "$FINAL_CHECK" | tr ' ' '\n' | while read -r pid; do
+        if [ -n "$pid" ]; then
+            ps -p "$pid" -o pid,ppid,%cpu,%mem,cmd 2>/dev/null || true
+        fi
+    done
+    echo ""
+    echo -e "${YELLOW}💡 You may need to run: sudo kill -9 <PID>${NC}"
+else
+    echo -e "${GREEN}🎉 SUCCESS: All vitest processes killed${NC}"
+fi
+
+# Memory recovery suggestions
+echo ""
+echo -e "${YELLOW}🔧 Memory Recovery Suggestions:${NC}"
+echo "1. Run: sync && echo 3 | sudo tee /proc/sys/vm/drop_caches"
+echo "2. Check memory: free -h"
+echo "3. Check for zombie processes: ps aux | grep defunct"
+echo ""
+echo -e "${GREEN}Emergency kill complete!${NC}"