@hazeljs/cli 1.0.6 → 2.0.1

package/dist/commands/agent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/agent.test.js

@@ -0,0 +1,104 @@
+"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 fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const commander_1 = require("commander");
+const agent_1 = require("./agent");
+const agent_templates_1 = require("./agent-templates");
+describe('registerAgentCommand (AOS-011 + templates)', () => {
+    it('registers run, logs, doctor, new, and templates subcommands', () => {
+        const program = new commander_1.Command();
+        (0, agent_1.registerAgentCommand)(program);
+        const agent = program.commands.find((c) => c.name() === 'agent');
+        expect(agent).toBeDefined();
+        const names = agent.commands.map((c) => c.name());
+        expect(names).toEqual(expect.arrayContaining([
+            'install',
+            'dna',
+            'run',
+            'logs',
+            'doctor',
+            'runs',
+            'new',
+            'templates',
+            'apply',
+            'get',
+            'describe',
+            'delete',
+            'events',
+        ]));
+    });
+});
+describe('agent templates scaffold', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'hazel-agent-new-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    });
+    it('lists three templates', () => {
+        expect((0, agent_templates_1.listAgentTemplates)().map((t) => t.id)).toEqual(['bare', 'agent-os', 'skillgate']);
+    });
+    it('scaffolds bare DNA package', () => {
+        const dest = path.join(tmp, 'bare-demo');
+        const result = (0, agent_templates_1.scaffoldAgentProject)({ name: 'bare-demo', destDir: dest, template: 'bare' });
+        expect(result.files).toContain('dna/agent.marketplace.json');
+        const pkg = JSON.parse(fs.readFileSync(path.join(dest, 'dna/agent.marketplace.json'), 'utf8'));
+        expect(pkg.dna.format).toBe('hazeljs.agent.dna');
+        expect(pkg.dna.name).toBeTruthy();
+    });
+    it('scaffolds agent-os with real tool source', () => {
+        const dest = path.join(tmp, 'os-demo');
+        (0, agent_templates_1.scaffoldAgentProject)({ name: 'os-demo', destDir: dest, template: 'agent-os' });
+        expect(fs.existsSync(path.join(dest, 'src/support.agent.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dest, 'src/main.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dest, 'dna/agent.marketplace.json'))).toBe(true);
+    });
+    it('scaffolds skillgate with openapi sample', () => {
+        const dest = path.join(tmp, 'sg-demo');
+        (0, agent_templates_1.scaffoldAgentProject)({ name: 'sg-demo', destDir: dest, template: 'skillgate' });
+        expect(fs.existsSync(path.join(dest, 'openapi/sample.openapi.json'))).toBe(true);
+        expect(fs.existsSync(path.join(dest, 'src/report.ts'))).toBe(true);
+    });
+    it('refuses non-empty dest without force', () => {
+        const dest = path.join(tmp, 'taken');
+        fs.mkdirSync(dest);
+        fs.writeFileSync(path.join(dest, 'x.txt'), 'x');
+        expect(() => (0, agent_templates_1.scaffoldAgentProject)({ name: 'taken', destDir: dest, template: 'bare' })).toThrow(/not empty/);
+    });
+});

package/dist/commands/skillgate.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+/**
+ * `hazel skillgate from-openapi <file>` — preview governed skills from an OpenAPI doc.
+ * `hazel skillgate init` — write a starter skillgate.config.json.
+ */
+export declare function registerSkillgateCommand(program: Command): void;

package/dist/commands/skillgate.js

