claude-dev-env 7.7.0 → 8.0.0

package/bin/install-pstack-plugin.test.mjs

@@ -0,0 +1,181 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import {
+    PSTACK_MARKETPLACE_REPOSITORY,
+    PSTACK_PLUGIN_HOSTS,
+    PSTACK_PLUGIN_IDENTIFIER,
+    hostCommandInvocation,
+    installPstackPlugin,
+    pstackPluginPlan,
+    shouldInstallPstackPlugin,
+} from './install-pstack-plugin.mjs';
+
+function recordingRunner(outcomeForCommand = () => ({ status: 0, stderr: '' })) {
+    const calls = [];
+    return {
+        calls,
+        runCommand(executable, commandArguments, options) {
+            calls.push({ executable, commandArguments, environment: options.environment });
+            return outcomeForCommand(executable, commandArguments);
+        },
+    };
+}
+
+const ROOTS = Object.freeze({
+    claudeRoot: '/managed/.claude',
+    codexHome: '/managed/.codex',
+    environment: {},
+});
+
+const WINDOWS_ENVIRONMENT = Object.freeze({ ComSpec: 'C:\\Windows\\system32\\cmd.exe' });
+
+test('the Claude plan carries the two documented plugin commands', () => {
+    const plan = pstackPluginPlan('claude');
+    assert.equal(plan.executable, 'claude');
+    assert.deepEqual(plan.commands, [
+        ['plugin', 'marketplace', 'add', PSTACK_MARKETPLACE_REPOSITORY],
+        ['plugin', 'install', PSTACK_PLUGIN_IDENTIFIER],
+    ]);
+});
+
+test('the Codex plan adds the plugin with the Codex verb', () => {
+    const plan = pstackPluginPlan('codex');
+    assert.equal(plan.executable, 'codex');
+    assert.deepEqual(plan.commands, [
+        ['plugin', 'marketplace', 'add', PSTACK_MARKETPLACE_REPOSITORY],
+        ['plugin', 'add', PSTACK_PLUGIN_IDENTIFIER],
+    ]);
+});
+
+test('an unsupported host names the hosts this installer knows', () => {
+    assert.throws(() => pstackPluginPlan('cursor'), /cursor/);
+    assert.deepEqual(PSTACK_PLUGIN_HOSTS, ['claude', 'codex']);
+});
+
+test('each host installs into the managed root this run wrote', () => {
+    const runner = recordingRunner();
+    const outcome = installPstackPlugin(ROOTS, runner);
+    assert.equal(outcome.status, 'installed');
+    assert.deepEqual(runner.calls.map(call => [call.executable, ...call.commandArguments]), [
+        ['claude', 'plugin', 'marketplace', 'add', PSTACK_MARKETPLACE_REPOSITORY],
+        ['claude', 'plugin', 'install', PSTACK_PLUGIN_IDENTIFIER],
+        ['codex', 'plugin', 'marketplace', 'add', PSTACK_MARKETPLACE_REPOSITORY],
+        ['codex', 'plugin', 'add', PSTACK_PLUGIN_IDENTIFIER],
+    ]);
+    assert.equal(runner.calls[0].environment.CLAUDE_CONFIG_DIR, ROOTS.claudeRoot);
+    assert.equal(runner.calls[2].environment.CODEX_HOME, ROOTS.codexHome);
+});
+
+test('an absent host command skips that host and leaves the other installed', () => {
+    const runner = recordingRunner((executable) => (executable === 'codex'
+        ? { status: null, error: Object.assign(new Error('spawn codex ENOENT'), { code: 'ENOENT' }) }
+        : { status: 0, stderr: '' }));
+    const outcome = installPstackPlugin(ROOTS, runner);
+    assert.equal(outcome.hosts.find(host => host.host === 'claude').status, 'installed');
+    const codex = outcome.hosts.find(host => host.host === 'codex');
+    assert.equal(codex.status, 'skipped');
+    assert.match(codex.warning, /codex/);
+    assert.equal(runner.calls.filter(call => call.executable === 'codex').length, 1);
+});
+
+test('a failing command reports that host and still installs the next one', () => {
+    const runner = recordingRunner((executable, commandArguments) => (
+        executable === 'claude' && commandArguments[1] === 'marketplace'
+            ? { status: 1, stderr: 'marketplace unreachable' }
+            : { status: 0, stderr: '' }));
+    const outcome = installPstackPlugin(ROOTS, runner);
+    assert.equal(outcome.status, 'failed');
+    const claude = outcome.hosts.find(host => host.host === 'claude');
+    assert.equal(claude.status, 'failed');
+    assert.match(claude.warning, /marketplace unreachable/);
+    assert.equal(outcome.hosts.find(host => host.host === 'codex').status, 'installed');
+    assert.equal(runner.calls.filter(call => call.executable === 'claude').length, 1);
+});
+
+test('an executable override replaces the host command for that host only', () => {
+    const runner = recordingRunner();
+    installPstackPlugin(
+        { ...ROOTS, environment: { CDE_CODEX_EXECUTABLE: '/opt/codex/bin/codex' } },
+        runner,
+    );
+    assert.deepEqual([...new Set(runner.calls.map(call => call.executable))], [
+        'claude',
+        '/opt/codex/bin/codex',
+    ]);
+});
+
+test('the opt-out flag and variable both turn the step off', () => {
+    assert.equal(shouldInstallPstackPlugin([], {}), true);
+    assert.equal(shouldInstallPstackPlugin(['--no-pstack'], {}), false);
+    assert.equal(shouldInstallPstackPlugin([], { CDE_INSTALL_PSTACK: '0' }), false);
+    assert.equal(shouldInstallPstackPlugin([], { CDE_INSTALL_PSTACK: '1' }), true);
+});
+
+test('a selected host list installs only that host', () => {
+    const runner = recordingRunner();
+    const outcome = installPstackPlugin({ ...ROOTS, hosts: ['codex'] }, runner);
+    assert.deepEqual(outcome.hosts.map(host => host.host), ['codex']);
+    assert.deepEqual([...new Set(runner.calls.map(call => call.executable))], ['codex']);
+});
+
+test('a non-Windows platform launches the host command directly', () => {
+    const invocation = hostCommandInvocation('claude', ['plugin', 'install', PSTACK_PLUGIN_IDENTIFIER], 'linux');
+    assert.deepEqual(invocation, {
+        file: 'claude',
+        args: ['plugin', 'install', PSTACK_PLUGIN_IDENTIFIER],
+        windowsVerbatimArguments: false,
+    });
+});
+
+test('Windows launches the host command through cmd.exe, which alone can run a .cmd shim', () => {
+    const invocation = hostCommandInvocation(
+        'claude', ['plugin', 'install', PSTACK_PLUGIN_IDENTIFIER], 'win32', WINDOWS_ENVIRONMENT,
+    );
+    assert.equal(invocation.file, WINDOWS_ENVIRONMENT.ComSpec);
+    assert.deepEqual(invocation.args, [
+        '/d',
+        '/s',
+        '/c',
+        `""claude" plugin install ${PSTACK_PLUGIN_IDENTIFIER}"`,
+    ]);
+    assert.equal(invocation.windowsVerbatimArguments, true);
+});
+
+test('a Windows executable path holding a space stays one quoted token', () => {
+    const invocation = hostCommandInvocation(
+        'C:\\Program Files\\nodejs\\claude.cmd',
+        ['plugin', 'marketplace', 'add', PSTACK_MARKETPLACE_REPOSITORY],
+        'win32',
+        WINDOWS_ENVIRONMENT,
+    );
+    assert.equal(
+        invocation.args.at(-1),
+        `""C:\\Program Files\\nodejs\\claude.cmd" plugin marketplace add ${PSTACK_MARKETPLACE_REPOSITORY}"`,
+    );
+});
+
+test('a Windows environment without ComSpec falls back to the bare shell name', () => {
+    const invocation = hostCommandInvocation('claude', ['plugin'], 'win32', {});
+    assert.equal(invocation.file, 'cmd.exe');
+});
+
+test("cmd.exe's command-not-found exit code reads as an absent host, not a failure", () => {
+    const runner = recordingRunner((executable) => (executable === 'codex'
+        ? {
+            status: 9009,
+            stderr: "'codex' is not recognized as an internal or external command,\noperable program or batch file.",
+        }
+        : { status: 0, stderr: '' }));
+    const outcome = installPstackPlugin(ROOTS, runner);
+    const codex = outcome.hosts.find(host => host.host === 'codex');
+    assert.equal(codex.status, 'skipped');
+    assert.equal(outcome.status, 'installed');
+    assert.equal(runner.calls.filter(call => call.executable === 'codex').length, 1);
+});
+
+test('a non-zero exit that is not command-not-found still reads as a failure', () => {
+    const runner = recordingRunner(() => ({ status: 9009, stderr: 'the marketplace rejected the catalog' }));
+    const outcome = installPstackPlugin({ ...ROOTS, hosts: ['claude'] }, runner);
+    assert.equal(outcome.hosts[0].status, 'failed');
+    assert.match(outcome.hosts[0].warning, /rejected the catalog/);
+});

