@principles/pd-cli 1.75.0 → 1.76.0

package/tests/commands/runtime-features.test.ts

@@ -1,114 +1,249 @@
-import { describe, it, expect } from 'vitest';
+/**
+ * runtime-features tests — PRI-305
+ *
+ * Covers:
+ *   - JSON purity (single parseable JSON object)
+ *   - Missing config → defaults with nextAction
+ *   - Malformed config → fail loud with reason and nextAction
+ *   - Effective flags from .pd/config.yaml
+ *   - No secret output
+ *   - CLI handler: --json stdout purity and exit code
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-import { buildFeatureFlagsStatus } from '../../src/commands/runtime-features.js';
-import { loadEffectiveFeatureFlags } from '../../src/services/feature-flag-loader.js';
+import * as yaml from 'js-yaml';
+import { buildRuntimeFeaturesStatus, handleRuntimeFeaturesStatus, type RuntimeFeaturesOutput } from '../../src/commands/runtime-features.js';
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function mkTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-runtime-features-test-'));
+}
+
+function rmTmpDir(dir: string): void {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+function writeConfig(workspaceDir: string, content: string): void {
+  const configDir = path.join(workspaceDir, '.pd');
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.writeFileSync(path.join(configDir, 'config.yaml'), content, 'utf8');
+}
+
+function makeValidConfigYaml(): string {
+  return yaml.dump({
+    version: 1,
+    features: {
+      prompt: { category: 'core', enabled: true },
+      code_tool_hook: { category: 'core', enabled: true },
+      defer_archive: { category: 'core', enabled: true },
+      correction_observer: { category: 'quiet', enabled: false },
+      empathy_observer: { category: 'quiet', enabled: false },
+    },
+    runtimeProfiles: {
+      'openclaw.default': { type: 'openclaw', source: 'default' },
+    },
+    internalAgents: {
+      defaultRuntime: 'openclaw.default',
+      agents: {
+        diagnostician: { enabled: true },
+        dreamer: { enabled: true },
+        scribe: { enabled: true },
+        artificer: { enabled: true },
+        philosopher: { enabled: false },
+        evaluator: { enabled: false },
+        rolloutReviewer: { enabled: false },
+        trainer: { enabled: false },
+        correctionObserver: { enabled: false },
+        empathyObserver: { enabled: false },
+      },
+    },
+    ui: { diagnostics: { mode: 'simple' } },
+  });
+}
+
+// ── JSON purity ──────────────────────────────────────────────────────────────
+
+describe('JSON purity', () => {
+  it('output is a single parseable JSON object', () => {
+    const tmp = mkTmpDir();
+    try {
+      const output = buildRuntimeFeaturesStatus(tmp);
+      const json = JSON.stringify(output, null, 2);
+      const parsed = JSON.parse(json);
+      expect(typeof parsed).toBe('object');
+      expect(parsed).not.toBeNull();
+      expect(Array.isArray(parsed)).toBe(false);
+    } finally { rmTmpDir(tmp); }
+  });
+});
 
-describe('buildFeatureFlagsStatus', () => {
-  it('returns status ok with clean config (no config file)', () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
+// ── Missing config → defaults ────────────────────────────────────────────────
+
+describe('Missing config → defaults', () => {
+  it('returns status=ok with source=defaults when config file is absent', () => {
+    const tmp = mkTmpDir();
     try {
-      const output = buildFeatureFlagsStatus(tmpDir);
+      const output = buildRuntimeFeaturesStatus(tmp);
       expect(output.status).toBe('ok');
-      expect(output.reason).toBeUndefined();
-      expect(output.nextAction).toBeUndefined();
-      expect(output.warnings).toEqual([]);
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
+      expect(output.source).toBe('defaults');
+      expect(output.enabledMvpChannels).toContain('prompt');
+      expect(output.enabledMvpChannels).toContain('code_tool_hook');
+      expect(output.enabledMvpChannels).toContain('defer_archive');
+    } finally { rmTmpDir(tmp); }
   });
+});
 
-  it('returns status degraded with reason/nextAction when warnings present', () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
-    const configDir = path.join(tmpDir, '.pd');
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(path.join(configDir, 'feature-flags.yaml'), 'gfi:\n  enabled: "yes"\n', 'utf8');
+// ── Malformed config → fail loud ────────────────────────────────────────────
 
+describe('Malformed config → fail loud', () => {
+  it('returns status=failed with reason and nextAction for YAML parse error', () => {
+    const tmp = mkTmpDir();
+    writeConfig(tmp, 'version: [unterminated');
     try {
-      const output = buildFeatureFlagsStatus(tmpDir);
-      expect(output.status).toBe('degraded');
-      expect(output.reason).toBeDefined();
-      expect(output.nextAction).toBeDefined();
-      expect(output.warnings.length).toBeGreaterThan(0);
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
+      const output = buildRuntimeFeaturesStatus(tmp);
+      expect(output.status).toBe('failed');
+      expect(output.source).toBe('malformed');
+      expect(output.reason).toBeTruthy();
+      expect(output.nextAction).toBeTruthy();
+      expect(output.errors).toBeDefined();
+      expect(output.errors!.length).toBeGreaterThan(0);
+    } finally { rmTmpDir(tmp); }
   });
 
-  it('JSON output contains all required fields', () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
+  it('returns status=failed for invalid version', () => {
+    const tmp = mkTmpDir();
+    writeConfig(tmp, yaml.dump({ version: 99, features: {}, runtimeProfiles: {}, internalAgents: { defaultRuntime: 'x', agents: {} } }));
     try {
-      const output = buildFeatureFlagsStatus(tmpDir);
-      const json = JSON.stringify(output);
-      const parsed = JSON.parse(json);
+      const output = buildRuntimeFeaturesStatus(tmp);
+      expect(output.status).toBe('failed');
+      expect(output.source).toBe('malformed');
+    } finally { rmTmpDir(tmp); }
+  });
+});
+
+// ── Valid config → effective flags ───────────────────────────────────────────
 
-      expect(parsed.status).toBe('ok');
-      expect(parsed.source).toBe('defaults');
-      expect(parsed.configPath).toBeTruthy();
-      expect(parsed.flags).toBeInstanceOf(Array);
-      expect(parsed.warnings).toBeInstanceOf(Array);
-      expect(typeof parsed.totalFlags).toBe('number');
-      expect(typeof parsed.enabledCount).toBe('number');
-      expect(typeof parsed.disabledCount).toBe('number');
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
+describe('Valid config → effective flags', () => {
+  it('returns status=ok with source=user_config for valid config', () => {
+    const tmp = mkTmpDir();
+    writeConfig(tmp, makeValidConfigYaml());
+    try {
+      const output = buildRuntimeFeaturesStatus(tmp);
+      expect(output.status).toBe('ok');
+      expect(output.source).toBe('user_config');
+      expect(output.enabledMvpChannels).toContain('prompt');
+    } finally { rmTmpDir(tmp); }
+  });
+
+  it('shows all feature flags with category and enabled status', () => {
+    const tmp = mkTmpDir();
+    writeConfig(tmp, makeValidConfigYaml());
+    try {
+      const output = buildRuntimeFeaturesStatus(tmp);
+      expect(output.features.length).toBeGreaterThan(0);
+      const promptFlag = output.features.find(f => f.id === 'prompt');
+      expect(promptFlag).toBeDefined();
+      expect(promptFlag!.category).toBe('core');
+      expect(promptFlag!.enabled).toBe(true);
+    } finally { rmTmpDir(tmp); }
+  });
+
+  it('counts enabled and disabled correctly', () => {
+    const tmp = mkTmpDir();
+    writeConfig(tmp, makeValidConfigYaml());
+    try {
+      const output = buildRuntimeFeaturesStatus(tmp);
+      expect(output.totalFlags).toBeGreaterThan(0);
+      expect(output.enabledCount + output.disabledCount).toBe(output.totalFlags);
+    } finally { rmTmpDir(tmp); }
   });
 });
 
-describe('YAML loader integration', () => {
-  it('rejects __proto__ key in YAML', () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
-    const configDir = path.join(tmpDir, '.pd');
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(configDir, 'feature-flags.yaml'),
-      '"__proto__":\n  enabled: true\n',
-      'utf8',
-    );
+// ── No secret output ─────────────────────────────────────────────────────────
 
+describe('No secret output', () => {
+  it('output never contains raw API key values', () => {
+    const tmp = mkTmpDir();
+    writeConfig(tmp, makeValidConfigYaml());
     try {
-      const result = loadEffectiveFeatureFlags(tmpDir);
-      expect(result.warnings.some(w => w.includes('__proto__'))).toBe(true);
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
+      const output = buildRuntimeFeaturesStatus(tmp);
+      const json = JSON.stringify(output);
+      expect(json).not.toContain('sk-ant-');
+      expect(json).not.toContain('"apiKey"');
+      expect(json).not.toContain('"gatewayToken"');
+    } finally { rmTmpDir(tmp); }
+  });
+});
+
+// ── CLI handler: --json stdout purity and exit code ──────────────────────────
+
+describe('CLI handler: --json stdout purity and exit code', () => {
+  let stdoutSpy: ReturnType<typeof vi.spyOn>;
+  let originalExitCode: number | undefined;
+
+  beforeEach(() => {
+    stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    originalExitCode = process.exitCode;
+    process.exitCode = undefined;
+  });
+
+  afterEach(() => {
+    stdoutSpy.mockRestore();
+    process.exitCode = originalExitCode;
   });
 
-  it('handles malformed YAML gracefully', () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
-    const configDir = path.join(tmpDir, '.pd');
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(path.join(configDir, 'feature-flags.yaml'), 'gfi: [unterminated', 'utf8');
+  it('--json outputs exactly one parseable JSON object to stdout', async () => {
+    const tmp = mkTmpDir();
+    try {
+      await handleRuntimeFeaturesStatus({ workspace: tmp, json: true });
+      expect(stdoutSpy).toHaveBeenCalledTimes(1);
+      const output = stdoutSpy.mock.calls[0][0] as string;
+      const parsed = JSON.parse(output);
+      expect(typeof parsed).toBe('object');
+      expect(parsed).not.toBeNull();
+      expect(Array.isArray(parsed)).toBe(false);
+      // Verify key fields exist
+      expect(parsed).toHaveProperty('status');
+      expect(parsed).toHaveProperty('source');
+      expect(parsed).toHaveProperty('features');
+    } finally { rmTmpDir(tmp); }
+  });
 
+  it('--json sets process.exitCode=1 on failed status', async () => {
+    const tmp = mkTmpDir();
+    writeConfig(tmp, 'version: [unterminated');
     try {
-      const result = loadEffectiveFeatureFlags(tmpDir);
-      expect(result.warnings.some(w => w.includes('YAML'))).toBe(true);
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
+      await handleRuntimeFeaturesStatus({ workspace: tmp, json: true });
+      expect(process.exitCode).toBe(1);
+      // Verify the JSON output still parses
+      const output = stdoutSpy.mock.calls[0][0] as string;
+      const parsed = JSON.parse(output);
+      expect(parsed.status).toBe('failed');
+      expect(parsed.reason).toBeTruthy();
+      expect(parsed.nextAction).toBeTruthy();
+    } finally { rmTmpDir(tmp); }
   });
 
-  it('enables GFI via valid YAML config', () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-features-test-'));
-    const configDir = path.join(tmpDir, '.pd');
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(configDir, 'feature-flags.yaml'),
-      'gfi:\n  enabled: true\n',
-      'utf8',
-    );
+  it('--json does not set exitCode=1 on ok status', async () => {
+    const tmp = mkTmpDir();
+    try {
+      await handleRuntimeFeaturesStatus({ workspace: tmp, json: true });
+      expect(process.exitCode).toBeUndefined();
+    } finally { rmTmpDir(tmp); }
+  });
 
+  it('--json output contains no extra stdout lines (no banners, headers)', async () => {
+    const tmp = mkTmpDir();
     try {
-      const result = loadEffectiveFeatureFlags(tmpDir);
-      expect(result.flags.gfi).toBeDefined();
-      if (result.flags.gfi) {
-        expect(result.flags.gfi.enabled).toBe(true);
-      }
-      expect(result.source).toBe('workspace_file');
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
+      await handleRuntimeFeaturesStatus({ workspace: tmp, json: true });
+      expect(stdoutSpy).toHaveBeenCalledTimes(1);
+      const output = stdoutSpy.mock.calls[0][0] as string;
+      // Must parse as single JSON object — no leading/trailing non-JSON
+      expect(() => JSON.parse(output)).not.toThrow();
+    } finally { rmTmpDir(tmp); }
   });
 });