@agenthippo-ai/agenthippo 0.1.0

package/out/test/engine-integration.test.js

@@ -0,0 +1,297 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Engine Integration Tests
+ *
+ * These tests actually run the engines with real API calls.
+ * They verify that agent-scoped config directories are used correctly.
+ *
+ * Requirements:
+ *   - AGENTHIPPO_INTEGRATION_TEST=1 to enable (legacy: AGENTIDE_INTEGRATION_TEST)
+ *   - ANTHROPIC_API_KEY or CLAUDE_API_KEY for Claude tests
+ *   - OPENAI_API_KEY for Codex tests
+ *
+ * Run with:
+ *   cd extensions/agentide && npm run compile && \
+ *   AGENTHIPPO_INTEGRATION_TEST=1 ANTHROPIC_API_KEY=sk-... \
+ *     node ../../node_modules/mocha/bin/mocha ./out/test/engine-integration.test.js --timeout 120000
+ */
+require("mocha");
+const branding_1 = require("../branding");
+const INTEGRATION_ENABLED = process.env.AGENTHIPPO_INTEGRATION_TEST === '1' ||
+    process.env.AGENTIDE_INTEGRATION_TEST === '1';
+// Only register tests when integration testing is enabled
+// This avoids "pending" noise in normal test runs
+if (INTEGRATION_ENABLED) {
+    const assert = require('assert');
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    // Shim vscode for engine modules that import it
+    const Module = require('module');
+    const originalRequire = Module.prototype.require;
+    const fakeVscode = {
+        window: {
+            showInformationMessage: () => undefined,
+            showErrorMessage: () => undefined,
+        },
+        workspace: {
+            getConfiguration: () => ({
+                get: (_key, defaultValue) => defaultValue,
+                inspect: (_key) => undefined,
+            }),
+        },
+        commands: {
+            executeCommand: async () => undefined,
+        },
+    };
+    Module.prototype.require = function (request) {
+        if (request === 'vscode') {
+            return fakeVscode;
+        }
+        return originalRequire.apply(this, arguments);
+    };
+    // Dynamic imports after stubbing vscode
+    const { ClaudeEngine } = require('../engines/claude');
+    const { CodexEngine } = require('../engines/codex');
+    const { resolveAgentRuntimePaths } = require('../agentpack/paths');
+    const { createTestAgentYaml } = require('./helpers/manifest-fixtures');
+    const CLAUDE_API_KEY = process.env.ANTHROPIC_API_KEY ||
+        process.env.CLAUDE_API_KEY ||
+        process.env.AGENTHIPPO_LITELLM_API_KEY ||
+        process.env.AGENTIDE_LITELLM_API_KEY;
+    const OPENAI_API_KEY = process.env.OPENAI_API_KEY ||
+        process.env.AGENTHIPPO_LITELLM_API_KEY ||
+        process.env.AGENTIDE_LITELLM_API_KEY;
+    const LITELLM_BASE_URL = process.env.AGENTHIPPO_LITELLM_BASE_URL ||
+        process.env.AGENTIDE_LITELLM_BASE_URL ||
+        'https://localhost:4443';
+    // -------------------------------------------------------------------------
+    // Helper Functions
+    // -------------------------------------------------------------------------
+    function makeTempWorkspace() {
+        return fs.mkdtempSync(path.join(os.tmpdir(), `${branding_1.AGENTIDE_CLI_NAME}-integration-`));
+    }
+    function makeAgent(workspaceRoot, agentId, engine, modelId) {
+        const runtimePaths = resolveAgentRuntimePaths(workspaceRoot, workspaceRoot, agentId);
+        const agentRoot = runtimePaths.agentRoot;
+        fs.mkdirSync(agentRoot, { recursive: true });
+        fs.writeFileSync(path.join(agentRoot, 'AGENTS.md'), `# ${agentId} Agent\n\nA test agent for integration testing.\n`, 'utf8');
+        const agentYaml = createTestAgentYaml({
+            name: agentId,
+            version: '0.1.0',
+            engine,
+            model: modelId,
+            includeSkills: true,
+            fileAccess: 'workspace-write',
+            visibility: 'internal',
+        });
+        fs.writeFileSync(path.join(agentRoot, 'agent.yaml'), agentYaml, 'utf8');
+        return {
+            agentRoot,
+            claudeConfigDir: runtimePaths.claudeConfigDir,
+            codexHome: runtimePaths.codexHome,
+        };
+    }
+    function createOutputChannel() {
+        const lines = [];
+        return {
+            lines,
+            appendLine: (msg) => {
+                lines.push(msg);
+                if (process.env.DEBUG_INTEGRATION) {
+                    console.log(msg);
+                }
+            },
+            show: () => { },
+        };
+    }
+    function createRuntimeContext(output) {
+        return {
+            logger: {
+                debug: (msg) => output.appendLine(msg),
+                info: (msg) => output.appendLine(msg),
+                warn: (msg) => output.appendLine(`Warning: ${msg}`),
+                error: (msg, err) => output.appendLine(`Error: ${msg}${err ? `: ${err.message}` : ''}`),
+            },
+            editTracker: undefined,
+            configProvider: undefined,
+        };
+    }
+    function createStreamEmitter() {
+        const chunks = [];
+        const emitter = {
+            progress: async (msg) => { chunks.push({ type: 'progress', content: msg }); },
+            thinking: async (msg) => { chunks.push({ type: 'thinking', content: msg }); },
+            message: async (msg) => { chunks.push({ type: 'message', content: msg }); },
+            error: async (msg) => { chunks.push({ type: 'error', content: msg }); },
+            done: async () => { chunks.push({ type: 'done', content: '' }); },
+            text: async (msg) => { chunks.push({ type: 'text', content: msg }); },
+            markdown: async (msg) => { chunks.push({ type: 'markdown', content: msg }); },
+            toolStart: async (name, input, id) => {
+                chunks.push({ type: 'toolStart', content: `${name}:${input || ''}:${id || ''}` });
+            },
+        };
+        return { emitter, chunks };
+    }
+    // -------------------------------------------------------------------------
+    // Claude Engine Integration Tests
+    // -------------------------------------------------------------------------
+    suite('Claude Engine Integration', function () {
+        this.timeout(120000);
+        if (!CLAUDE_API_KEY) {
+            console.log('[Claude tests] Skipped: no ANTHROPIC_API_KEY or CLAUDE_API_KEY');
+            return;
+        }
+        test('sends prompt and uses agent-scoped CLAUDE_CONFIG_DIR', async () => {
+            const workspaceRoot = makeTempWorkspace();
+            const agentId = 'integration-test-claude';
+            const { claudeConfigDir } = makeAgent(workspaceRoot, agentId, 'claude', 'claude-sonnet-4-5-20250929');
+            const workspaceClaude = path.join(workspaceRoot, '.claude');
+            if (fs.existsSync(workspaceClaude)) {
+                fs.rmSync(workspaceClaude, { recursive: true, force: true });
+            }
+            const output = createOutputChannel();
+            const { emitter, chunks } = createStreamEmitter();
+            const engine = new ClaudeEngine({ storagePath: workspaceRoot, codexHome: undefined, claudeConfigDir: undefined, litellmApiKey: CLAUDE_API_KEY, litellmBaseUrl: LITELLM_BASE_URL }, async () => 'integration-test-signature', () => undefined);
+            const opts = {
+                agentPackId: agentId,
+                workspaceRoot,
+                additionalDirectories: [],
+                modelId: 'claude-sonnet-4-5-20250929',
+                sessionId: `integration-${Date.now()}`,
+                apiKey: CLAUDE_API_KEY,
+                useLiteLLM: true,
+            };
+            await engine.stream('Reply with exactly: INTEGRATION_TEST_OK', opts, emitter, createRuntimeContext(output), new AbortController().signal);
+            assert.ok(fs.existsSync(claudeConfigDir), `Agent CLAUDE_CONFIG_DIR should exist: ${claudeConfigDir}`);
+            const hasAgentDirLog = output.lines.some((line) => line.includes('CLAUDE_CONFIG_DIR') && line.includes(agentId));
+            assert.ok(hasAgentDirLog, 'Output should log agent-scoped CLAUDE_CONFIG_DIR');
+            const textChunks = chunks.filter((c) => c.type === 'text');
+            assert.ok(textChunks.length > 0, 'Should receive text response from Claude');
+            const fullResponse = textChunks.map((c) => c.content).join('');
+            assert.ok(fullResponse.includes('INTEGRATION_TEST_OK'), `Response should contain INTEGRATION_TEST_OK, got: ${fullResponse.slice(0, 200)}`);
+            // Cleanup: dispose engine to close SDK sessions
+            engine.dispose();
+            try {
+                fs.rmSync(workspaceRoot, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        });
+        test('default agent uses default-scoped directory', async () => {
+            const workspaceRoot = makeTempWorkspace();
+            const defaultPaths = resolveAgentRuntimePaths(workspaceRoot, workspaceRoot, 'default');
+            const output = createOutputChannel();
+            const { emitter, chunks } = createStreamEmitter();
+            const engine = new ClaudeEngine({ storagePath: workspaceRoot, codexHome: undefined, claudeConfigDir: undefined, litellmApiKey: CLAUDE_API_KEY, litellmBaseUrl: LITELLM_BASE_URL }, async () => 'integration-test-signature', () => undefined);
+            const opts = {
+                workspaceRoot,
+                additionalDirectories: [],
+                modelId: 'claude-sonnet-4-5-20250929',
+                sessionId: `integration-default-${Date.now()}`,
+                apiKey: CLAUDE_API_KEY,
+                useLiteLLM: true,
+            };
+            await engine.stream('Reply with exactly: DEFAULT_MODE_OK', opts, emitter, createRuntimeContext(output), new AbortController().signal);
+            assert.ok(fs.existsSync(defaultPaths.claudeConfigDir), `Default CLAUDE_CONFIG_DIR should exist: ${defaultPaths.claudeConfigDir}`);
+            const textChunks = chunks.filter((c) => c.type === 'text');
+            const fullResponse = textChunks.map((c) => c.content).join('');
+            assert.ok(fullResponse.includes('DEFAULT_MODE_OK'), `Response should contain DEFAULT_MODE_OK, got: ${fullResponse.slice(0, 200)}`);
+            // Cleanup: dispose engine to close SDK sessions
+            engine.dispose();
+            try {
+                fs.rmSync(workspaceRoot, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Codex Engine Integration Tests
+    // -------------------------------------------------------------------------
+    suite('Codex Engine Integration', function () {
+        this.timeout(120000);
+        if (!OPENAI_API_KEY) {
+            console.log('[Codex tests] Skipped: no OPENAI_API_KEY');
+            return;
+        }
+        test('writes config into agent-scoped CODEX_HOME', async () => {
+            const workspaceRoot = makeTempWorkspace();
+            const agentId = 'integration-test-codex';
+            const { codexHome } = makeAgent(workspaceRoot, agentId, 'codex', 'gpt-4o');
+            const workspaceCodex = path.join(workspaceRoot, '.codex');
+            if (fs.existsSync(workspaceCodex)) {
+                fs.rmSync(workspaceCodex, { recursive: true, force: true });
+            }
+            const output = createOutputChannel();
+            const engine = new CodexEngine({ storagePath: workspaceRoot, codexHome: undefined, claudeConfigDir: undefined, litellmApiKey: CLAUDE_API_KEY, litellmBaseUrl: LITELLM_BASE_URL }, () => undefined, () => undefined);
+            await engine.ensureCodexConfig(false, undefined, 'gpt-4o', workspaceRoot, [], output, codexHome, agentId);
+            const configPath = path.join(codexHome, 'config.toml');
+            assert.ok(fs.existsSync(configPath), `config.toml should exist in agent CODEX_HOME: ${codexHome}`);
+            const configContent = fs.readFileSync(configPath, 'utf8');
+            const instructionsMatch = configContent.match(/model_instructions_file\s*=\s*"([^"]+)"/);
+            assert.ok(instructionsMatch, `config.toml should include model_instructions_file, got:\n${configContent}`);
+            const instructionsPath = instructionsMatch?.[1];
+            assert.ok(instructionsPath && fs.existsSync(instructionsPath), `model_instructions_file should exist: ${instructionsPath ?? 'missing'}`);
+            const instructionsContent = fs.readFileSync(instructionsPath, 'utf8');
+            assert.ok(instructionsContent.includes(`# ${agentId} Agent`), 'Instructions file should include AGENTS.md content');
+            try {
+                fs.rmSync(workspaceRoot, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Multi-Agent Isolation Tests
+    // -------------------------------------------------------------------------
+    suite('Multi-Agent Isolation', function () {
+        this.timeout(180000);
+        if (!CLAUDE_API_KEY) {
+            console.log('[Multi-Agent tests] Skipped: no ANTHROPIC_API_KEY or CLAUDE_API_KEY');
+            return;
+        }
+        test('different agents use isolated config directories', async () => {
+            const workspaceRoot = makeTempWorkspace();
+            const agentA = makeAgent(workspaceRoot, 'agent-alpha', 'claude', 'claude-sonnet-4-5-20250929');
+            const agentB = makeAgent(workspaceRoot, 'agent-beta', 'claude', 'claude-sonnet-4-5-20250929');
+            const engine = new ClaudeEngine({ storagePath: workspaceRoot, codexHome: undefined, claudeConfigDir: undefined, litellmApiKey: CLAUDE_API_KEY, litellmBaseUrl: LITELLM_BASE_URL }, async () => 'integration-test-signature', () => undefined);
+            const outputA = createOutputChannel();
+            const { emitter: emitterA } = createStreamEmitter();
+            await engine.stream('Reply: AGENT_ALPHA', {
+                agentPackId: 'agent-alpha',
+                workspaceRoot,
+                additionalDirectories: [],
+                modelId: 'claude-sonnet-4-5-20250929',
+                sessionId: `agent-alpha-${Date.now()}`,
+                apiKey: CLAUDE_API_KEY,
+                useLiteLLM: true,
+            }, emitterA, createRuntimeContext(outputA), new AbortController().signal);
+            const outputB = createOutputChannel();
+            const { emitter: emitterB } = createStreamEmitter();
+            await engine.stream('Reply: AGENT_BETA', {
+                agentPackId: 'agent-beta',
+                workspaceRoot,
+                additionalDirectories: [],
+                modelId: 'claude-sonnet-4-5-20250929',
+                sessionId: `agent-beta-${Date.now()}`,
+                apiKey: CLAUDE_API_KEY,
+                useLiteLLM: true,
+            }, emitterB, createRuntimeContext(outputB), new AbortController().signal);
+            assert.ok(fs.existsSync(agentA.claudeConfigDir), `Agent alpha CLAUDE_CONFIG_DIR should exist`);
+            assert.ok(fs.existsSync(agentB.claudeConfigDir), `Agent beta CLAUDE_CONFIG_DIR should exist`);
+            assert.notStrictEqual(agentA.claudeConfigDir, agentB.claudeConfigDir, 'Agent config dirs should be different');
+            const hasAgentALog = outputA.lines.some((line) => line.includes('CLAUDE_CONFIG_DIR') && line.includes('agent-alpha'));
+            const hasAgentBLog = outputB.lines.some((line) => line.includes('CLAUDE_CONFIG_DIR') && line.includes('agent-beta'));
+            assert.ok(hasAgentALog, 'Agent alpha output should log its config dir');
+            assert.ok(hasAgentBLog, 'Agent beta output should log its config dir');
+            // Cleanup: dispose engine to close SDK sessions
+            engine.dispose();
+            try {
+                fs.rmSync(workspaceRoot, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        });
+    });
+} // end if (INTEGRATION_ENABLED)

package/out/test/enginePaths.test.js

@@ -0,0 +1,195 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Engine Paths Unit Tests
+ *
+ * Tests the path resolution logic for engine config directories.
+ * These are pure unit tests that don't require API keys or network access.
+ *
+ * For integration tests that actually run engines, see engine-integration.test.ts
+ */
+require("mocha");
+const assert = __importStar(require("assert"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// Shim vscode for engine modules that import it
+const Module = require('module');
+const originalRequire = Module.prototype.require;
+const fakeVscode = {
+    window: {
+        showInformationMessage: () => undefined,
+        showErrorMessage: () => undefined,
+    },
+    workspace: {
+        getConfiguration: () => ({
+            get: (_key, defaultValue) => defaultValue,
+            inspect: (_key) => undefined,
+        }),
+    },
+    commands: {
+        executeCommand: async () => undefined,
+    },
+};
+Module.prototype.require = function (request) {
+    if (request === 'vscode') {
+        return fakeVscode;
+    }
+    // Stub SDK to prevent accidental real calls
+    if (request.includes('@anthropic-ai/claude-agent-sdk')) {
+        return {
+            Client: class {
+                constructor(_opts) { }
+            },
+            query: () => { throw new Error('SDK should not be called in unit tests'); },
+        };
+    }
+    return originalRequire.apply(this, arguments);
+};
+// Import after stubbing vscode
+const codex_1 = require("../engines/codex");
+const paths_1 = require("../agentpack/paths");
+const logger_1 = require("../runtime/interfaces/logger");
+// -----------------------------------------------------------------------------
+// Helper Functions
+// -----------------------------------------------------------------------------
+const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agentide-engine-paths-'));
+function makeTempWorkspace() {
+    return fs.mkdtempSync(path.join(tmpRoot, 'ws-'));
+}
+function makeSkill(dir, name) {
+    const skillDir = path.join(dir, 'skills', name);
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# test skill', 'utf8');
+}
+// -----------------------------------------------------------------------------
+// Path Resolution Tests
+// -----------------------------------------------------------------------------
+suite('Engine Path Resolution', () => {
+    test('agent paths resolve claudeConfigDir isolated per agent', () => {
+        const workspaceRoot = '/Users/test/project';
+        const storageUri = '/Users/test/.vscode/storage';
+        const agentId = 'my-agent';
+        const paths = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, agentId);
+        assert.ok(paths.claudeConfigDir.includes(agentId), `claudeConfigDir should contain agentId: ${paths.claudeConfigDir}`);
+        assert.ok(paths.claudeConfigDir.includes(paths_1.AGENT_CONSTANTS.AGENTS_DIR), `claudeConfigDir should be under agents dir: ${paths.claudeConfigDir}`);
+    });
+    test('agent paths resolve codexHome isolated per agent', () => {
+        const workspaceRoot = '/Users/test/project';
+        const storageUri = '/Users/test/.vscode/storage';
+        const agentId = 'my-agent';
+        const paths = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, agentId);
+        assert.ok(paths.codexHome.includes(agentId), `codexHome should contain agentId: ${paths.codexHome}`);
+        assert.ok(paths.codexHome.includes(paths_1.AGENT_CONSTANTS.AGENTS_DIR), `codexHome should be under agents dir: ${paths.codexHome}`);
+    });
+    test('default agent uses agents/default path', () => {
+        const workspaceRoot = '/Users/test/project';
+        const storageUri = '/Users/test/.vscode/storage';
+        const paths = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'default');
+        assert.ok(paths.claudeConfigDir.includes('default'), `claudeConfigDir should include 'default': ${paths.claudeConfigDir}`);
+        assert.ok(paths.codexHome.includes('default'), `codexHome should include 'default': ${paths.codexHome}`);
+        assert.ok(paths.agentRoot.includes('agents/default') || paths.agentRoot.includes('agents\\default'), `agentRoot should be under agents/default: ${paths.agentRoot}`);
+    });
+    test('different agents have isolated config directories', () => {
+        const workspaceRoot = '/Users/test/project';
+        const storageUri = '/Users/test/.vscode/storage';
+        const agentA = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'agent-a');
+        const agentB = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'agent-b');
+        assert.notStrictEqual(agentA.claudeConfigDir, agentB.claudeConfigDir, 'Different agents should have different claudeConfigDir');
+        assert.notStrictEqual(agentA.codexHome, agentB.codexHome, 'Different agents should have different codexHome');
+    });
+    test('derived dirs are at workspace root for all agents', () => {
+        const workspaceRoot = '/Users/test/project';
+        const storageUri = '/Users/test/.vscode/storage';
+        const agentPaths = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'my-agent');
+        const defaultPaths = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'default');
+        // All agents share the same derived dirs at workspace root
+        assert.strictEqual(agentPaths.codexDerivedDir, defaultPaths.codexDerivedDir, 'All agents should share the same codexDerivedDir');
+        assert.strictEqual(agentPaths.claudeDerivedDir, defaultPaths.claudeDerivedDir, 'All agents should share the same claudeDerivedDir');
+        assert.strictEqual(agentPaths.codexDerivedDir, path.join(workspaceRoot, '.codex'), 'codexDerivedDir should be at workspace root');
+        assert.strictEqual(agentPaths.claudeDerivedDir, path.join(workspaceRoot, '.claude'), 'claudeDerivedDir should be at workspace root');
+    });
+    test('agent content dirs are under AGENTIDE_DIR/agents/<agentId>', () => {
+        const workspaceRoot = '/Users/test/project';
+        const storageUri = '/Users/test/.vscode/storage';
+        const paths = (0, paths_1.resolveAgentRuntimePaths)(workspaceRoot, storageUri, 'test-agent');
+        assert.strictEqual(paths.agentRoot, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'test-agent'), 'agentRoot should be under AGENTIDE_DIR/agents/test-agent');
+        assert.strictEqual(paths.rulesDir, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'test-agent', 'rules'), 'rulesDir should be under agentRoot/rules');
+        assert.strictEqual(paths.skillsDir, path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'test-agent', 'skills'), 'skillsDir should be under agentRoot/skills');
+    });
+});
+// -----------------------------------------------------------------------------
+// CodexEngine Config Tests (No API required)
+// -----------------------------------------------------------------------------
+suite('CodexEngine Config Paths', () => {
+    test('ensureCodexConfig writes to explicit CODEX_HOME', async () => {
+        const workspaceRoot = makeTempWorkspace();
+        const agentRoot = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'agent-a');
+        const codexHome = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'agent-a', 'codex-storage');
+        fs.mkdirSync(agentRoot, { recursive: true });
+        makeSkill(agentRoot, 's1');
+        const engine = new codex_1.CodexEngine({ storagePath: workspaceRoot, codexHome: undefined, claudeConfigDir: undefined }, () => undefined, () => undefined);
+        const logger = new logger_1.NoOpLogger();
+        const engineWithConfig = engine;
+        await engineWithConfig.ensureCodexConfig(false, // useLiteLLM
+        undefined, // customBaseUrl
+        undefined, // modelId
+        workspaceRoot, [], // additionalDirectories
+        logger, codexHome);
+        // Config files should be written into agent-local CODEX_HOME
+        assert.ok(fs.existsSync(path.join(codexHome, 'config.toml')), 'config.toml should be in agent CODEX_HOME');
+        // Workspace root .codex should NOT be created for config
+        // (derived dir may exist but shouldn't have config.toml)
+        const workspaceCodexConfig = path.join(workspaceRoot, '.codex', 'config.toml');
+        assert.ok(!fs.existsSync(workspaceCodexConfig), 'workspace .codex/config.toml should not be created');
+    });
+    test('ensureCodexConfig respects additionalDirectories', async () => {
+        const workspaceRoot = makeTempWorkspace();
+        const additionalDir = makeTempWorkspace();
+        const codexHome = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'default', 'codex-storage');
+        // Create skills in additional directory
+        makeSkill(additionalDir, 'extra-skill');
+        const engine = new codex_1.CodexEngine({ storagePath: workspaceRoot, codexHome: undefined, claudeConfigDir: undefined }, () => undefined, () => undefined);
+        const logger = new logger_1.NoOpLogger();
+        const engineWithConfig = engine;
+        await engineWithConfig.ensureCodexConfig(false, undefined, undefined, workspaceRoot, [additionalDir], logger, codexHome);
+        // Config should be created
+        assert.ok(fs.existsSync(path.join(codexHome, 'config.toml')), 'config.toml should exist');
+    });
+});

package/out/test/enginePublish.test.js

@@ -0,0 +1,82 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const fs_1 = require("fs");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const publish_1 = require("../engines/publish");
+suite('enginePublish', () => {
+    let tempDir;
+    suiteSetup(async () => {
+        tempDir = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), 'agentide-engine-publish-'));
+    });
+    suiteTeardown(async () => {
+        await fs_1.promises.rm(tempDir, { recursive: true, force: true });
+    });
+    test('isValidPublishVersion accepts semver', () => {
+        assert.strictEqual((0, publish_1.isValidPublishVersion)('1.0.0'), true);
+        assert.strictEqual((0, publish_1.isValidPublishVersion)('2.1.3-beta.1'), true);
+        assert.strictEqual((0, publish_1.isValidPublishVersion)('latest'), false);
+    });
+    test('validateEngineForPublish rejects missing manifest', async () => {
+        const engineDir = path.join(tempDir, 'broken');
+        await fs_1.promises.mkdir(engineDir, { recursive: true });
+        const result = await (0, publish_1.validateEngineForPublish)(engineDir, 'broken');
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.errors.some(error => error.includes('engine.manifest.json')));
+    });
+    test('validateEngineForPublish accepts minimal engine', async () => {
+        const engineDir = path.join(tempDir, 'demo');
+        await fs_1.promises.mkdir(engineDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(engineDir, 'engine.manifest.json'), `${JSON.stringify({
+            version: 2,
+            id: 'demo',
+            displayName: 'Demo',
+            entry: './engine.mjs',
+            promptInjection: { mode: 'message-suffix' },
+        }, null, 2)}\n`, 'utf-8');
+        await fs_1.promises.writeFile(path.join(engineDir, 'engine.mjs'), 'export class DemoEngine { async run() {} }\n', 'utf-8');
+        const result = await (0, publish_1.validateEngineForPublish)(engineDir, 'demo');
+        assert.strictEqual(result.valid, true, result.errors.join('; '));
+        const files = await (0, publish_1.collectEngineFiles)(engineDir);
+        assert.ok(files.some(file => file.path === 'engine.manifest.json'));
+        assert.ok(files.some(file => file.path === 'engine.mjs'));
+    });
+});