@@ -0,0 +1,147 @@
+"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 });
+exports.registerSkillgateCommand = registerSkillgateCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * `hazel skillgate from-openapi <file>` — preview governed skills from an OpenAPI doc.
+ * `hazel skillgate init` — write a starter skillgate.config.json.
+ */
+function registerSkillgateCommand(program) {
+    const skillgate = program
+        .command('skillgate')
+        .description('Skillgate — OpenAPI → curated, governed agent skills');
+    skillgate
+        .command('from-openapi')
+        .description('Parse an OpenAPI JSON file and print the Skillgate report')
+        .argument('<file>', 'Path to OpenAPI JSON')
+        .option('--mode <mode>', 'Include mode: opt-in | all', 'opt-in')
+        .option('--tags <tags>', 'Comma-separated tag allowlist')
+        .option('--allow-destructive', 'Allow DELETE / destructive methods')
+        .option('--allow-admin', 'Allow admin / internal paths')
+        .option('--base-url <url>', 'Override servers[0].url for invokers')
+        .option('--json', 'Print raw JSON report')
+        .action(async (file, opts) => {
+        try {
+            const { Skillgate } = await Promise.resolve().then(() => __importStar(require('@hazeljs/skillgate')));
+            const abs = path.resolve(process.cwd(), file);
+            const raw = fs.readFileSync(abs, 'utf8');
+            const spec = JSON.parse(raw);
+            const gate = Skillgate.fromOpenApi(spec, {
+                include: {
+                    mode: opts.mode === 'all' ? 'all' : 'opt-in',
+                    tags: opts.tags
+                        ? opts.tags
+                            .split(',')
+                            .map((t) => t.trim())
+                            .filter(Boolean)
+                        : undefined,
+                },
+                classify: {
+                    allowDestructive: Boolean(opts.allowDestructive),
+                    allowAdmin: Boolean(opts.allowAdmin),
+                },
+                invoke: opts.baseUrl ? { baseUrl: opts.baseUrl } : undefined,
+                force: true,
+            });
+            const report = gate.report();
+            if (opts.json) {
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify(report, null, 2));
+                return;
+            }
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({
+                included: report.included.map((s) => ({
+                    name: s.name,
+                    class: s.class,
+                    method: s.method,
+                    path: s.path,
+                    readOnly: s.readOnly,
+                    requiresApproval: s.requiresApproval,
+                })),
+                denied: report.denied.map((s) => ({
+                    name: s.name,
+                    reason: s.denyReason,
+                })),
+                warnings: report.warnings,
+                next: 'gate.register(toolRegistry, "your-agent")',
+            }, null, 2));
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e);
+            process.exitCode = 1;
+        }
+    });
+    skillgate
+        .command('init')
+        .description('Write a starter skillgate.config.json in the current directory')
+        .option('--force', 'Overwrite existing file')
+        .action((opts) => {
+        const out = path.resolve(process.cwd(), 'skillgate.config.json');
+        if (fs.existsSync(out) && !opts.force) {
+            // eslint-disable-next-line no-console
+            console.error(`Refusing to overwrite ${out} (pass --force)`);
+            process.exitCode = 1;
+            return;
+        }
+        const starter = {
+            $schema: 'https://hazeljs.ai/schemas/skillgate.config.json',
+            include: {
+                mode: 'opt-in',
+                tags: ['agent', 'skillgate'],
+            },
+            classify: {
+                writeRequiresApproval: true,
+                allowDestructive: false,
+                allowAdmin: false,
+            },
+            invoke: {
+                baseUrl: 'http://127.0.0.1:3000',
+                headers: {
+                    Authorization: 'Bearer ${API_TOKEN}',
+                },
+            },
+            warnAbove: 12,
+            maxTools: 24,
+            agentName: 'api-concierge',
+        };
+        fs.writeFileSync(out, JSON.stringify(starter, null, 2) + '\n');
+        // eslint-disable-next-line no-console
+        console.log(`Wrote ${out}`);
+    });
+}

package/dist/commands/store.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+/**
+ * `hazel store publish|install|list|remove|doctor` — local or hosted Agent OS package registry.
+ * Hosted (Cloud Team SKU): `--remote <url> --token <token>` or HAZEL_REGISTRY_URL / HAZEL_REGISTRY_TOKEN.
+ * `hazel install` aliases `hazel store install`.
+ */
+export declare function registerStoreCommand(program: Command): void;

package/dist/commands/store.js

