@agenthippo-ai/agenthippo 0.1.0

package/out/test/headless-sync.test.js

@@ -0,0 +1,279 @@
+"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 });
+/**
+ * Headless Sync Tests
+ *
+ * Tests for the syncPackToWorkspace function that syncs agent pack content
+ * to workspace derived directories (.claude/, .codex/).
+ */
+require("mocha");
+const assert = __importStar(require("assert"));
+const fs = __importStar(require("fs"));
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const sync_1 = require("../headless/sync");
+const shared_1 = require("../shared");
+const paths_1 = require("../agentpack/paths");
+// -------------------------------------------------------------------------
+// Test Helpers
+// -------------------------------------------------------------------------
+function makeTempDir(prefix) {
+    return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+function createTestLogger() {
+    const messages = [];
+    return {
+        messages,
+        info: (msg) => messages.push(msg),
+        appendLine: (msg) => messages.push(msg),
+    };
+}
+async function cleanupDir(dir) {
+    try {
+        await fs_1.promises.rm(dir, { recursive: true, force: true });
+    }
+    catch {
+        // ignore
+    }
+}
+// -------------------------------------------------------------------------
+// Tests
+// -------------------------------------------------------------------------
+suite('Headless Sync - syncPackToWorkspace', () => {
+    let workspaceRoot;
+    let packPath;
+    let logger;
+    setup(async () => {
+        workspaceRoot = makeTempDir('headless-sync-workspace-');
+        packPath = makeTempDir('headless-sync-pack-');
+        logger = createTestLogger();
+    });
+    teardown(async () => {
+        await cleanupDir(workspaceRoot);
+        await cleanupDir(packPath);
+    });
+    test('creates derived directory for claude engine', async () => {
+        await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), '# Test Agent');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        const derivedDir = path.join(workspaceRoot, shared_1.AGENT_ENGINES.claude.workspaceDir);
+        assert.ok(fs.existsSync(derivedDir), 'Claude derived directory should exist');
+    });
+    test('creates derived directory for codex engine', async () => {
+        await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), '# Test Agent');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'codex', logger);
+        const derivedDir = path.join(workspaceRoot, shared_1.AGENT_ENGINES.codex.workspaceDir);
+        assert.ok(fs.existsSync(derivedDir), 'Codex derived directory should exist');
+    });
+    test('syncs AGENTS.md to claude rules file (CLAUDE.md)', async () => {
+        const content = '# My Agent\n\nThis is a test agent.';
+        await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), content);
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        const rulesFile = path.join(workspaceRoot, '.claude', 'CLAUDE.md');
+        assert.ok(fs.existsSync(rulesFile), 'CLAUDE.md should exist');
+        const actual = await fs_1.promises.readFile(rulesFile, 'utf8');
+        assert.strictEqual(actual, content);
+    });
+    test('syncs AGENTS.md to codex rules file (AGENTS.md)', async () => {
+        const content = '# My Codex Agent\n\nThis is a test agent.';
+        await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), content);
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'codex', logger);
+        const rulesFile = path.join(workspaceRoot, '.codex', 'AGENTS.md');
+        assert.ok(fs.existsSync(rulesFile), 'AGENTS.md should exist in .codex/');
+        const actual = await fs_1.promises.readFile(rulesFile, 'utf8');
+        assert.strictEqual(actual, content);
+    });
+    test('combines AGENTS.md with context.md', async () => {
+        await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), '# Agent Rules');
+        await fs_1.promises.writeFile(path.join(packPath, 'context.md'), '## Context Section');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        const rulesFile = path.join(workspaceRoot, '.claude', 'CLAUDE.md');
+        const content = await fs_1.promises.readFile(rulesFile, 'utf8');
+        assert.ok(content.includes('# Agent Rules'), 'Should include AGENTS.md content');
+        assert.ok(content.includes('---'), 'Should have separator');
+        assert.ok(content.includes('## Context Section'), 'Should include context.md content');
+    });
+    test('syncs skills directory via symlinks', async () => {
+        // Create pack with skills
+        const skillsDir = path.join(packPath, 'skills');
+        await fs_1.promises.mkdir(skillsDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(skillsDir, 'test-skill.md'), '# Test Skill');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        const derivedSkillsDir = path.join(workspaceRoot, '.claude', 'skills');
+        assert.ok(fs.existsSync(derivedSkillsDir), 'skills directory should exist');
+        const skillFile = path.join(derivedSkillsDir, 'test-skill.md');
+        assert.ok(fs.existsSync(skillFile), 'skill file should exist');
+        const content = await fs_1.promises.readFile(skillFile, 'utf8');
+        assert.strictEqual(content, '# Test Skill');
+    });
+    test('syncs rules fragments directory', async () => {
+        // Create pack with rule fragments
+        const rulesDir = path.join(packPath, 'rules');
+        await fs_1.promises.mkdir(rulesDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(rulesDir, 'coding-style.md'), '# Coding Style\n\nUse TypeScript.');
+        await fs_1.promises.writeFile(path.join(rulesDir, 'testing.md'), '# Testing\n\nWrite tests.');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        const derivedRulesDir = path.join(workspaceRoot, '.claude', 'rules');
+        assert.ok(fs.existsSync(derivedRulesDir), 'rules directory should exist');
+        assert.ok(fs.existsSync(path.join(derivedRulesDir, 'coding-style.md')));
+        assert.ok(fs.existsSync(path.join(derivedRulesDir, 'testing.md')));
+    });
+    test('ignores non-.md files in rules directory', async () => {
+        const rulesDir = path.join(packPath, 'rules');
+        await fs_1.promises.mkdir(rulesDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(rulesDir, 'valid.md'), '# Valid');
+        await fs_1.promises.writeFile(path.join(rulesDir, 'ignore.txt'), 'Should be ignored');
+        await fs_1.promises.writeFile(path.join(rulesDir, 'ignore.json'), '{}');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        const derivedRulesDir = path.join(workspaceRoot, '.claude', 'rules');
+        assert.ok(fs.existsSync(path.join(derivedRulesDir, 'valid.md')));
+        assert.ok(!fs.existsSync(path.join(derivedRulesDir, 'ignore.txt')), '.txt files should not be synced');
+        assert.ok(!fs.existsSync(path.join(derivedRulesDir, 'ignore.json')), '.json files should not be synced');
+    });
+    test('creates .gitignore with derived directories', async () => {
+        await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), '# Test');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        const gitignorePath = path.join(workspaceRoot, '.gitignore');
+        assert.ok(fs.existsSync(gitignorePath), '.gitignore should exist');
+        const content = await fs_1.promises.readFile(gitignorePath, 'utf8');
+        assert.ok(content.includes('.claude'), '.gitignore should include .claude');
+        assert.ok(content.includes('.codex'), '.gitignore should include .codex');
+    });
+    test('handles empty pack (no AGENTS.md)', async () => {
+        // Pack with no files should not throw
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        // Derived directory should still be created
+        const derivedDir = path.join(workspaceRoot, shared_1.AGENT_ENGINES.claude.workspaceDir);
+        assert.ok(fs.existsSync(derivedDir), 'Derived directory should still be created');
+    });
+    test('throws for unknown engine', async () => {
+        await assert.rejects(async () => (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'unknown', logger), /Unknown engine/);
+    });
+    test('logs sync operations', async () => {
+        await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), '# Test');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        assert.ok(logger.messages.length > 0, 'Should have logged messages');
+        assert.ok(logger.messages.some(m => m.includes('Synced rules')), 'Should log rules sync');
+        assert.ok(logger.messages.some(m => m.includes('synced to workspace')), 'Should log completion');
+    });
+    test('re-syncing updates content', async () => {
+        // Initial sync
+        await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), '# Version 1');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        const rulesFile = path.join(workspaceRoot, '.claude', 'CLAUDE.md');
+        let content = await fs_1.promises.readFile(rulesFile, 'utf8');
+        assert.ok(content.includes('Version 1'));
+        // Update and re-sync
+        await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), '# Version 2');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', logger);
+        content = await fs_1.promises.readFile(rulesFile, 'utf8');
+        assert.ok(content.includes('Version 2'), 'Content should be updated');
+    });
+    test('syncs pack MCP from agent.yaml spec.mcp to workspace .mcp.json', async () => {
+        await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), '# MCP pack');
+        await fs_1.promises.mkdir(path.join(packPath, 'mcp'), { recursive: true });
+        await fs_1.promises.writeFile(path.join(packPath, 'mcp', 'db.json'), JSON.stringify({ mcpServers: { db: { command: 'echo', args: ['db'] } } }, null, 2));
+        await fs_1.promises.writeFile(path.join(packPath, 'agent.yaml'), [
+            'apiVersion: agenthippo.ai/v1',
+            'kind: Agent',
+            'metadata:',
+            '  name: test-pack',
+            '  version: 0.1.0',
+            'spec:',
+            '  engine: cursor',
+            '  mcp:',
+            '    - name: db',
+            '      config: ./mcp/db.json',
+        ].join('\n'));
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'cursor', logger);
+        const mcpPath = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, paths_1.AGENT_CONSTANTS.AGENTS_DIR, 'test-pack', paths_1.AGENT_CONSTANTS.MCP_DIR, '.mcp.json');
+        assert.ok(fs.existsSync(mcpPath), '.mcp.json should exist');
+        const cfg = JSON.parse(await fs_1.promises.readFile(mcpPath, 'utf8'));
+        assert.ok(cfg.mcpServers?.db, 'should merge db server');
+    });
+    test('does not create self-referential skill symlinks when pack lives under agentide agents dir', async () => {
+        const inWorkspacePackPath = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, paths_1.AGENT_CONSTANTS.AGENTS_DIR, 'test-pack');
+        const skillDir = path.join(inWorkspacePackPath, paths_1.AGENT_CONSTANTS.SKILLS_DIR, 'demo-skill');
+        await fs_1.promises.mkdir(skillDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(inWorkspacePackPath, 'AGENTS.md'), '# In-workspace pack');
+        await fs_1.promises.writeFile(path.join(skillDir, 'SKILL.md'), '# Demo skill');
+        await (0, sync_1.syncPackToWorkspace)(workspaceRoot, inWorkspacePackPath, 'test-pack', 'codex', logger);
+        const skillMd = path.join(skillDir, 'SKILL.md');
+        const stat = await fs_1.promises.lstat(skillMd);
+        assert.ok(stat.isFile(), 'SKILL.md should remain a real file, not a symlink loop');
+        const content = await fs_1.promises.readFile(skillMd, 'utf8');
+        assert.strictEqual(content, '# Demo skill');
+    });
+});
+suite('Headless Sync - LoggerLike interface', () => {
+    test('works with appendLine (vscode.OutputChannel style)', async () => {
+        const workspaceRoot = makeTempDir('headless-sync-logger-');
+        const packPath = makeTempDir('headless-sync-logger-pack-');
+        try {
+            await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), '# Test');
+            const messages = [];
+            const outputChannelStyle = {
+                appendLine: (msg) => messages.push(msg),
+            };
+            await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', outputChannelStyle);
+            assert.ok(messages.length > 0, 'Should have logged via appendLine');
+        }
+        finally {
+            await cleanupDir(workspaceRoot);
+            await cleanupDir(packPath);
+        }
+    });
+    test('works with info (Logger interface style)', async () => {
+        const workspaceRoot = makeTempDir('headless-sync-logger-');
+        const packPath = makeTempDir('headless-sync-logger-pack-');
+        try {
+            await fs_1.promises.writeFile(path.join(packPath, 'AGENTS.md'), '# Test');
+            const messages = [];
+            const loggerStyle = {
+                info: (msg) => messages.push(msg),
+            };
+            await (0, sync_1.syncPackToWorkspace)(workspaceRoot, packPath, 'test-pack', 'claude', loggerStyle);
+            assert.ok(messages.length > 0, 'Should have logged via info');
+        }
+        finally {
+            await cleanupDir(workspaceRoot);
+            await cleanupDir(packPath);
+        }
+    });
+});

