@agenthippo-ai/agenthippo 0.1.1 → 1.110.9

package/out/cli/commands/deploy.js

@@ -48,9 +48,10 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const yaml = __importStar(require("js-yaml"));
 const deploy_init_1 = require("../deploy-init");
+const registry_1 = require("../deploy/blueprints/registry");
 const utils_1 = require("../utils");
 const DEFAULT_PORT = 8080;
-/** Read pack id + engine + model from agent.yaml without the full loader (no workspace/sync needed). */
+/** Read pack id + version + engine + model from agent.yaml without the full loader (no workspace/sync needed). */
 function readManifest(packDir) {
     const manifestPath = path.join(packDir, 'agent.yaml');
     if (!fs.existsSync(manifestPath)) {
@@ -61,9 +62,14 @@ function readManifest(packDir) {
     if (!name) {
         throw new Error(`agent.yaml is missing metadata.name in ${packDir}`);
     }
+    const version = parsed?.metadata?.version?.trim();
+    if (!version) {
+        throw new Error(`agent.yaml is missing metadata.version in ${packDir}`);
+    }
     const model = parsed?.spec?.model?.trim();
     return {
         name,
+        version,
         engine: parsed?.spec?.engine?.trim() || 'claude',
         ...(model ? { model } : {}),
     };
@@ -123,7 +129,7 @@ function copyPackToStaging(packDir, stagingDir) {
                 return false;
             if (base.endsWith('.log'))
                 return false;
-            if (/credentials/i.test(base) && base.endsWith('.json'))
+            if ((0, deploy_init_1.isSecretLikeBasename)(base))
                 return false;
             return true;
         },
@@ -135,8 +141,35 @@ async function deployCommand(action, packArg, options) {
         console.error(`Unknown deploy action "${action}". Supported: init`);
         process.exit(1);
     }
+    // Blueprint resolution (PLAN/deploy.md §3) picks --target/--ingress for you; --platform
+    // selects which platform within the blueprint's supported set. Raw --target/--ingress stay
+    // fully usable when --blueprint is omitted — nothing here changes that path.
+    let resolvedTarget = options.target;
+    let resolvedIngress = options.ingress;
+    if (options.blueprint) {
+        if (!(0, registry_1.isBlueprintId)(options.blueprint)) {
+            console.error(`Unknown --blueprint "${options.blueprint}". Supported: ${Object.keys(registry_1.BLUEPRINTS).join(', ')}`);
+            process.exit(1);
+            return;
+        }
+        if (options.platform && !(0, deploy_init_1.isDeployTarget)(options.platform)) {
+            console.error(`Unknown --platform "${options.platform}". Supported: ${deploy_init_1.DEPLOY_TARGETS.join(', ')}`);
+            process.exit(1);
+            return;
+        }
+        try {
+            const resolved = (0, registry_1.resolveBlueprint)(options.blueprint, options.platform);
+            resolvedTarget = resolved.target;
+            resolvedIngress = resolved.ingress;
+        }
+        catch (err) {
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+            return;
+        }
+    }
     const packDir = path.resolve(options.packdir || packArg || process.cwd());
-    const targetsRequested = options.target === 'all' ? [...deploy_init_1.DEPLOY_TARGETS] : [options.target];
+    const targetsRequested = resolvedTarget === 'all' ? [...deploy_init_1.DEPLOY_TARGETS] : [resolvedTarget];
     for (const t of targetsRequested) {
         if (!(0, deploy_init_1.isDeployTarget)(t)) {
             console.error(`Unknown --target "${t}". Supported: ${deploy_init_1.DEPLOY_TARGETS.join(', ')}, all`);
@@ -162,8 +195,14 @@ async function deployCommand(action, packArg, options) {
             }
         }
     }
+    const modelRouting = options.modelRouting === 'gateway' ? 'gateway' : options.modelRouting === 'sidecar' ? 'sidecar' : undefined;
+    if (options.modelRouting && options.modelRouting !== 'gateway' && options.modelRouting !== 'sidecar') {
+        console.error(`Unknown --model-routing "${options.modelRouting}". Supported: sidecar, gateway`);
+        process.exit(1);
+    }
     const ctx = {
         packName: manifest.name,
+        packVersion: manifest.version,
         image: options.image || (0, deploy_init_1.defaultRuntimeImage)(manifest.engine),
         port: options.port || DEFAULT_PORT,
         engine: manifest.engine,
@@ -171,18 +210,18 @@ async function deployCommand(action, packArg, options) {
         envVars,
         gatewayChannels: gateway,
         publicHostname: (0, deploy_init_1.resolveDeployPublicHostname)(options.hostname),
-        ingress: options.ingress,
+        ingress: resolvedIngress,
         idpUrl: options.idpUrl,
         cookieDomain: options.cookieDomain,
+        colocate: options.colocate,
+        modelRouting,
+        edgeTurnConnector: options.edgeTurnConnector?.trim() || undefined,
     };
     for (const target of targetsRequested) {
-        // Staging dir = a self-contained pack (pack content + generated deploy/). Default
-        // ./deploy-out/<pack>-<target> (cwd-relative); --out overrides (per-target subdir if
-        // multiple targets). Build context = staging root, so COPY . /app/pack/ is correct
-        // regardless of where the script is invoked from.
+        const routingSuffix = modelRouting === 'gateway' ? '-gateway' : '';
         const outDir = options.out
-            ? (targetsRequested.length > 1 ? path.join(path.resolve(options.out), target) : path.resolve(options.out))
-            : path.join(process.cwd(), 'deploy-out', `${manifest.name}-${target}`);
+            ? (targetsRequested.length > 1 ? path.join(path.resolve(options.out), target + routingSuffix) : path.resolve(options.out))
+            : path.join(process.cwd(), 'deploy-out', `${manifest.name}-${target}${routingSuffix}`);
         fs.mkdirSync(outDir, { recursive: true });
         // Copy the pack into the staging root (filtered: no VCS/caches/secrets, no source deploy/).
         const brokenLinks = copyPackToStaging(packDir, outDir);
@@ -220,4 +259,5 @@ async function deployCommand(action, packArg, options) {
         console.log(`\n${utils_1.COLORS.dim}Scanned pack secrets into .env.example: ${envVars.join(', ')}${utils_1.COLORS.reset}`);
     }
     console.log(`\nNext: cd into the staging dir above, \`cp deploy/.env.example deploy/.env\`, then run the command in deploy/README.md (scripts anchor themselves to the staging root).`);
+    console.log(`${utils_1.COLORS.dim}Tip: run deploy init from the pack's parent directory — not from inside the pack (default deploy-out/ inside the pack copies into itself and fails).${utils_1.COLORS.reset}`);
 }

package/out/cli/commands/gateway.js

@@ -60,7 +60,65 @@ async function ensureStoreFileExists(storePath) {
         process.exit(1);
     }
 }
+/**
+ * Broker-mediated send (secure-obo-design §7.6): under `agenthippo serve` with the egress
+ * broker active, the agent's env carries AGENTHIPPO_EGRESS_URL + AGENTHIPPO_TURN_NONCE but NOT
+ * the gateway token. Route the send through the broker, which resolves the destination
+ * server-side from THIS turn's bound handles and delivers with the broker-held token.
+ * `--outbound`/`--agent` are ignored here — the broker derives both from the verified nonce.
+ */
+async function sendViaEgressBroker(egressUrl, nonce, options) {
+    const message = options.message.trim();
+    if (!message) {
+        console.error('Error: --message is required');
+        process.exit(1);
+    }
+    if (options.dryRun) {
+        console.log(`${utils_js_1.COLORS.dim}Dry run (egress broker):${utils_js_1.COLORS.reset} POST ${egressUrl} { to: ${options.target ?? '(reply-to-sender)'} }`);
+        process.exit(0);
+    }
+    let res;
+    try {
+        res = await fetch(egressUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${nonce}` },
+            body: JSON.stringify({ message, to: options.target?.trim() || undefined, media: options.media?.trim() || undefined }),
+        });
+    }
+    catch (err) {
+        console.error(`${utils_js_1.COLORS.red}✗${utils_js_1.COLORS.reset} Egress broker unreachable: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    const bodyText = await res.text();
+    let body = {};
+    try {
+        body = JSON.parse(bodyText);
+    }
+    catch { /* non-JSON error body */ }
+    if (options.json) {
+        console.log(JSON.stringify({ via: 'egress-broker', status: res.status, result: body }, null, 2));
+    }
+    else if (res.ok && body.ok) {
+        console.log(`${utils_js_1.COLORS.green}✓${utils_js_1.COLORS.reset} Sent (via egress broker${body.via ? `, ${body.via}` : ''})`);
+    }
+    else {
+        console.error(`${utils_js_1.COLORS.red}✗${utils_js_1.COLORS.reset} Egress send rejected (HTTP ${res.status}): ${body.error || bodyText || 'unknown error'}`);
+        process.exit(1);
+    }
+    process.exit(res.ok && body.ok ? 0 : 1);
+}
 async function gatewaySendCommand(options) {
+    // Prefer the broker whenever serve exposes it: the agent has no gateway token to send directly.
+    const egressUrl = process.env.AGENTHIPPO_EGRESS_URL?.trim();
+    const nonce = process.env.AGENTHIPPO_TURN_NONCE?.trim();
+    if (egressUrl && nonce) {
+        await sendViaEgressBroker(egressUrl, nonce, options);
+        return;
+    }
+    if (egressUrl) {
+        console.error('Error: egress broker is active but AGENTHIPPO_TURN_NONCE is missing — refusing direct gateway send');
+        process.exit(1);
+    }
     const storePath = resolveOutboundPath(options.outbound);
     await ensureStoreFileExists(storePath);
     const agentId = options.agent.trim();

package/out/cli/commands/idp.js

@@ -0,0 +1,85 @@
+"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 });
+exports.idpCommand = idpCommand;
+/**
+ * IdP Command — `agenthippo idp init --out <path> --hostname <host>`
+ *
+ * Generates the central IdP stack (PLAN/deploy.md) into a self-contained directory. Generates
+ * only; never builds images or calls a cloud — same rule as `deploy init`.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const idp_init_1 = require("../idp-init");
+const utils_1 = require("../utils");
+async function idpCommand(action, options) {
+    if (action !== 'init') {
+        console.error(`Unknown idp action "${action}". Supported: init`);
+        process.exit(1);
+        return;
+    }
+    if (!options.hostname?.trim()) {
+        console.error('idp init requires --hostname <public-hostname> (e.g. auth.corp.example)');
+        process.exit(1);
+        return;
+    }
+    const outDir = path.resolve(options.out || './enterprise-deploy/idp');
+    fs.mkdirSync(outDir, { recursive: true });
+    const ctx = { hostname: options.hostname.trim(), cookieDomain: options.cookieDomain };
+    const files = (0, idp_init_1.renderIdpArtifacts)(ctx);
+    const written = [];
+    const skipped = [];
+    for (const [rel, content] of Object.entries(files)) {
+        const dest = path.join(outDir, rel);
+        if (fs.existsSync(dest) && !options.force) {
+            skipped.push(rel);
+            continue;
+        }
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.writeFileSync(dest, content);
+        written.push(rel);
+    }
+    console.log(`${utils_1.COLORS.green}✓${utils_1.COLORS.reset} idp → ${path.relative(process.cwd(), outDir) || '.'}`);
+    for (const f of written) {
+        console.log(`    ${utils_1.COLORS.dim}+ ${f}${utils_1.COLORS.reset}`);
+    }
+    for (const f of skipped) {
+        console.log(`    ${utils_1.COLORS.yellow}• ${f} (exists; --force to overwrite)${utils_1.COLORS.reset}`);
+    }
+    console.log(`Next: cd ${path.relative(process.cwd(), outDir) || '.'}, cp .env.example ~/.agent-hippo/.env, cp .env.auth.example ~/.agent-hippo/.env.auth (fill in), then ./run.sh`);
+}

package/out/cli/commands/pack.js

@@ -44,6 +44,10 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const pack_loader_1 = require("../pack-loader");
 const branding_1 = require("../../branding");
+const warrant_1 = require("../../authority/warrant");
+const signature_1 = require("../../pack/signature");
+const store_1 = require("./store");
+const pack_install_ref_1 = require("../pack-install-ref");
 const BANNER_LINE = '-'.repeat(62);
 async function packCommand(options) {
     const workspace = options.workspace;
@@ -65,9 +69,20 @@ async function packCommand(options) {
             }
             await showPackInfo(options.name, workspace);
             break;
+        case 'sign':
+            await signPackCommand(options);
+            break;
+        case 'verify':
+            await verifyPackCommand(options);
+            break;
+        case 'digest':
+            await digestCommand(options);
+            break;
+        case 'keygen':
+            keygenCommand(options);
+            break;
         case 'install':
-            console.log('Pack installation is not yet implemented.');
-            console.log(`   For now, manually copy your pack to ~/${branding_1.AGENTIDE_DIR_NAME}/agents/<name>/`);
+            await installPackCommand(options);
             break;
         case 'export':
             console.log('Pack export is not yet implemented.');
@@ -79,11 +94,44 @@ async function packCommand(options) {
             console.log('  list      List installed packs');
             console.log('  validate  Validate a pack');
             console.log('  info      Show pack details');
-            console.log('  install   Install a pack (coming soon)');
+            console.log('  sign      Sign a pack so a fleet can verify it before running');
+            console.log('  verify    Verify a pack against trusted public keys');
+            console.log('  digest    Print the pack content digest (what a signature covers)');
+            console.log('  keygen    Generate an ES256 signing keypair');
+            console.log('  install   Install a pack from the store to a folder');
             console.log('  export    Export a pack (coming soon)');
             process.exit(1);
     }
 }
+async function installPackCommand(options) {
+    if (!options.name?.trim()) {
+        console.error('Error: pack slug required.');
+        console.log('Usage: agenthippo pack install <slug>[@version] --to <dir>');
+        console.log('');
+        console.log('Examples:');
+        console.log('  agenthippo pack install joker1 --to ./packs/joker1');
+        console.log('  agenthippo pack install code-reviewer@1.0.0 --to ./packs/code-reviewer');
+        process.exit(1);
+    }
+    const dest = options.to?.trim();
+    if (!dest) {
+        console.error('Error: --to <dir> is required.');
+        console.log('Usage: agenthippo pack install <slug>[@version] --to <dir>');
+        console.log('');
+        console.log('Same download as `agenthippo store install pack/<slug>`, extracted flat for serve/deploy.');
+        process.exit(1);
+    }
+    const { slug, version } = (0, pack_install_ref_1.parsePackInstallRef)(options.name);
+    await (0, store_1.installFromStore)({
+        action: 'install',
+        query: `pack/${slug}${version ? `@${version}` : ''}`,
+        workspace: options.workspace,
+        version,
+        force: options.force,
+        installDir: path.resolve(dest),
+        verbose: options.verbose,
+    });
+}
 async function listPacks(workspace) {
     const packs = (0, pack_loader_1.listAvailablePacks)(workspace);
     if (packs.length === 0) {
@@ -218,3 +266,134 @@ async function showPackInfo(nameOrPath, workspace) {
         process.exit(1);
     }
 }
+// -----------------------------------------------------------------------------
+// Signing
+//
+// Publishing has to be a one-liner before `--require-signed-pack` can be turned
+// on in anger: a requirement nobody can satisfy just gets switched off again.
+// -----------------------------------------------------------------------------
+/** Resolve a pack path and its declared identity — a signature binds both, not just bytes. */
+async function loadForSigning(nameOrPath, workspace) {
+    if (!nameOrPath) {
+        console.error('Error: pack name or path required');
+        process.exit(1);
+    }
+    const packPath = (0, pack_loader_1.resolvePackPath)(nameOrPath, workspace);
+    if (!packPath) {
+        console.error(`Error: pack not found: ${nameOrPath}`);
+        process.exit(1);
+    }
+    const loaded = await (0, pack_loader_1.loadAgentPack)(packPath, workspace);
+    return {
+        packPath: loaded.packPath,
+        name: loaded.manifest.metadata.name,
+        version: loaded.manifest.metadata.version ?? '0.0.0',
+    };
+}
+function keygenCommand(options) {
+    const kid = options.kid || `sign-${new Date().toISOString().slice(0, 10)}`;
+    const key = (0, warrant_1.generateWarrantKeypair)(kid);
+    const out = options.output;
+    if (out) {
+        fs.writeFileSync(out, key.privateKeyPem, { mode: 0o600 });
+        console.log(`Private key written to ${out} (mode 0600) — keep it off shared disks.`);
+    }
+    else {
+        console.log(key.privateKeyPem);
+    }
+    console.log('');
+    console.log(`kid: ${kid}`);
+    console.log('Public half — publish this to the control plane so instances can verify:');
+    console.log(key.publicKeyPem.trim());
+    console.log('');
+    console.log(`  curl -X POST "$CONTROL/api/keys" -H 'content-type: application/json' \\`);
+    console.log(`    -d '{"kid":"${kid}","publicPem":"…"}'`);
+}
+async function signPackCommand(options) {
+    const { packPath, name, version } = await loadForSigning(options.name, options.workspace);
+    if (!options.key) {
+        console.error('Error: --key <private-key.pem> required. Generate one with: agenthippo pack keygen -o key.pem');
+        process.exit(1);
+    }
+    let privateKeyPem;
+    try {
+        privateKeyPem = fs.readFileSync(options.key, 'utf8');
+    }
+    catch (err) {
+        console.error(`Error: cannot read key ${options.key}: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+        return;
+    }
+    const kid = options.kid;
+    if (!kid) {
+        console.error('Error: --kid <id> required — it is how a verifier finds the public half in JWKS.');
+        process.exit(1);
+    }
+    const { digest } = (0, signature_1.signPack)({ packDir: packPath, pack: name, packVersion: version, privateKeyPem, kid: kid });
+    console.log(`Signed ${name}@${version}`);
+    console.log(`  digest    ${digest}`);
+    console.log(`  key       ${kid}`);
+    console.log(`  written   ${path.join(packPath, signature_1.PACK_SIGNATURE_FILE)}`);
+    console.log('');
+    console.log('Commit pack.sig with the pack: it travels WITH the artifact, and a fleet that');
+    console.log('requires signatures refuses anything whose contents no longer match it.');
+}
+async function verifyPackCommand(options) {
+    const { packPath, name, version } = await loadForSigning(options.name, options.workspace);
+    const token = (0, signature_1.readPackSignature)(packPath);
+    if (!token) {
+        console.error(`UNSIGNED: no ${signature_1.PACK_SIGNATURE_FILE} at ${packPath}`);
+        console.error((0, signature_1.describePackRefusal)({ kind: 'unsigned', detail: `no ${signature_1.PACK_SIGNATURE_FILE}`, pack: name, packVersion: version, packDir: packPath }));
+        process.exit(1);
+    }
+    let keys = {};
+    if (options.keys) {
+        try {
+            keys = JSON.parse(fs.readFileSync(options.keys, 'utf8'));
+        }
+        catch (err) {
+            console.error(`Error: cannot read keys ${options.keys}: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+        }
+    }
+    else {
+        const trust = await (0, signature_1.loadPackTrustRoot)({
+            env: options.jwks ? { ...process.env, [signature_1.PACK_JWKS_URL_ENV]: options.jwks } : process.env,
+            leaseUrl: process.env.AGENTHIPPO_LEASE_URL,
+        });
+        for (const w of trust.warnings) {
+            console.error(`Warning: ${w}`);
+        }
+        if (trust.status === 'unavailable') {
+            // Distinct from "no keys configured", and with a different fix. Collapsing the two into
+            // an empty keyring is finding A4 — a 503 read exactly like an unmanaged install.
+            console.error(`REFUSED: a trust root is configured but could not be loaded — ${trust.reason}`);
+            console.error((0, signature_1.describePackRefusal)({
+                kind: 'trust-root-unavailable', detail: trust.reason ?? 'unavailable', pack: name, packVersion: version,
+                packDir: packPath, trustRootHint: trust.url ? `Trust root: ${trust.url}` : undefined,
+            }));
+            process.exit(1);
+        }
+        keys = trust.keys;
+    }
+    if (Object.keys(keys).length === 0) {
+        // "No keys" is a refusal, never a pass: verifying against an empty keyring would report
+        // success for any signature at all.
+        console.error('REFUSED: no trusted public keys. Pass --keys <file>, --jwks <url>, or set AGENTHIPPO_PACK_SIGNING_KEYS.');
+        process.exit(1);
+    }
+    const res = (0, signature_1.verifyPack)(token, keys, { packDir: packPath, pack: name, packVersion: version });
+    if (!res.ok) {
+        console.error(`INVALID: ${res.reason}`);
+        console.error((0, signature_1.describePackRefusal)({ kind: res.kind, detail: res.reason, pack: name, packVersion: version, packDir: packPath }));
+        process.exit(1);
+    }
+    console.log(`OK: ${name}@${version} verified`);
+    console.log(`  digest ${res.claims.digest}`);
+    console.log(`  NOTE: .claude/, .codex/ and .agent-hippo/ ARE covered by this digest — they carry hooks`);
+    console.log('        and other executable content, and were previously outside the signature.');
+}
+async function digestCommand(options) {
+    const { packPath, name, version } = await loadForSigning(options.name, options.workspace);
+    console.log(`${(0, signature_1.computePackDigest)(packPath)}  ${name}@${version}`);
+}