package/bin/install.agents-home.test.mjs

@@ -53,10 +53,6 @@ const CLEAN_CODER_POLICY_REFERENCES = [
         '<managed-root>/rules/code-standards.md',
         'packages/claude-dev-env/rules/code-standards.md',
     ],
-    [
-        '<managed-root>/rules/file-global-constants.md',
-        'packages/claude-dev-env/rules/file-global-constants.md',
-    ],
     [
         '<managed-root>/rules/windows-filesystem-safe.md',
         'packages/claude-dev-env/rules/windows-filesystem-safe.md',

package/bin/install.codex-rules.test.mjs

@@ -118,6 +118,11 @@ test('resolveInstallRoot names ~/.codex/rules and allows files under it', () =>
     });
     const expectedDirectory = join(homeDirectory, DEFAULT_CODEX_DIRECTORY_NAME, CODEX_RULES_DIRECTORY_NAME);
     assert.equal(resolution.codexRulesInstallDirectory, expectedDirectory);
+    assert.equal(
+        resolution.codexHomeDirectory,
+        join(homeDirectory, DEFAULT_CODEX_DIRECTORY_NAME),
+        'the pstack plugin step installs into this Codex home',
+    );
     assert.equal(
         isAllowedInstallDestination(join(expectedDirectory, CODEX_RULES_SHIPPED_FILE_NAME), resolution),
         true,
@@ -140,6 +145,7 @@ test('CODEX_HOME relocates the Codex rules destination', () => {
         resolution.codexRulesInstallDirectory,
         join(relocatedHome, CODEX_RULES_DIRECTORY_NAME),
     );
+    assert.equal(resolution.codexHomeDirectory, relocatedHome);
 });
 
 test('a full install copies shipped Codex rules and leaves a local default.rules in place', () => {

package/bin/install.cursor-rules.test.mjs

@@ -43,13 +43,6 @@ function runInstaller(homeDirectory, extraArguments, environmentOverrides = {})
     });
 }
 