package/out/test/helpers/manifest-fixtures.js

@@ -0,0 +1,27 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestAgentYaml = createTestAgentYaml;
+/**
+ * Build a test-friendly Agent manifest YAML string.
+ * Keeps repetitive manifest snippets centralized for tests.
+ */
+function createTestAgentYaml({ name, version, engine, quoteVersion = false, description, model, includeSkills = false, fileAccess, visibility, }) {
+    const lines = [
+        'apiVersion: agenthippo.ai/v1',
+        'kind: Agent',
+        'metadata:',
+        `  name: ${name}`,
+        `  version: ${quoteVersion ? `"${version}"` : version}`,
+        ...(description ? [`  description: ${description}`] : []),
+        'spec:',
+        `  engine: ${engine}`,
+        ...(model ? [`  model: ${model}`] : []),
+        ...(includeSkills ? ['  skills: []'] : []),
+        ...(fileAccess ? ['  permissions:', `    fileAccess: ${fileAccess}`] : []),
+        ...(visibility ? [`  visibility: ${visibility}`] : []),
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/out/test/mcp-obo.test.js

@@ -0,0 +1,82 @@
+"use strict";
+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 });
+const assert = __importStar(require("assert"));
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const credential_context_1 = require("../cli/credential-context");
+const mcp_1 = require("../mcp");
+suite('mcp: OBO token in MCP env (Design B §11.1)', () => {
+    const orig = process.env.DATABRICKS_TOKEN;
+    let tokenDir;
+    setup(() => {
+        tokenDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'mcp-obo-'));
+    });
+    teardown(() => {
+        if (orig === undefined) {
+            delete process.env.DATABRICKS_TOKEN;
+        }
+        else {
+            process.env.DATABRICKS_TOKEN = orig;
+        }
+        (0, node_fs_1.rmSync)(tokenDir, { recursive: true, force: true });
+    });
+    test('static PAT when no credential scope', () => {
+        process.env.DATABRICKS_TOKEN = 'pat-static';
+        assert.strictEqual((0, mcp_1.resolveMcpEnvVar)('DATABRICKS_TOKEN'), 'pat-static');
+    });
+    test('OBO token overrides static PAT inside runWithCredential (inline fallback)', async () => {
+        process.env.DATABRICKS_TOKEN = 'pat-static';
+        await (0, credential_context_1.runWithCredential)({ userId: 'u@x.com', dataToken: 'obo-live' }, async () => {
+            assert.strictEqual((0, mcp_1.resolveMcpEnvVar)('DATABRICKS_TOKEN'), 'obo-live');
+        });
+    });
+    test('credential placeholder resolves to token file for stdio MCP', async () => {
+        await (0, credential_context_1.runWithCredential)({ userId: 'u@x.com', dataToken: 'obo-file-token' }, async () => {
+            const resolved = (0, mcp_1.resolveMcpServerEnv)({
+                DATABRICKS_HOST: 'dbc.example.com',
+                DATABRICKS_TOKEN: '${credential:dataToken}',
+            });
+            assert.ok(resolved);
+            assert.strictEqual(resolved.DATABRICKS_HOST, 'dbc.example.com');
+            assert.strictEqual(resolved.DATABRICKS_TOKEN, undefined);
+            const file = resolved[mcp_1.AGENTHIPPO_DATA_TOKEN_FILE_ENV];
+            assert.ok(file);
+            assert.strictEqual((0, node_fs_1.readFileSync)(file, 'utf8'), 'obo-file-token');
+            assert.strictEqual((0, mcp_1.resolveMcpEnvVar)('DATABRICKS_TOKEN'), '');
+        }, { dataTokenDir: tokenDir });
+    });
+});