Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

fix: address security audit findings from #1375 (#1383)

rUv75fe9f564f88
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000000..92fc61484d
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,53 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported |
+|---------|--------------------|
+| 3.5.x | Yes |
+| 3.0-3.4 | No |
+| 2.x | No |
+
+## Reporting a Vulnerability
+
+**Do not open a public GitHub issue for security vulnerabilities.**
+
+Please report vulnerabilities by emailing **[email protected]**. Include the following in your report:
+
+- A clear description of the vulnerability
+- Steps to reproduce the issue
+- Affected versions and components
+- Impact assessment (severity, potential for exploitation)
+- Any suggested fixes or mitigations, if available
+
+## Response Timeline
+
+- **48 hours** -- Initial acknowledgment of your report
+- **7 days** -- Preliminary assessment and severity classification
+- **30 days** -- Target for a fix or mitigation to be released
+
+We will keep you informed of progress throughout the process.
+
+## Safe Harbor
+
+We consider security research conducted in good faith to be authorized activity. We will not pursue legal action against researchers who:
+
+- Make a good faith effort to avoid privacy violations, data destruction, and service disruption
+- Report vulnerabilities promptly and provide sufficient detail for reproduction
+- Do not publicly disclose the vulnerability before a fix is available
+- Do not exploit the vulnerability beyond what is necessary to demonstrate the issue
+
+## Credit
+
+We appreciate the work of security researchers. With your permission, we will publicly credit you in the release notes when a reported vulnerability is fixed.
+
+## Security Practices
+
+This project employs the following security measures at system boundaries:
+
+- **Input validation** using Zod schemas for all public API inputs
+- **Parameterized SQL queries** to prevent injection attacks
+- **Path traversal prevention** via the `PathValidator` module
+- **Command injection protection** via the `SafeExecutor` module
+
+For questions about this policy, contact [email protected].
diff --git a/package.json b/package.json
index 96af4f2001..a6864e8fbf 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "claude-flow",
- "version": "3.5.39",
+ "version": "3.5.40",
"description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
"main": "dist/index.js",
"type": "module",
diff --git a/ruflo/package.json b/ruflo/package.json
index 634b01143f..1c9f1c122c 100644
--- a/ruflo/package.json
+++ b/ruflo/package.json
@@ -1,6 +1,6 @@
{
"name": "ruflo",
- "version": "3.5.39",
+ "version": "3.5.40",
"description": "Ruflo - Enterprise AI agent orchestration platform. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
"main": "bin/ruflo.js",
"type": "module",
diff --git a/v3/@claude-flow/cli/package.json b/v3/@claude-flow/cli/package.json
index fe769aa598..8aeb5cf34c 100644
--- a/v3/@claude-flow/cli/package.json
+++ b/v3/@claude-flow/cli/package.json
@@ -1,6 +1,6 @@
{
"name": "@claude-flow/cli",
- "version": "3.5.39",
+ "version": "3.5.40",
"type": "module",
"description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
"main": "dist/src/index.js",
@@ -75,7 +75,6 @@
"test": "vitest run",
"test:plugin-store": "npx tsx src/plugins/tests/standalone-test.ts",
"test:pattern-store": "npx tsx src/transfer/store/tests/standalone-test.ts",
- "preinstall": "node bin/preinstall.cjs || true",
"prepublishOnly": "cp ../../../README.md ./README.md",
"release": "npm version prerelease --preid=alpha && npm run publish:all",
"publish:all": "./scripts/publish.sh"
diff --git a/v3/@claude-flow/cli/src/commands/cleanup.ts b/v3/@claude-flow/cli/src/commands/cleanup.ts
new file mode 100644
index 0000000000..ffbb30af26
--- /dev/null
+++ b/v3/@claude-flow/cli/src/commands/cleanup.ts
@@ -0,0 +1,236 @@
+/**
+ * V3 CLI Cleanup Command
+ * Removes project artifacts created by claude-flow/ruflo
+ *
+ * Created with ruv.io
+ */
+
+import type { Command, CommandContext, CommandResult } from '../types.js';
+import { output } from '../output.js';
+import { existsSync, statSync, rmSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Artifact directories and files that claude-flow/ruflo may create
+ */
+const ARTIFACT_DIRS = [
+ { path: '.claude', description: 'Claude settings, helpers, agents' },
+ { path: '.claude-flow', description: 'Capabilities and configuration' },
+ { path: 'data', description: 'Memory databases' },
+ { path: '.swarm', description: 'Swarm state' },
+ { path: '.hive-mind', description: 'Consensus state' },
+ { path: 'coordination', description: 'Coordination data' },
+ { path: 'memory', description: 'Memory storage' },
+];
+
+const ARTIFACT_FILES = [
+ { path: 'claude-flow.config.json', description: 'Claude Flow configuration' },
+];
+
+/**
+ * Paths to preserve when --keep-config is set
+ */
+const KEEP_CONFIG_PATHS = [
+ 'claude-flow.config.json',
+ join('.claude', 'settings.json'),
+];
+
+/**
+ * Calculate the total size of a path (file or directory) in bytes
+ */
+function getSize(fullPath: string): number {
+ try {
+ const stat = statSync(fullPath);
+ if (stat.isFile()) {
+ return stat.size;
+ }
+ if (stat.isDirectory()) {
+ let total = 0;
+ const entries = readdirSync(fullPath, { withFileTypes: true });
+ for (const entry of entries) {
+ total += getSize(join(fullPath, entry.name));
+ }
+ return total;
+ }
+ } catch {
+ // Permission errors, broken symlinks, etc.
+ }
+ return 0;
+}
+
+/**
+ * Format bytes into a human-readable string
+ */
+function formatSize(bytes: number): string {
+ if (bytes === 0) return '0 B';
+ const units = ['B', 'KB', 'MB', 'GB'];
+ const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+ const value = bytes / Math.pow(1024, i);
+ return `${value.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+
+/**
+ * Cleanup command definition
+ */
+export const cleanupCommand: Command = {
+ name: 'cleanup',
+ description: 'Remove project artifacts created by claude-flow/ruflo',
+ aliases: ['clean'],
+ options: [
+ {
+ name: 'dry-run',
+ short: 'n',
+ description: 'Show what would be removed without deleting (default behavior)',
+ type: 'boolean',
+ default: true,
+ },
+ {
+ name: 'force',
+ short: 'f',
+ description: 'Actually delete the artifacts',
+ type: 'boolean',
+ default: false,
+ },
+ {
+ name: 'keep-config',
+ short: 'k',
+ description: 'Preserve claude-flow.config.json and .claude/settings.json',
+ type: 'boolean',
+ default: false,
+ },
+ ],
+ examples: [
+ {
+ command: 'cleanup',
+ description: 'Show what would be removed (dry run)',
+ },
+ {
+ command: 'cleanup --force',
+ description: 'Remove all claude-flow artifacts',
+ },
+ {
+ command: 'cleanup --force --keep-config',
+ description: 'Remove artifacts but keep configuration files',
+ },
+ ],
+ action: async (ctx: CommandContext): Promise<CommandResult> => {
+ const force = ctx.flags.force === true;
+ const keepConfig = ctx.flags['keep-config'] === true;
+ const cwd = ctx.cwd;
+
+ const dryRun = !force;
+
+ output.writeln();
+ output.writeln(output.bold(dryRun
+ ? 'Claude Flow Cleanup (dry run)'
+ : 'Claude Flow Cleanup'));
+ output.writeln();
+
+ const found: { path: string; description: string; size: number; type: 'dir' | 'file'; skipped?: boolean }[] = [];
+ let totalSize = 0;
+
+ // Scan directories
+ for (const artifact of ARTIFACT_DIRS) {
+ const fullPath = join(cwd, artifact.path);
+ if (existsSync(fullPath)) {
+ const size = getSize(fullPath);
+ found.push({ path: artifact.path, description: artifact.description, size, type: 'dir' });
+ totalSize += size;
+ }
+ }
+
+ // Scan files
+ for (const artifact of ARTIFACT_FILES) {
+ const fullPath = join(cwd, artifact.path);
+ if (existsSync(fullPath)) {
+ const size = getSize(fullPath);
+ found.push({ path: artifact.path, description: artifact.description, size, type: 'file' });
+ totalSize += size;
+ }
+ }
+
+ if (found.length === 0) {
+ output.writeln(output.info('No claude-flow artifacts found in the current directory.'));
+ return { success: true, message: 'Nothing to clean' };
+ }
+
+ // Mark items that would be skipped due to --keep-config
+ if (keepConfig) {
+ for (const item of found) {
+ if (KEEP_CONFIG_PATHS.includes(item.path)) {
+ item.skipped = true;
+ }
+ }
+ }
+
+ // Display what was found
+ output.writeln(output.bold('Artifacts found:'));
+ output.writeln();
+
+ let removedCount = 0;
+ let removedSize = 0;
+ let skippedCount = 0;
+
+ for (const item of found) {
+ const sizeStr = formatSize(item.size);
+ const typeLabel = item.type === 'dir' ? 'dir ' : 'file';
+
+ if (item.skipped) {
+ output.writeln(output.dim(` [skip] ${typeLabel} ${item.path} (${sizeStr}) - ${item.description}`));
+ skippedCount++;
+ continue;
+ }
+
+ if (dryRun) {
+ output.writeln(output.warning(` [would remove] ${typeLabel} ${item.path} (${sizeStr}) - ${item.description}`));
+ } else {
+ // Actually delete
+ try {
+ const fullPath = join(cwd, item.path);
+ if (item.type === 'dir') {
+ rmSync(fullPath, { recursive: true, force: true });
+ } else {
+ rmSync(fullPath, { force: true });
+ }
+ output.writeln(output.success(` [removed] ${typeLabel} ${item.path} (${sizeStr}) - ${item.description}`));
+ removedCount++;
+ removedSize += item.size;
+ } catch (err) {
+ const msg = err instanceof Error ? err.message : String(err);
+ output.writeln(output.error(` [failed] ${typeLabel} ${item.path} - ${msg}`));
+ }
+ }
+ }
+
+ // Summary
+ output.writeln();
+ output.writeln(output.bold('Summary:'));
+
+ if (dryRun) {
+ const actionable = found.filter(f => !f.skipped);
+ output.writeln(` Found ${actionable.length} artifact(s) totaling ${formatSize(totalSize)}`);
+ if (skippedCount > 0) {
+ output.writeln(` ${skippedCount} item(s) would be preserved (--keep-config)`);
+ }
+ output.writeln();
+ output.writeln(output.dim(' This was a dry run. Use --force to actually remove artifacts.'));
+ } else {
+ output.writeln(` Removed ${removedCount} artifact(s) totaling ${formatSize(removedSize)}`);
+ if (skippedCount > 0) {
+ output.writeln(` Preserved ${skippedCount} item(s) (--keep-config)`);
+ }
+ }
+
+ output.writeln();
+
+ return {
+ success: true,
+ message: dryRun
+ ? `Dry run: ${found.length} artifact(s) found`
+ : `Removed ${removedCount} artifact(s)`,
+ data: { found, removedCount, removedSize, dryRun },
+ };
+ },
+};
+
+export default cleanupCommand;
diff --git a/v3/@claude-flow/cli/src/commands/index.ts b/v3/@claude-flow/cli/src/commands/index.ts
index fa4aff016c..6b310040f9 100644
--- a/v3/@claude-flow/cli/src/commands/index.ts
+++ b/v3/@claude-flow/cli/src/commands/index.ts
@@ -72,6 +72,7 @@ const commandLoaders: Record<string, CommandLoader> = {
appliance: () => import('./appliance.js'),
'appliance-advanced': () => import('./appliance-advanced.js'),
'transfer-store': () => import('./transfer-store.js'),
+ cleanup: () => import('./cleanup.js'),
};
// Cache for loaded commands
@@ -148,6 +149,7 @@ import updateCommand from './update.js';
import { processCommand } from './process.js';
import { guidanceCommand } from './guidance.js';
import { applianceCommand } from './appliance.js';
+import { cleanupCommand } from './cleanup.js';
// Pre-populate cache with core commands
loadedCommands.set('init', initCommand);
@@ -169,6 +171,7 @@ loadedCommands.set('security', securityCommand);
loadedCommands.set('ruvector', ruvectorCommand);
loadedCommands.set('hive-mind', hiveMindCommand);
loadedCommands.set('guidance', guidanceCommand);
+loadedCommands.set('cleanup', cleanupCommand);
// =============================================================================
// Exports (maintain backwards compatibility)
@@ -195,6 +198,7 @@ export { ruvectorCommand } from './ruvector/index.js';
export { hiveMindCommand } from './hive-mind.js';
export { guidanceCommand } from './guidance.js';
export { applianceCommand } from './appliance.js';
+export { cleanupCommand } from './cleanup.js';
// Lazy-loaded command re-exports (for backwards compatibility, but async-only)
export async function getConfigCommand() { return loadCommand('config'); }
@@ -220,6 +224,7 @@ export async function getIssuesCommand() { return loadCommand('issues'); }
export async function getRuvectorCommand() { return loadCommand('ruvector'); }
export async function getGuidanceCommand() { return loadCommand('guidance'); }
export async function getApplianceCommand() { return loadCommand('appliance'); }
+export async function getCleanupCommand() { return loadCommand('cleanup'); }
/**
* Core commands loaded synchronously (available immediately)
@@ -246,6 +251,7 @@ export const commands: Command[] = [
ruvectorCommand,
hiveMindCommand,
guidanceCommand,
+ cleanupCommand,
];
/**
@@ -295,6 +301,7 @@ export const commandsByCategory = {
updateCommand,
processCommand,
applianceCommand,
+ cleanupCommand,
],
};
diff --git a/v3/@claude-flow/cli/src/memory/memory-initializer.ts b/v3/@claude-flow/cli/src/memory/memory-initializer.ts
index d13713f9b1..e98c647241 100644
--- a/v3/@claude-flow/cli/src/memory/memory-initializer.ts
+++ b/v3/@claude-flow/cli/src/memory/memory-initializer.ts
@@ -2222,13 +2222,20 @@ export async function searchEntries(options: {
const db = new SQL.Database(fileBuffer);
// Get entries with embeddings
- const entries = db.exec(`
- SELECT id, key, namespace, content, embedding
- FROM memory_entries
- WHERE status = 'active'
- ${namespace !== 'all' ? `AND namespace = '${namespace.replace(/'/g, "''")}'` : ''}
- LIMIT 1000
- `);
+ const searchStmt = db.prepare(
+ namespace !== 'all'
+ ? `SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' AND namespace = ? LIMIT 1000`
+ : `SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' LIMIT 1000`
+ );
+ if (namespace !== 'all') {
+ searchStmt.bind([namespace]);
+ }
+ const searchRows: unknown[][] = [];
+ while (searchStmt.step()) {
+ searchRows.push(searchStmt.get());
+ }
+ searchStmt.free();
+ const entries = searchRows.length > 0 ? [{ values: searchRows }] : [];
const results: { id: string; key: string; content: string; score: number; namespace: string }[] = [];
@@ -2369,24 +2376,37 @@ export async function listEntries(options: {
const db = new SQL.Database(fileBuffer);
// Get total count
- const countQuery = namespace
- ? `SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND namespace = '${namespace.replace(/'/g, "''")}'`
- : `SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`;
-
- const countResult = db.exec(countQuery);
+ const countStmt = namespace
+ ? db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND namespace = ?`)
+ : db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`);
+ if (namespace) {
+ countStmt.bind([namespace]);
+ }
+ const countRows: unknown[][] = [];
+ while (countStmt.step()) {
+ countRows.push(countStmt.get());
+ }
+ countStmt.free();
+ const countResult = countRows.length > 0 ? [{ values: countRows }] : [];
const total = countResult[0]?.values?.[0]?.[0] as number || 0;
// Get entries
- const listQuery = `
- SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at
- FROM memory_entries
- WHERE status = 'active'
- ${namespace ? `AND namespace = '${namespace.replace(/'/g, "''")}'` : ''}
- ORDER BY updated_at DESC
- LIMIT ${limit} OFFSET ${offset}
- `;
-
- const result = db.exec(listQuery);
+ const safeLimit = parseInt(String(limit), 10) || 100;
+ const safeOffset = parseInt(String(offset), 10) || 0;
+ const listStmt = namespace
+ ? db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' AND namespace = ? ORDER BY updated_at DESC LIMIT ? OFFSET ?`)
+ : db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' ORDER BY updated_at DESC LIMIT ? OFFSET ?`);
+ if (namespace) {
+ listStmt.bind([namespace, safeLimit, safeOffset]);
+ } else {
+ listStmt.bind([safeLimit, safeOffset]);
+ }
+ const listRows: unknown[][] = [];
+ while (listStmt.step()) {
+ listRows.push(listStmt.get());
+ }
+ listStmt.free();
+ const result = listRows.length > 0 ? [{ values: listRows }] : [];
const entries: {
id: string;
key: string;
@@ -2484,14 +2504,21 @@ export async function getEntry(options: {
const db = new SQL.Database(fileBuffer);
// Find entry by key
- const result = db.exec(`
+ const getStmt = db.prepare(`
SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
FROM memory_entries
WHERE status = 'active'
- AND key = '${key.replace(/'/g, "''")}'
- AND namespace = '${namespace.replace(/'/g, "''")}'
+ AND key = ?
+ AND namespace = ?
LIMIT 1
`);
+ getStmt.bind([key, namespace]);
+ const getRows: unknown[][] = [];
+ while (getStmt.step()) {
+ getRows.push(getStmt.get());
+ }
+ getStmt.free();
+ const result = getRows.length > 0 ? [{ values: getRows }] : [];
if (!result[0]?.values?.[0]) {
db.close();
@@ -2506,8 +2533,8 @@ export async function getEntry(options: {
db.run(`
UPDATE memory_entries
SET access_count = access_count + 1, last_accessed_at = strftime('%s', 'now') * 1000
- WHERE id = '${String(id).replace(/'/g, "''")}'
- `);
+ WHERE id = ?
+ `, [String(id)]);
// Save updated database
const data = db.export();
@@ -2603,13 +2630,20 @@ export async function deleteEntry(options: {
const db = new SQL.Database(fileBuffer);
// Check if entry exists first
- const checkResult = db.exec(`
+ const checkStmt = db.prepare(`
SELECT id FROM memory_entries
WHERE status = 'active'
- AND key = '${key.replace(/'/g, "''")}'
- AND namespace = '${namespace.replace(/'/g, "''")}'
+ AND key = ?
+ AND namespace = ?
LIMIT 1
`);
+ checkStmt.bind([key, namespace]);
+ const checkRows: unknown[][] = [];
+ while (checkStmt.step()) {
+ checkRows.push(checkStmt.get());
+ }
+ checkStmt.free();
+ const checkResult = checkRows.length > 0 ? [{ values: checkRows }] : [];
if (!checkResult[0]?.values?.[0]) {
// Get remaining count before closing
@@ -2636,10 +2670,10 @@ export async function deleteEntry(options: {
SET status = 'deleted',
embedding = NULL,
updated_at = strftime('%s', 'now') * 1000
- WHERE key = '${key.replace(/'/g, "''")}'
- AND namespace = '${namespace.replace(/'/g, "''")}'
+ WHERE key = ?
+ AND namespace = ?
AND status = 'active'
- `);
+ `, [key, namespace]);
// Get remaining count
const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
diff --git a/v3/@claude-flow/security/README.md b/v3/@claude-flow/security/README.md
index 00480bf654..64aa501e74 100644
--- a/v3/@claude-flow/security/README.md
+++ b/v3/@claude-flow/security/README.md
@@ -34,7 +34,7 @@ const security = createSecurityModule({
projectRoot: '/workspaces/project',
hmacSecret: process.env.HMAC_SECRET!,
bcryptRounds: 12,
- allowedCommands: ['git', 'npm', 'npx', 'node']
+ allowedCommands: ['git', 'npm', 'node']
});
// Hash a password
diff --git a/v3/@claude-flow/security/__tests__/acceptance/security-compliance.test.ts b/v3/@claude-flow/security/__tests__/acceptance/security-compliance.test.ts
index cb461a8645..4edab12305 100644
--- a/v3/@claude-flow/security/__tests__/acceptance/security-compliance.test.ts
+++ b/v3/@claude-flow/security/__tests__/acceptance/security-compliance.test.ts
@@ -668,7 +668,7 @@ describe('Security Compliance Acceptance', () => {
it('should have limited allowed commands', () => {
// Then
- expect(securityConfigs.strict.execution.allowedCommands).toEqual(['npm', 'npx', 'node', 'git']);
+ expect(securityConfigs.strict.execution.allowedCommands).toEqual(['npm', 'node', 'git']);
});
});
});
diff --git a/v3/@claude-flow/security/__tests__/fixtures/configurations.ts b/v3/@claude-flow/security/__tests__/fixtures/configurations.ts
index 48143b8da3..72e1cb448e 100644
--- a/v3/@claude-flow/security/__tests__/fixtures/configurations.ts
+++ b/v3/@claude-flow/security/__tests__/fixtures/configurations.ts
@@ -53,7 +53,7 @@ const strictConfig: SecurityConfig = {
execution: {
shell: false,
timeout: 30000,
- allowedCommands: ['npm', 'npx', 'node', 'git'],
+ allowedCommands: ['npm', 'node', 'git'],
blockedCommands: [
'rm',
'rmdir',
@@ -119,7 +119,7 @@ const developmentConfig: SecurityConfig = {
execution: {
shell: false,
timeout: 60000,
- allowedCommands: ['npm', 'npx', 'node', 'git', 'ls', 'cat', 'grep', 'find', 'echo'],
+ allowedCommands: ['npm', 'node', 'git', 'ls', 'cat', 'grep', 'find', 'echo'],
blockedCommands: ['rm', 'rmdir', 'del', 'format', 'mkfs', 'dd'],
},
paths: {
@@ -181,7 +181,7 @@ const cicdConfig: SecurityConfig = {
execution: {
shell: false,
timeout: 10000,
- allowedCommands: ['npm', 'npx', 'node', 'git', 'echo'],
+ allowedCommands: ['npm', 'node', 'git', 'echo'],
blockedCommands: ['rm', 'rmdir', 'del', 'format', 'mkfs', 'dd', 'chmod', 'chown'],
},
paths: {
diff --git a/v3/@claude-flow/security/__tests__/unit/safe-executor.test.ts b/v3/@claude-flow/security/__tests__/unit/safe-executor.test.ts
index f6dc9c496b..e3283f1851 100644
--- a/v3/@claude-flow/security/__tests__/unit/safe-executor.test.ts
+++ b/v3/@claude-flow/security/__tests__/unit/safe-executor.test.ts
@@ -320,7 +320,7 @@ describe('SafeExecutor', () => {
expect(result).toBe(true);
});
- it('should allow npx command', () => {
+ it('should block npx command', () => {
// Given
mockValidator.extractCommand.mockReturnValue('npx');
@@ -328,7 +328,7 @@ describe('SafeExecutor', () => {
const result = safeExecutor.isCommandAllowed('npx');
// Then
- expect(result).toBe(true);
+ expect(result).toBe(false);
});
it('should allow node command', () => {
diff --git a/v3/@claude-flow/security/src/domain/services/security-domain-service.ts b/v3/@claude-flow/security/src/domain/services/security-domain-service.ts
index 1754f0ed7b..be0b96c550 100644
--- a/v3/@claude-flow/security/src/domain/services/security-domain-service.ts
+++ b/v3/@claude-flow/security/src/domain/services/security-domain-service.ts
@@ -289,7 +289,7 @@ export class SecurityDomainService {
permissions,
allowedPaths: customPaths ?? ['./src', './tests', './docs'],
blockedPaths: ['/etc', '/var', '~/', '../'],
- allowedCommands: ['npm', 'npx', 'node', 'git', 'vitest'],
+ allowedCommands: ['npm', 'node', 'git', 'vitest'],
blockedCommands: ['rm -rf /', 'dd', 'mkfs', 'format'],
});
}
diff --git a/v3/@claude-flow/security/src/index.ts b/v3/@claude-flow/security/src/index.ts
index 44c91cdbdc..a22dad27b5 100644
--- a/v3/@claude-flow/security/src/index.ts
+++ b/v3/@claude-flow/security/src/index.ts
@@ -141,7 +141,7 @@ export interface SecurityModuleConfig {
/**
* Allowed commands for safe executor
- * Default: ['git', 'npm', 'npx', 'node']
+ * Default: ['git', 'npm', 'node']
*/
allowedCommands?: string[];
}
@@ -187,7 +187,7 @@ export function createSecurityModule(config: SecurityModuleConfig): SecurityModu
}),
credentialGenerator: new CredentialGenerator(),
safeExecutor: new SafeExecutor({
- allowedCommands: config.allowedCommands ?? ['git', 'npm', 'npx', 'node'],
+ allowedCommands: config.allowedCommands ?? ['git', 'npm', 'node'],
}),
pathValidator: new PathValidator({
allowedPrefixes: [config.projectRoot],
diff --git a/v3/@claude-flow/security/src/safe-executor.ts b/v3/@claude-flow/security/src/safe-executor.ts
index 8d8b2e0fc6..bce8124aa1 100644
--- a/v3/@claude-flow/security/src/safe-executor.ts
+++ b/v3/@claude-flow/security/src/safe-executor.ts
@@ -491,7 +491,6 @@ export function createDevelopmentExecutor(): SafeExecutor {
allowedCommands: [
'git',
'npm',
- 'npx',
'node',
'tsc',
'vitest',