@principles/pd-cli 1.73.0

package/tests/services/feature-flag-loader.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  loadEffectiveFeatureFlags,
+  getFeatureFlagsConfigPath,
+  FEATURE_FLAGS_CONFIG_FILENAME,
+  FEATURE_FLAGS_CONFIG_DIR,
+} from '../../src/services/feature-flag-loader.js';
+
+function createTempWorkspace(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-ffl-test-'));
+}
+
+function writeConfig(tmpDir: string, content: string): void {
+  const configDir = path.join(tmpDir, FEATURE_FLAGS_CONFIG_DIR);
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.writeFileSync(path.join(configDir, FEATURE_FLAGS_CONFIG_FILENAME), content, 'utf8');
+}
+
+function cleanup(tmpDir: string): void {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+}
+
+describe('feature-flag-loader', () => {
+  describe('getFeatureFlagsConfigPath', () => {
+    it('should return path under .pd/feature-flags.yaml', () => {
+      const result = getFeatureFlagsConfigPath('/workspace/project');
+      expect(result).toBe(path.join('/workspace/project', '.pd', 'feature-flags.yaml'));
+    });
+
+    it('should use FEATURE_FLAGS_CONFIG_DIR and FEATURE_FLAGS_CONFIG_FILENAME constants', () => {
+      const result = getFeatureFlagsConfigPath('/root');
+      expect(result).toContain(FEATURE_FLAGS_CONFIG_DIR);
+      expect(result).toContain(FEATURE_FLAGS_CONFIG_FILENAME);
+    });
+  });
+
+  describe('loadEffectiveFeatureFlags', () => {
+    it('should return defaults when config file does not exist', () => {
+      const tmpDir = createTempWorkspace();
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.source).toBe('defaults');
+        expect(result.warnings).toEqual([]);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should return defaults with YAML parse error warning for malformed YAML', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, 'gfi: [unterminated');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.warnings.some(w => w.includes('YAML parse error'))).toBe(true);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should return defaults with mapping warning when YAML contains an array', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, '- item1\n- item2\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.warnings.some(w => w.includes('expected a mapping'))).toBe(true);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should return defaults with mapping warning when YAML contains null', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, '---\nnull\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.warnings.some(w => w.includes('expected a mapping'))).toBe(true);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should return defaults with mapping warning when YAML is undefined after parse', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, '---\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.source).toBe('defaults');
+        expect(result.warnings.some(w => w.includes('expected a mapping'))).toBe(true);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should return defaults with mapping warning when YAML contains a scalar string', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, 'just a string\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.warnings.some(w => w.includes('expected a mapping'))).toBe(true);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should return defaults with mapping warning when YAML contains a number', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, '42\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.warnings.some(w => w.includes('expected a mapping'))).toBe(true);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should reject __proto__ dangerous key', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, '"__proto__":\n  enabled: true\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.warnings.some(w => w.includes("dangerous key '__proto__' rejected"))).toBe(true);
+        expect(Object.hasOwn(result.flags, '__proto__')).toBe(false);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should reject constructor dangerous key', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, 'constructor:\n  enabled: true\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.warnings.some(w => w.includes("dangerous key 'constructor' rejected"))).toBe(true);
+        expect(Object.hasOwn(result.flags, 'constructor')).toBe(false);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should reject prototype dangerous key', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, 'prototype:\n  enabled: true\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.warnings.some(w => w.includes("dangerous key 'prototype' rejected"))).toBe(true);
+        expect(Object.hasOwn(result.flags, 'prototype')).toBe(false);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should allow valid keys while rejecting dangerous ones', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, 'gfi:\n  enabled: true\nprototype:\n  enabled: true\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.warnings.some(w => w.includes("dangerous key 'prototype' rejected"))).toBe(true);
+        expect(result.flags.gfi).toBeDefined();
+        if (result.flags.gfi) {
+          expect(result.flags.gfi.enabled).toBe(true);
+        }
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should parse valid YAML config and set source to workspace_file', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, 'gfi:\n  enabled: true\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.source).toBe('workspace_file');
+        expect(result.flags.gfi).toBeDefined();
+        if (result.flags.gfi) {
+          expect(result.flags.gfi.enabled).toBe(true);
+        }
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should handle empty YAML mapping with defaults source', () => {
+      const tmpDir = createTempWorkspace();
+      writeConfig(tmpDir, '{}\n');
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.source).toBe('defaults');
+        expect(result.warnings).toEqual([]);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    it('should include configPath in result', () => {
+      const tmpDir = createTempWorkspace();
+      try {
+        const result = loadEffectiveFeatureFlags(tmpDir);
+        expect(result.configPath).toContain(FEATURE_FLAGS_CONFIG_FILENAME);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+  });
+});

package/tests/services/proven-channel-baseline-runner.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import * as path from 'path';
+import * as os from 'os';
+import { isProductionWorkspace } from '../../src/services/proven-channel-baseline-runner.js';
+
+describe('isProductionWorkspace (real implementation)', () => {
+  it('blocks exact production workspace path', () => {
+    const homedirWorkspace = path.join(os.homedir(), '.openclaw', 'workspace');
+    expect(isProductionWorkspace(homedirWorkspace)).toBe(true);
+  });
+
+  it('blocks descendant of production workspace', () => {
+    const homedirWorkspace = path.join(os.homedir(), '.openclaw', 'workspace', 'my-project');
+    expect(isProductionWorkspace(homedirWorkspace)).toBe(true);
+  });
+
+  it('does NOT block sibling path with different prefix', () => {
+    const sibling = path.join(os.homedir(), '.openclaw', 'workspace-extra');
+    expect(isProductionWorkspace(sibling)).toBe(false);
+  });
+
+  it('does NOT block unrelated path', () => {
+    expect(isProductionWorkspace('C:\\Users\\test\\project')).toBe(false);
+  });
+
+  it('does NOT block temp directory', () => {
+    const tmp = os.tmpdir();
+    expect(isProductionWorkspace(tmp)).toBe(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "types": ["node"],
+    "paths": {
+      "@principles/core/runtime-v2/*": ["../principles-core/dist/runtime-v2/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}