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(config): apply CLI daemon settings without persisting defaults

Rudy Celeklif080556eb51a
diff --git a/v3/@claude-flow/cli/__tests__/config-set-daemon.test.ts b/v3/@claude-flow/cli/__tests__/config-set-daemon.test.ts
new file mode 100644
index 0000000000..194f5b06b2
--- /dev/null
+++ b/v3/@claude-flow/cli/__tests__/config-set-daemon.test.ts
@@ -0,0 +1,85 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { configCommand } from '../src/commands/config.js';
+import { configManager, ConfigFileManager } from '../src/services/config-file-manager.js';
+import { WorkerDaemon } from '../src/services/worker-daemon.js';
+import { CommandParser } from '../src/parser.js';
+
+vi.mock('../src/output.js', () => ({ output: { writeln: vi.fn(), printError: vi.fn() } }));
+vi.mock('../src/prompt.js', () => ({ select: vi.fn(), input: vi.fn() }));
+
+let cwd: string;
+const set = configCommand.subcommands!.find(command => command.name === 'set')!;
+const readDaemon = (dir: string) => (WorkerDaemon.prototype as any).readDaemonConfigFromFile(join(dir, '.claude-flow'));
+
+beforeEach(() => {
+ cwd = mkdtempSync(join(tmpdir(), 'config-daemon-'));
+ vi.stubEnv('CLAUDE_FLOW_CONFIG', '');
+ configManager.load(cwd);
+});
+afterEach(() => {
+ vi.unstubAllEnvs();
+ rmSync(cwd, { recursive: true, force: true });
+});
+
+async function run(...args: string[]) {
+ const parser = new CommandParser();
+ parser.registerCommand(configCommand);
+ const parsed = parser.parse(['config', 'set', ...args]);
+ expect(parser.validateFlags(parsed.flags, set)).toEqual([]);
+ return set.action!({ cwd, args: parsed.positional, flags: parsed.flags, interactive: false });
+}
+
+describe('CLI config set reaches daemon settings', () => {
+ it.each([
+ ['-k', 'daemon.idleSecs', '-v', '0'],
+ ['--key=daemon.idleSecs', '--value=0'],
+ ['daemon.idleSecs', '0'],
+ ])('accepts zero via %j', async (...args) => {
+ expect((await run(...args))?.success).toBe(true);
+ expect(readDaemon(cwd).idleShutdownMs).toBe(0);
+ });
+
+ it('writes only explicit keys so setting the daemon does not relocate memory', async () => {
+ expect((await run('daemon.resourceThresholds.minFreeMemoryPercent', '2'))?.success).toBe(true);
+ expect(JSON.parse(readFileSync(configManager.getConfigPath()!, 'utf8'))).toEqual({
+ daemon: { resourceThresholds: { minFreeMemoryPercent: 2 } },
+ });
+ expect(readDaemon(cwd).minFreeMemoryPercent).toBe(2);
+ });
+
+ it('reads nested updates to an existing .claude-flow config', () => {
+ mkdirSync(join(cwd, '.claude-flow'));
+ writeFileSync(join(cwd, '.claude-flow/config.json'), JSON.stringify({ unrelated: true }));
+ const manager = new ConfigFileManager();
+ manager.set(cwd, 'daemon.ttlSecs', 600);
+ manager.set(cwd, 'daemon.autoStart', false);
+ expect(readDaemon(cwd)).toMatchObject({ ttlMs: 600_000, autoStart: false });
+ expect(manager.get(cwd, 'unrelated')).toBe(true);
+ });
+
+ it('updates an existing flat key instead of leaving a conflicting nested value', () => {
+ mkdirSync(join(cwd, '.claude-flow'));
+ writeFileSync(join(cwd, '.claude-flow/config.json'), JSON.stringify({ 'daemon.idleSecs': 60 }));
+ const manager = new ConfigFileManager();
+ manager.set(cwd, 'daemon.idleSecs', 0);
+ expect(manager.get(cwd, 'daemon.idleSecs')).toBe(0);
+ expect(readDaemon(cwd).idleShutdownMs).toBe(0);
+ });
+
+ it('rejects an absent value without writing a config', async () => {
+ expect((await run('--key', 'daemon.idleSecs'))?.success).toBe(false);
+ expect(configManager.getConfigPath()).toBeNull();
+ });
+
+ it('preserves flat scoped settings and zero/false precedence', () => {
+ mkdirSync(join(cwd, '.claude-flow'));
+ writeFileSync(join(cwd, '.claude-flow/config.json'), JSON.stringify({
+ daemon: { idleSecs: 60, autoStart: true },
+ scopes: { project: { 'daemon.idleSecs': 0, 'daemon.autoStart': false } },
+ }));
+ expect(readDaemon(cwd)).toMatchObject({ idleShutdownMs: 0, autoStart: false });
+ });
+});
diff --git a/v3/@claude-flow/cli/src/commands/config.ts b/v3/@claude-flow/cli/src/commands/config.ts
index 2f07e78635..83f1b49cb8 100644
--- a/v3/@claude-flow/cli/src/commands/config.ts
+++ b/v3/@claude-flow/cli/src/commands/config.ts
@@ -136,15 +136,13 @@ const setCommand: Command = {
name: 'key',
short: 'k',
description: 'Configuration key',
- type: 'string',
- required: true
+ type: 'string'
},
{
name: 'value',
short: 'v',
description: 'Configuration value',
- type: 'string',
- required: true
+ type: 'string'
}
],
examples: [
@@ -152,8 +150,8 @@ const setCommand: Command = {
{ command: 'claude-flow config set -k memory.backend -v agentdb', description: 'Set memory backend' }
],
action: async (ctx: CommandContext): Promise<CommandResult> => {
- const key = ctx.flags.key as string || ctx.args[0];
- const value = ctx.flags.value as string || ctx.args[1];
+ const key = (ctx.flags.key ?? ctx.args[0]) as string | undefined;
+ const value = ctx.flags.value ?? ctx.args[1];
if (!key || value === undefined) {
output.printError('Both key and value are required');
@@ -161,7 +159,7 @@ const setCommand: Command = {
}
try {
- const parsedValue = parseConfigValue(value);
+ const parsedValue = parseConfigValue(String(value));
configManager.set(ctx.cwd, key, parsedValue);
output.writeln(`Set ${key} = ${value}`);
return { success: true };
diff --git a/v3/@claude-flow/cli/src/services/config-file-manager.ts b/v3/@claude-flow/cli/src/services/config-file-manager.ts
index d789c4f6e8..411968283f 100644
--- a/v3/@claude-flow/cli/src/services/config-file-manager.ts
+++ b/v3/@claude-flow/cli/src/services/config-file-manager.ts
@@ -105,13 +105,19 @@ export class ConfigFileManager {
/** Get a nested config value by dot-separated key */
get(cwd: string, key: string): unknown {
const config = this.getConfig(cwd);
- return getNestedValue(config, key);
+ return Object.hasOwn(config, key) ? config[key] : getNestedValue(config, key);
}
/** Set a nested config value by dot-separated key */
set(cwd: string, key: string, value: unknown): void {
- const config = this.getConfig(cwd);
- setNestedValue(config, key, value);
+ // A targeted update must not persist unrelated defaults (notably the
+ // default memory path, which would relocate an existing memory store).
+ const config = this.config ?? this.load(cwd) ?? {};
+ if (Object.hasOwn(config, key)) {
+ config[key] = value;
+ } else {
+ setNestedValue(config, key, value);
+ }
this.config = config;
const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
this.writeAtomic(targetPath, config);
diff --git a/v3/@claude-flow/cli/src/services/worker-daemon.ts b/v3/@claude-flow/cli/src/services/worker-daemon.ts
index a0bc90787d..d781dfe2bc 100644
--- a/v3/@claude-flow/cli/src/services/worker-daemon.ts
+++ b/v3/@claude-flow/cli/src/services/worker-daemon.ts
@@ -11,6 +11,7 @@
* - testgaps: Test coverage analysis (20 min interval)
*/
+import { ConfigFileManager } from './config-file-manager.js';
import { EventEmitter } from 'events';
import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync, unlinkSync, renameSync } from 'fs';
import { cpus } from 'os';
@@ -478,8 +479,8 @@ export class WorkerDaemon extends EventEmitter {
}
/**
- * Read daemon-specific config from .claude-flow/config.{json,yaml,yml}.
- * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'.
+ * Read daemon-specific config from CLI JSON paths or .claude-flow/config.{yaml,yml}.
+ * Supports dotted and nested keys like 'daemon.resourceThresholds.maxCpuLoad'.
* #1844: prefer JSON when both exist (existing behavior) but fall back
* to YAML so operators using the v3 canonical YAML format aren't silently
* ignored. The chosen path (or a parse warning) is returned rather than
@@ -502,7 +503,8 @@ export class WorkerDaemon extends EventEmitter {
configSourcePath?: string;
yamlParseWarning?: string;
} {
- const jsonPath = join(claudeFlowDir, 'config.json');
+ // Share the CLI's JSON search order, including root and explicit config files.
+ const jsonPath = new ConfigFileManager().findConfig(join(claudeFlowDir, '..'));
const yamlPath = join(claudeFlowDir, 'config.yaml');
const ymlPath = join(claudeFlowDir, 'config.yml');
@@ -510,7 +512,7 @@ export class WorkerDaemon extends EventEmitter {
let raw: Record<string, any> | undefined;
let chosenPath: string | undefined;
- if (existsSync(jsonPath)) {
+ if (jsonPath) {
try {
raw = JSON.parse(readFileSync(jsonPath, 'utf-8'));
chosenPath = jsonPath;
@@ -541,21 +543,28 @@ export class WorkerDaemon extends EventEmitter {
}
try {
- // Support both flat keys at root and nested under scopes.project
- const cfg = raw?.scopes?.project ?? raw;
- const rawCpuLoad = cfg['daemon.resourceThresholds.maxCpuLoad'] ?? raw['daemon.resourceThresholds.maxCpuLoad'];
- const rawMinMem = cfg['daemon.resourceThresholds.minFreeMemoryPercent'] ?? raw['daemon.resourceThresholds.minFreeMemoryPercent'];
- const rawMaxConcurrent = cfg['daemon.maxConcurrent'] ?? raw['daemon.maxConcurrent'];
- const rawTimeout = cfg['daemon.workerTimeoutMs'] ?? raw['daemon.workerTimeoutMs'];
+ // The CLI writes nested objects; legacy files use dotted keys. Scoped
+ // values retain precedence, including explicit false and zero.
+ const read = (obj: Record<string, any> | undefined, key: string): unknown => {
+ if (!obj) return undefined;
+ return obj[key] ?? key.split('.').reduce((value, part) =>
+ value && typeof value === 'object' && Object.hasOwn(value, part) ? value[part] : undefined, obj as any);
+ };
+ const get = (key: string) => read(raw?.scopes?.project, key) ?? read(raw, key);
+ const rawAutoStart = get('daemon.autoStart');
+ const rawCpuLoad = get('daemon.resourceThresholds.maxCpuLoad');
+ const rawMinMem = get('daemon.resourceThresholds.minFreeMemoryPercent');
+ const rawMaxConcurrent = get('daemon.maxConcurrent');
+ const rawTimeout = get('daemon.workerTimeoutMs');
// #2356 — lifecycle limits are configured in SECONDS in config.json
// (`daemon.ttlSecs` / `daemon.idleSecs`) for parity with the CLI flag
// and env var; stored internally as ms. An explicit 0 disables.
- const rawTtl = cfg['daemon.ttlSecs'] ?? raw['daemon.ttlSecs'];
- const rawIdle = cfg['daemon.idleSecs'] ?? raw['daemon.idleSecs'];
+ const rawTtl = get('daemon.ttlSecs');
+ const rawIdle = get('daemon.idleSecs');
// #2661 — explicit opt-in for scheduled AI workers.
- const rawAiEnabled = cfg['daemon.aiWorkers.enabled'] ?? raw['daemon.aiWorkers.enabled'];
+ const rawAiEnabled = get('daemon.aiWorkers.enabled');
return {
- autoStart: typeof raw['daemon.autoStart'] === 'boolean' ? raw['daemon.autoStart'] : undefined,
+ autoStart: typeof rawAutoStart === 'boolean' ? rawAutoStart : undefined,
maxConcurrent: (typeof rawMaxConcurrent === 'number' && rawMaxConcurrent > 0) ? rawMaxConcurrent : undefined,
workerTimeoutMs: (typeof rawTimeout === 'number' && rawTimeout > 0) ? rawTimeout : undefined,
maxCpuLoad: (typeof rawCpuLoad === 'number' && rawCpuLoad > 0 && rawCpuLoad < 1000) ? rawCpuLoad : undefined,