-function runSelector(selectorPath, selectionInput) {
-    return JSON.parse(execFileSync('node', [selectorPath], {
-        encoding: 'utf8',
-        input: JSON.stringify(selectionInput),
-    }));
-}
-
 test('resolveInstallRoot names ~/.cursor/rules and allows generated mdc files under it', () => {
     const homeDirectory = join(tmpdir(), 'cdev-cursor-rules-home');
     const resolution = resolveInstallRoot({
@@ -111,246 +104,22 @@ test('--only journal is rejected before Cursor rules change; --only core writes
             CURSOR_RULES_DIRECTORY_NAME,
             'asd-ste100-language.mdc',
         );
-        const preferencePath = join(
-            homeDirectory,
-            '.agents',
-            'rules',
-            'pstack-model-preferences.codex.json',
-        );
+        const policyPath = join(homeDirectory, '.agents', 'rules', 'subagent-model-policy.json');
         assert.throws(
             () => runInstaller(homeDirectory, ['--only', 'journal']),
             error => error.status === 1 && /Unknown group\(s\): journal/.test(error.stderr),
         );
         assert.equal(existsSync(generatedPath), false);
-        assert.equal(existsSync(preferencePath), false);
+        assert.equal(existsSync(policyPath), false);
 
         runInstaller(homeDirectory, ['--only', 'core']);
         assert.equal(existsSync(generatedPath), true);
-        assert.equal(existsSync(preferencePath), true);
+        assert.equal(existsSync(policyPath), true);
     } finally {
         rmSync(homeDirectory, { recursive: true, force: true });
     }
 });
 
-for (const targetName of [null, 'profile']) {
-    test('pstack rules survive reinstall and sync for ' + (targetName ?? 'main'), () => {
-        const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-pstack-'));
-        try {
-            const targetArguments = targetName
-                ? ['--target', join(homeDirectory, targetName)]
-                : [];
-            const resolution = resolveInstallRoot({
-                homeDirectory,
-                environment: {},
-                explicitTarget: targetName ? join(homeDirectory, targetName) : null,
-            });
-            const sharedPath = join(resolution.agentsHome, 'rules', 'pstack-models.mdc');
-            const cursorPath = join(resolution.cursorRulesInstallDirectory, 'pstack-models.mdc');
-            const preferencesPath = join(
-                resolution.agentsHome,
-                'rules',
-                'pstack-model-preferences.codex.json',
-            );
-            const policyPath = join(
-                resolution.agentsHome,
-                'rules',
-                'subagent-model-policy.json',
-            );
-            const selectorPath = join(
-                resolution.agentsHome,
-                'scripts',
-                'select_pstack_models.mjs',
-            );
-            const managedSelectorPath = join(
-                resolution.managedRoot,
-                'scripts',
-                'select_pstack_models.mjs',
-            );
-            runInstaller(homeDirectory, [...targetArguments, '--only', 'core']);
-
-            const installedText = readFileSync(sharedPath, 'utf8');
-            assert.doesNotMatch(installedText, /gpt-|claude-|grok-/i);
-            assert.match(installedText, /feature, refactoring: reliable code execution/);
-            assert.match(installedText, /interrogate reviewers: independent adversarial review/);
-            assert.match(installedText, /alwaysApply: true/);
-            assert.match(installedText, /replaces the fixed model defaults in pstack skills/);
-            assert.match(installedText, /Run the installed selector once for each agent/);
-            assert.equal(readFileSync(cursorPath, 'utf8'), installedText);
-            assert.equal(isAllowedInstallDestination(sharedPath, resolution), true);
-            assert.equal(existsSync(selectorPath), true);
-            assert.equal(existsSync(policyPath), true);
-
-            const savedPreferences = JSON.parse(readFileSync(preferencesPath, 'utf8'));
-            assert.deepEqual(savedPreferences, {
-                host: 'codex',
-                defaultEffort: 'medium',
-                modelsByRole: {
-                    'feature, refactoring': ['gpt-5.6-sol'],
-                    'bug-fix': ['gpt-5.6-sol'],
-                    'perf-issue': ['gpt-6-astra'],
-                    hillclimb: ['gpt-6-astra'],
-                    'judgment and prose': ['gpt-6-astra'],
-                    'hardest tasks': ['gpt-6-astra'],
-                    'how explorer': ['gpt-5.6-terra'],
-                    'how explainer': ['gpt-5.6-sol'],
-                    'how critics': ['gpt-5.6-terra', 'gpt-5.6-sol', 'gpt-6-astra'],
-                    'why investigators': ['gpt-5.6-terra'],
-                    'why synthesizer': ['gpt-6-astra'],
-                    'reflect tooling': ['gpt-5.6-sol'],
-                    'reflect judgment, divergent, synthesizer': ['gpt-6-astra'],
-                    'arena runners': ['gpt-5.6-terra', 'gpt-5.6-sol', 'gpt-6-astra'],
-                    'arena cross-judge pool': ['gpt-5.6-sol', 'gpt-6-astra'],
-                    'swarm workers': ['gpt-5.6-luna'],
-                    'architect runners': ['gpt-5.6-sol', 'gpt-6-astra'],
-                    'interrogate reviewers': [
-                        'gpt-5.6-terra',
-                        'gpt-5.6-sol',
-                        'gpt-6-astra',
-                    ],
-                },
-            });
-            for (const role of Object.keys(savedPreferences.modelsByRole)) {
-                assert.equal(installedText.includes(role + ':'), true);
-            }
-            const codexSelection = runSelector(selectorPath, {
-                host: 'codex',
-                inventoryHost: 'codex',
-                role: 'feature, refactoring',
-                delegationIndex: 0,
-                availableModelIds: ['gpt-5.6-sol'],
-                confirmedSuitableModelIds: [],
-                parentFallback: {
-                    isAllowed: false,
-                    hasMaterialCapabilityLoss: false,
-                },
-            });
-            assert.equal(codexSelection.canDelegate, false);
-            assert.equal(codexSelection.failure, 'no-supported-model');
-            assert.deepEqual(codexSelection.nativeSpawnArguments, {});
-
-            const claudePreferencesPath = join(
-                resolution.agentsHome,
-                'rules',
-                'pstack-model-preferences.claude.json',
-            );
-            const seededClaudePreferences = JSON.parse(
-                readFileSync(claudePreferencesPath, 'utf8'),
-            );
-            assert.deepEqual(seededClaudePreferences, {
-                host: 'claude',
-                modelsByRole: {
-                    'feature, refactoring': ['opus'],
-                    'bug-fix': ['opus'],
-                    'perf-issue': ['fable'],
-                    hillclimb: ['fable'],
-                    'judgment and prose': ['fable'],
-                    'hardest tasks': ['fable'],
-                    'how explorer': ['sonnet'],
-                    'how explainer': ['opus'],
-                    'how critics': ['sonnet', 'opus', 'fable'],
-                    'why investigators': ['sonnet'],
-                    'why synthesizer': ['fable'],
-                    'reflect tooling': ['opus'],
-                    'reflect judgment, divergent, synthesizer': ['fable'],
-                    'arena runners': ['sonnet', 'opus', 'fable'],
-                    'arena cross-judge pool': ['opus', 'fable'],
-                    'swarm workers': ['sonnet'],
-                    'architect runners': ['opus', 'fable'],
-                    'interrogate reviewers': ['sonnet', 'opus', 'fable'],
-                },
-            });
-            const claudeSelection = runSelector(selectorPath, {
-                host: 'claude',
-                inventoryHost: 'claude',
-                role: 'swarm workers',
-                delegationIndex: 0,
-                availableModelIds: ['sonnet', 'opus', 'fable'],
-                confirmedSuitableModelIds: [],
-                parentFallback: {
-                    isAllowed: false,
-                    hasMaterialCapabilityLoss: false,
-                },
-            });
-            assert.deepEqual(claudeSelection.nativeSpawnArguments, {
-                model: 'sonnet',
-            });
-
-            writeFileSync(claudePreferencesPath, JSON.stringify({
-                host: 'claude',
-                modelsByRole: {
-                    'feature, refactoring': ['confirmed-claude-model'],
-                },
-            }));
-            const editedClaudeSelection = runSelector(selectorPath, {
-                host: 'claude',
-                inventoryHost: 'claude',
-                role: 'feature, refactoring',
-                delegationIndex: 0,
-                availableModelIds: ['confirmed-claude-model'],
-                confirmedSuitableModelIds: [],
-                parentFallback: {
-                    isAllowed: false,
-                    hasMaterialCapabilityLoss: false,
-                },
-            });
-            assert.deepEqual(editedClaudeSelection.nativeSpawnArguments, {
-                model: 'confirmed-claude-model',
-            });
-
-            const manifest = JSON.parse(readFileSync(resolution.manifestFilePath, 'utf8'));
-            assert.equal(manifest.files.includes(sharedPath), true);
-            assert.equal(manifest.files.includes(managedSelectorPath), true);
-            assert.equal(manifest.files.includes(preferencesPath), false);
-            assert.equal(manifest.files.includes(claudePreferencesPath), false);
-
-            writeFileSync(sharedPath, 'stale');
-            writeFileSync(preferencesPath, JSON.stringify({
-                host: 'codex',
-                modelsByRole: {
-                    'feature, refactoring': ['user-edited-codex-model'],
-                },
-            }));
-            runInstaller(homeDirectory, [...targetArguments, '--only', 'core']);
-            assert.equal(readFileSync(sharedPath, 'utf8'), installedText);
-            assert.deepEqual(
-                JSON.parse(readFileSync(preferencesPath, 'utf8'))
-                    .modelsByRole['feature, refactoring'],
-                ['user-edited-codex-model'],
-            );
-            assert.deepEqual(
-                JSON.parse(readFileSync(claudePreferencesPath, 'utf8'))
-                    .modelsByRole['feature, refactoring'],
-                ['confirmed-claude-model'],
-            );
-
-            const syncArguments = [
-                join(resolution.managedRoot, 'scripts', 'sync_to_cursor.py'),
-                '--claude-root', resolution.managedRoot,
-                '--cursor-root', resolution.cursorInstallDirectory,
-                '--quiet',
-            ];
-            execFileSync('python', syncArguments);
-            execFileSync('python', [...syncArguments, '--check']);
-            assert.equal(readFileSync(cursorPath, 'utf8'), installedText);
-            assert.equal(readFileSync(sharedPath, 'utf8'), installedText);
-            if (targetName) {
-                assert.equal(
-                    existsSync(join(homeDirectory, '.agents', 'rules', 'pstack-models.mdc')),
-                    false,
-                );
-            }
-
-            runInstaller(homeDirectory, [...targetArguments, '--uninstall']);
-            assert.equal(existsSync(sharedPath), false);
-            assert.equal(existsSync(cursorPath), false);
-            assert.equal(existsSync(selectorPath), false);
-            assert.equal(existsSync(preferencesPath), true);
-            assert.equal(existsSync(claudePreferencesPath), true);
-        } finally {
-            rmSync(homeDirectory, { recursive: true, force: true });
-        }
-    });
-}
 
 test('seeds one editable policy and one native Codex routing hook', () => {
     const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-routing-install-'));
@@ -667,22 +436,3 @@ test('a blocked shared rule destination rolls back generated Cursor files', () =
     }
 });
 
-test('a failed install rolls back newly seeded host preference files', () => {
-    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-pstack-seed-rollback-'));
-    try {
-        const preferencesDirectory = join(homeDirectory, '.agents', 'rules');
-        assert.throws(() => runInstaller(
-            homeDirectory,
-            ['--only', 'core'],
-            { CLAUDE_DEV_ENV_INSTALL_FAULT: 'after_file_staging' },
-        ));
-        for (const hostName of ['claude', 'codex']) {
-            assert.equal(
-                existsSync(join(preferencesDirectory, 'pstack-model-preferences.' + hostName + '.json')),
-                false,
-            );
-        }
-    } finally {
-        rmSync(homeDirectory, { recursive: true, force: true });
-    }
-});