@@ -0,0 +1,203 @@
+"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 });
+exports.registerStoreCommand = registerStoreCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+async function resolveRegistry(opts) {
+    const { createAgentPackageRegistry } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+    return createAgentPackageRegistry({
+        remote: opts.remote,
+        token: opts.token,
+        registryRoot: opts.registry,
+    });
+}
+function registryOptions(cmd) {
+    return cmd
+        .option('--registry <dir>', 'Local registry root (default: ~/.hazel/registry)')
+        .option('--remote <url>', 'Hosted registry base URL (Cloud Team SKU; env HAZEL_REGISTRY_URL)')
+        .option('--token <token>', 'Bearer token for hosted registry (env HAZEL_REGISTRY_TOKEN)');
+}
+async function publishAction(file, opts) {
+    const { loadMarketplacePackage } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+    const pkg = loadMarketplacePackage(path.resolve(process.cwd(), file));
+    const registry = await resolveRegistry(opts);
+    await registry.publish(pkg);
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({
+        ok: true,
+        action: 'publish',
+        package: pkg.name,
+        version: pkg.version,
+        registry: registry.location,
+        kind: registry.kind,
+    }, null, 2));
+}
+async function installAction(spec, opts) {
+    const { loadMarketplacePackage, materializeAgentPackage, parsePackageSpec } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+    const projectRoot = path.resolve(process.cwd(), opts.cwd);
+    const resolvedPath = path.resolve(process.cwd(), spec);
+    const looksLikeFile = spec.includes(path.sep) ||
+        spec.includes('/') ||
+        spec.endsWith('.json') ||
+        fs.existsSync(resolvedPath);
+    let pkg;
+    if (looksLikeFile && fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isFile()) {
+        pkg = loadMarketplacePackage(resolvedPath);
+    }
+    else {
+        const { name, version } = parsePackageSpec(spec);
+        const registry = await resolveRegistry(opts);
+        pkg = await registry.get(name, version);
+    }
+    const result = materializeAgentPackage(pkg, projectRoot);
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({
+        ok: true,
+        action: 'install',
+        package: result.packageName,
+        version: result.version,
+        path: result.packagePath,
+        lock: result.lockPath,
+        note: 'Use hazel agent run with the materialized package DNA, or runtime.installAgentPackage for hot-reload',
+    }, null, 2));
+}
+/**
+ * `hazel store publish|install|list|remove|doctor` — local or hosted Agent OS package registry.
+ * Hosted (Cloud Team SKU): `--remote <url> --token <token>` or HAZEL_REGISTRY_URL / HAZEL_REGISTRY_TOKEN.
+ * `hazel install` aliases `hazel store install`.
+ */
+function registerStoreCommand(program) {
+    const store = program
+        .command('store')
+        .description('Agent OS package registry — local filesystem or hosted (--remote) Cloud Team registry');
+    registryOptions(store
+        .command('publish')
+        .description('Publish a marketplace / DNA JSON package to the registry')
+        .argument('<file>', 'Path to .dna.json or marketplace package JSON')).action(async (file, opts) => {
+        try {
+            await publishAction(file, opts);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+    registryOptions(store
+        .command('install')
+        .description('Install a package into the project (.hazel/agents). Spec: path, name, or name@version')
+        .argument('<spec>', 'File path or package name[@version]')
+        .option('--cwd <dir>', 'Project root', '.')).action(async (spec, opts) => {
+        try {
+            await installAction(spec, opts);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+    registryOptions(store
+        .command('list')
+        .description('List packages in the registry')
+        .argument('[query]', 'Optional name/description filter')).action(async (query, opts) => {
+        try {
+            const registry = await resolveRegistry(opts);
+            const packages = await registry.list(query);
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({ ok: true, kind: registry.kind, registry: registry.location, packages }, null, 2));
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+    registryOptions(store
+        .command('remove')
+        .description('Remove a package (or one version) from the registry')
+        .argument('<spec>', 'name or name@version')).action(async (spec, opts) => {
+        try {
+            const { parsePackageSpec } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+            const { name, version } = parsePackageSpec(spec);
+            const registry = await resolveRegistry(opts);
+            await registry.remove(name, version);
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({
+                ok: true,
+                action: 'remove',
+                name,
+                version: version ?? '*',
+                kind: registry.kind,
+                registry: registry.location,
+            }, null, 2));
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+    registryOptions(store.command('doctor').description('Check registry health (local or remote)')).action(async (opts) => {
+        try {
+            const registry = await resolveRegistry(opts);
+            const report = await registry.doctor();
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({ ...report, kind: registry.kind, registry: registry.location }, null, 2));
+            if (!report.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+    registryOptions(program
+        .command('install')
+        .description('Alias for hazel store install')
+        .argument('<spec>', 'File path or package name[@version]')
+        .option('--cwd <dir>', 'Project root', '.')).action(async (spec, opts) => {
+        try {
+            await installAction(spec, opts);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/store.test.js

@@ -0,0 +1,120 @@
+"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 commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const store_1 = require("./store");
+describe('registerStoreCommand (G2 Package+Store)', () => {
+    it('registers store subcommands and install alias', () => {
+        const program = new commander_1.Command();
+        (0, store_1.registerStoreCommand)(program);
+        const store = program.commands.find((c) => c.name() === 'store');
+        expect(store).toBeDefined();
+        const names = store.commands.map((c) => c.name());
+        expect(names).toEqual(expect.arrayContaining(['publish', 'install', 'list', 'remove', 'doctor']));
+        expect(program.commands.some((c) => c.name() === 'install')).toBe(true);
+    });
+    it('publish then install materializes support-desk style package', async () => {
+        const { exportAgentDna, toMarketplacePackage, saveMarketplacePackage } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'hazel-store-cli-'));
+        const registryDir = path.join(tmp, 'registry');
+        const projectDir = path.join(tmp, 'project');
+        fs.mkdirSync(projectDir);
+        const dna = exportAgentDna({
+            name: 'support-desk',
+            version: '1.0.0',
+            tools: [{ name: 'lookupOrder' }],
+        });
+        const pkg = toMarketplacePackage(dna);
+        pkg.name = '@hazeljs/support-desk-agent';
+        const pkgFile = path.join(tmp, 'support-desk.marketplace.json');
+        saveMarketplacePackage(pkg, pkgFile);
+        const program = new commander_1.Command();
+        (0, store_1.registerStoreCommand)(program);
+        await program.parseAsync(['store', 'publish', pkgFile, '--registry', registryDir], {
+            from: 'user',
+        });
+        expect(process.exitCode ?? 0).toBe(0);
+        await program.parseAsync([
+            'store',
+            'install',
+            '@hazeljs/support-desk-agent@1.0.0',
+            '--cwd',
+            projectDir,
+            '--registry',
+            registryDir,
+        ], { from: 'user' });
+        expect(process.exitCode ?? 0).toBe(0);
+        const lockPath = path.join(projectDir, '.hazel', 'agents', 'lock.json');
+        expect(fs.existsSync(lockPath)).toBe(true);
+        const lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+        expect(lock['@hazeljs/support-desk-agent']?.version).toBe('1.0.0');
+        fs.rmSync(tmp, { recursive: true, force: true });
+    });
+    it('publishes and installs real starter support-desk.marketplace.json', async () => {
+        // Fixture is vendored in-package so CI (hazeljs repo only) does not need sibling starters.
+        const pkgFile = path.resolve(__dirname, '../../fixtures/support-desk.marketplace.json');
+        expect(fs.existsSync(pkgFile)).toBe(true);
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'hazel-store-starter-'));
+        const registryDir = path.join(tmp, 'registry');
+        const projectDir = path.join(tmp, 'project');
+        fs.mkdirSync(projectDir);
+        const program = new commander_1.Command();
+        (0, store_1.registerStoreCommand)(program);
+        process.exitCode = 0;
+        await program.parseAsync(['store', 'publish', pkgFile, '--registry', registryDir], {
+            from: 'user',
+        });
+        expect(process.exitCode ?? 0).toBe(0);
+        await program.parseAsync([
+            'store',
+            'install',
+            '@hazeljs/support-desk-agent',
+            '--cwd',
+            projectDir,
+            '--registry',
+            registryDir,
+        ], { from: 'user' });
+        expect(process.exitCode ?? 0).toBe(0);
+        const packageJson = path.join(projectDir, '.hazel', 'agents', 'hazeljs__support-desk-agent', 'package.json');
+        expect(fs.existsSync(packageJson)).toBe(true);
+        const loaded = JSON.parse(fs.readFileSync(packageJson, 'utf8'));
+        expect(loaded.name).toBe('@hazeljs/support-desk-agent');
+        expect(loaded.dna.name).toBe('support-desk');
+        fs.rmSync(tmp, { recursive: true, force: true });
+    });
+});

package/dist/index.js

@@ -56,6 +56,8 @@ const add_1 = require("./commands/add");
 const eval_1 = require("./commands/eval");
 const benchmark_1 = require("./commands/benchmark");
 const agent_1 = require("./commands/agent");
+const skillgate_1 = require("./commands/skillgate");
+const store_1 = require("./commands/store");
 // Read version from package.json to ensure consistency
 const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json'), 'utf8'));
 const program = new commander_1.Command();
@@ -71,6 +73,8 @@ program
 (0, eval_1.registerEvalCommand)(program);
 (0, benchmark_1.registerBenchmarkCommand)(program);
 (0, agent_1.registerAgentCommand)(program);
+(0, skillgate_1.registerSkillgateCommand)(program);
+(0, store_1.registerStoreCommand)(program);
 // Generate command group (unified: hazel g <type> <name> [--path] [--dry-run] [--json], or hazel g --list)
 const generateCommand = program
     .command('generate')

package/dist/utils/packages-registry.js

@@ -234,6 +234,25 @@ export const mlImports = [MLModule.forRoot()];
 // Minimal MCP server example:
 const server = createMcpServer({ name: 'hazel-mcp', version: '0.1.0' });
 server.start();
+`,
+    },
+    {
+        shortName: 'skillgate',
+        npm: '@hazeljs/skillgate',
+        label: 'Skillgate - OpenAPI → governed agent skills (@hazeljs/skillgate)',
+        hint: 'import { Skillgate } from "@hazeljs/skillgate";\n  // Skillgate.fromOpenApi(spec).register(toolRegistry, "api-concierge");',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: `import { Skillgate } from '@hazeljs/skillgate';
+import { ToolRegistry } from '@hazeljs/agent';
+
+// Opt-in: tags agent|skillgate, x-hazel-skill, or explicit allowlists.
+const gate = Skillgate.fromOpenApi(openApiSpec, {
+  include: { tags: ['agent'] },
+  invoke: { baseUrl: process.env.API_BASE_URL || 'http://127.0.0.1:3000' },
+});
+const registry = new ToolRegistry();
+gate.register(registry, 'api-concierge');
 `,
     },
     {