@agenthippo-ai/agenthippo 0.1.1 → 1.110.9

package/out/test/pack-trust-root.test.js

@@ -0,0 +1,202 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  The trust root — where the fleet learns which code it is allowed to run.
+ *
+ *  Every one of these pins a property that was absent: the JWKS URL was built from whatever
+ *  AGENTHIPPO_LEASE_URL pointed at, fetched with a bare `fetch()`, with no scheme requirement, no
+ *  pinning, and nothing signing the document. Whoever could answer that URL chose the trust root.
+ *--------------------------------------------------------------------------------------------*/
+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 warrant_1 = require("../authority/warrant");
+const signature_1 = require("../pack/signature");
+const key = (0, warrant_1.generateWarrantKeypair)('k1');
+const other = (0, warrant_1.generateWarrantKeypair)('k2');
+const okResponse = (body) => ({
+    ok: true,
+    status: 200,
+    json: async () => body,
+});
+const fetchReturning = (body) => (async () => okResponse(body));
+suite('trust root — scheme', () => {
+    test('an http JWKS origin is refused: the keyring that decides what runs must not be rewritable in flight', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: { [signature_1.PACK_JWKS_URL_ENV]: 'http://plane.example/.well-known/jwks.json' },
+            fetchImpl: fetchReturning({ pemsByKid: { k1: key.publicKeyPem } }),
+        });
+        assert.strictEqual(root.status, 'unavailable');
+        assert.match(root.reason ?? '', /must be https/);
+        assert.deepStrictEqual(root.keys, {});
+    });
+    test('https is accepted with no warning', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://plane.example/.well-known/jwks.json' },
+            fetchImpl: fetchReturning({ pemsByKid: { k1: key.publicKeyPem } }),
+        });
+        assert.strictEqual(root.status, 'configured');
+        assert.deepStrictEqual(Object.keys(root.keys), ['k1']);
+    });
+    test('the local-dev escape hatch works and is LOUD', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: {
+                [signature_1.PACK_JWKS_URL_ENV]: 'http://localhost:9000/.well-known/jwks.json',
+                [signature_1.ALLOW_INSECURE_TRUST_ROOT_ENV]: '1',
+            },
+            fetchImpl: fetchReturning({ pemsByKid: { k1: key.publicKeyPem } }),
+        });
+        assert.strictEqual(root.status, 'configured');
+        assert.ok(root.warnings.some((w) => /INSECURE/.test(w)), 'the opt-out must announce itself');
+    });
+    test('assertSecureTrustUrl rejects a malformed URL rather than assuming a scheme', () => {
+        const r = (0, signature_1.assertSecureTrustUrl)('not a url', 'the trust root', {});
+        assert.strictEqual(r.ok, false);
+    });
+});
+suite('trust root — independence from the lease origin', () => {
+    test('a dedicated JWKS URL takes precedence over anything derived from the lease', async () => {
+        let asked = '';
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://trust.example/jwks.json' },
+            leaseUrl: 'https://attacker.example/lease',
+            fetchImpl: (async (u) => { asked = u; return okResponse({ pemsByKid: { k1: key.publicKeyPem } }); }),
+        });
+        assert.strictEqual(asked, 'https://trust.example/jwks.json');
+        assert.strictEqual(root.status, 'configured');
+    });
+    test('deriving from the lease origin still works but says it is weaker', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: {},
+            leaseUrl: 'https://plane.example/lease',
+            fetchImpl: fetchReturning({ pemsByKid: { k1: key.publicKeyPem } }),
+        });
+        assert.strictEqual(root.status, 'configured');
+        assert.strictEqual(root.derivedFromLease, true);
+        assert.ok(root.warnings.some((w) => /derived from AGENTHIPPO_LEASE_URL/.test(w)));
+    });
+    test('the derived URL asks for the pack-signing purpose, so a plane that splits keys by purpose still answers it', async () => {
+        let asked = '';
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: {},
+            leaseUrl: 'https://plane.example/lease',
+            fetchImpl: (async (u) => { asked = u; return okResponse({ pemsByKid: { k1: key.publicKeyPem } }); }),
+        });
+        // Without the query string a plane that now serves one purpose per document can hand back
+        // a set with no pack-signing key in it — an empty trust root, which with signing fail-closed
+        // means every instance refuses to boot at once.
+        assert.strictEqual(asked, 'https://plane.example/.well-known/jwks.json?purpose=pack-signing');
+        assert.strictEqual(root.status, 'configured');
+    });
+    test('nothing configured is UNCONFIGURED, not an error — an unmanaged deployment has no plane', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({ env: {} });
+        assert.strictEqual(root.status, 'unconfigured');
+        assert.deepStrictEqual(root.keys, {});
+    });
+});
+suite('trust root — thumbprint pinning', () => {
+    test('a key that matches no pin is REFUSED, by either thumbprint form', async () => {
+        const tp = (0, signature_1.publicKeyThumbprints)(key.publicKeyPem);
+        for (const pin of [tp.jwk, tp.spki, `sha256:${tp.spki.toUpperCase()}`]) {
+            const root = await (0, signature_1.loadPackTrustRoot)({
+                env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j', [signature_1.PACK_JWKS_PINS_ENV]: pin },
+                fetchImpl: fetchReturning({ pemsByKid: { k1: key.publicKeyPem, k2: other.publicKeyPem } }),
+            });
+            assert.strictEqual(root.status, 'configured', `pin form ${pin} should match`);
+            assert.deepStrictEqual(Object.keys(root.keys), ['k1'], 'the unpinned key must be dropped');
+            assert.ok(root.warnings.some((w) => /k2 does not match any pin/.test(w)));
+        }
+    });
+    test('a swapped trust root that matches NO pin is unavailable, not silently empty', async () => {
+        const tp = (0, signature_1.publicKeyThumbprints)(key.publicKeyPem);
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j', [signature_1.PACK_JWKS_PINS_ENV]: tp.spki },
+            fetchImpl: fetchReturning({ pemsByKid: { k2: other.publicKeyPem } }),
+        });
+        assert.strictEqual(root.status, 'unavailable');
+        assert.match(root.reason ?? '', /pin check/);
+    });
+    test('parseJwksPins tolerates whitespace, prefixes and blanks', () => {
+        assert.deepStrictEqual((0, signature_1.parseJwksPins)(' sha256:AB , ,cd '), ['ab', 'cd']);
+        assert.deepStrictEqual((0, signature_1.parseJwksPins)(undefined), []);
+    });
+});
+suite('trust root — A4: unavailable is not the same as unconfigured', () => {
+    test('a non-200 JWKS is an ERROR, not an empty keyring', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j' },
+            fetchImpl: (async () => ({ ok: false, status: 503 })),
+        });
+        assert.strictEqual(root.status, 'unavailable');
+        assert.match(root.reason ?? '', /HTTP 503/);
+    });
+    test('a transport failure is an ERROR', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j' },
+            fetchImpl: (async () => { throw new Error('ECONNREFUSED'); }),
+        });
+        assert.strictEqual(root.status, 'unavailable');
+        assert.match(root.reason ?? '', /ECONNREFUSED/);
+    });
+    test('a garbled inline keyring is an ERROR — a typo must not read as "unmanaged"', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({ env: { AGENTHIPPO_PACK_SIGNING_KEYS: '{not json' } });
+        assert.strictEqual(root.status, 'unavailable');
+        assert.match(root.reason ?? '', /not valid JSON/);
+    });
+    test('a JWKS with no usable ES256 keys is an ERROR', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j' },
+            fetchImpl: fetchReturning({ keys: [{ kty: 'RSA', kid: 'r1', n: 'x', e: 'AQAB' }] }),
+        });
+        assert.strictEqual(root.status, 'unavailable');
+    });
+});
+suite('trust root — document shapes', () => {
+    test('a standard JWKS (what authority/warrant.ts publishes) is accepted', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j' },
+            fetchImpl: fetchReturning((0, warrant_1.jwks)([key])),
+        });
+        assert.strictEqual(root.status, 'configured');
+        assert.deepStrictEqual(Object.keys(root.keys), ['k1']);
+    });
+    test('inline keys need no network at all (air-gapped)', async () => {
+        const root = await (0, signature_1.loadPackTrustRoot)({
+            env: { AGENTHIPPO_PACK_SIGNING_KEYS: JSON.stringify({ k1: key.publicKeyPem }) },
+            fetchImpl: (async () => { throw new Error('must not be called'); }),
+        });
+        assert.strictEqual(root.status, 'configured');
+    });
+});

package/out/test/remote-trust.test.js

@@ -0,0 +1,242 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *
+ *  `spec.remote.url` comes from a pack manifest — a file that arrives from the store, a PR, or a
+ *  teammate. These tests pin that it can no longer be turned into a token-exfiltration sink.
+ *--------------------------------------------------------------------------------------------*/
+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 = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const remoteTrust_1 = require("../remote/remoteTrust");
+const serveClient_1 = require("../remote/serveClient");
+suite('remote serve URL classification', () => {
+    test('loopback is its own level — allowed, never prompted', () => {
+        for (const url of ['http://127.0.0.1:8080', 'http://localhost:9000/base', 'https://127.0.0.1:8443']) {
+            const v = (0, remoteTrust_1.classifyRemoteServeUrl)(url);
+            assert.strictEqual(v.level, 'loopback', url);
+            assert.strictEqual((0, remoteTrust_1.mayReceiveAccessToken)(v), true, `${url} is this machine`);
+        }
+    });
+    test('an untrusted host may NOT receive the access token', () => {
+        assert.strictEqual((0, remoteTrust_1.mayReceiveAccessToken)((0, remoteTrust_1.classifyRemoteServeUrl)('https://attacker.example')), false);
+    });
+    test('the product domain and its subdomains are trusted', () => {
+        assert.strictEqual((0, remoteTrust_1.classifyRemoteServeUrl)('https://agenthippo.ai').level, 'trusted');
+        assert.strictEqual((0, remoteTrust_1.classifyRemoteServeUrl)('https://serve.agenthippo.ai/v1').level, 'trusted');
+    });
+    test('a lookalike domain is NOT trusted', () => {
+        // The suffix match must be on a label boundary, not a substring.
+        assert.strictEqual((0, remoteTrust_1.classifyRemoteServeUrl)('https://agenthippo.ai.attacker.tld').level, 'untrusted');
+        assert.strictEqual((0, remoteTrust_1.classifyRemoteServeUrl)('https://notagenthippo.ai').level, 'untrusted');
+        assert.strictEqual((0, remoteTrust_1.classifyRemoteServeUrl)('https://evil-agenthippo.ai').level, 'untrusted');
+    });
+    test('cleartext http to a non-loopback host is refused outright — no consent path', () => {
+        const v = (0, remoteTrust_1.classifyRemoteServeUrl)('http://attacker.example/serve');
+        assert.strictEqual(v.level, 'refused');
+        assert.ok(v.reason?.includes('access token'), 'the reason names what would leak');
+    });
+    test('a non-http scheme and a malformed URL are refused', () => {
+        assert.strictEqual((0, remoteTrust_1.classifyRemoteServeUrl)('ftp://attacker.example').level, 'refused');
+        assert.strictEqual((0, remoteTrust_1.classifyRemoteServeUrl)('¬not a url').level, 'refused');
+    });
+    test('an explicitly approved origin becomes trusted', () => {
+        const v = (0, remoteTrust_1.classifyRemoteServeUrl)('https://serve.corp.example:8443/x', {
+            approvedOrigins: ['https://serve.corp.example:8443'],
+        });
+        assert.strictEqual(v.level, 'trusted');
+    });
+    test('an approval is per origin — a different port is a different host', () => {
+        const v = (0, remoteTrust_1.classifyRemoteServeUrl)('https://serve.corp.example:9999/x', {
+            approvedOrigins: ['https://serve.corp.example:8443'],
+        });
+        assert.strictEqual(v.level, 'untrusted');
+    });
+});
+suite('remote trust gate', () => {
+    function memoryStore(initial = []) {
+        const origins = [...initial];
+        return {
+            origins,
+            readApprovedOrigins: () => [...origins],
+            approveOrigin: (o) => { origins.push(o); },
+        };
+    }
+    test('with no prompt available, an untrusted host is REFUSED, not silently contacted', async () => {
+        const gate = (0, remoteTrust_1.createRemoteTrustGate)({ store: memoryStore(), trustedDomains: ['agenthippo.ai'] });
+        const result = await gate.evaluate('https://attacker.example/serve');
+        assert.strictEqual(result.allowed, false);
+        assert.strictEqual(result.sendAuth, false);
+        assert.ok(result.verdict.reason?.includes('attacker.example'));
+    });
+    test('declining the prompt refuses the turn and stores nothing', async () => {
+        const store = memoryStore();
+        const gate = (0, remoteTrust_1.createRemoteTrustGate)({
+            store,
+            trustedDomains: ['agenthippo.ai'],
+            prompt: async () => false,
+        });
+        const result = await gate.evaluate('https://attacker.example/serve');
+        assert.strictEqual(result.allowed, false);
+        assert.strictEqual(result.sendAuth, false);
+        assert.deepStrictEqual(store.origins, [], 'a declined host is not remembered');
+    });
+    test('approving the prompt allows the turn and remembers the origin', async () => {
+        const store = memoryStore();
+        let promptedWith;
+        const gate = (0, remoteTrust_1.createRemoteTrustGate)({
+            store,
+            trustedDomains: ['agenthippo.ai'],
+            prompt: async (v) => { promptedWith = v; return true; },
+        });
+        const result = await gate.evaluate('https://serve.corp.example/x');
+        assert.strictEqual(result.allowed, true);
+        assert.strictEqual(result.sendAuth, true);
+        assert.strictEqual(promptedWith?.hostname, 'serve.corp.example', 'the prompt names the host');
+        assert.deepStrictEqual(store.origins, ['https://serve.corp.example']);
+    });
+    test('a remembered origin is not prompted again', async () => {
+        const store = memoryStore(['https://serve.corp.example']);
+        let prompted = 0;
+        const gate = (0, remoteTrust_1.createRemoteTrustGate)({
+            store,
+            trustedDomains: ['agenthippo.ai'],
+            prompt: async () => { prompted++; return true; },
+        });
+        const result = await gate.evaluate('https://serve.corp.example/x');
+        assert.strictEqual(result.allowed, true);
+        assert.strictEqual(result.sendAuth, true);
+        assert.strictEqual(prompted, 0);
+    });
+    test('a refused scheme is never offered for consent', async () => {
+        let prompted = 0;
+        const gate = (0, remoteTrust_1.createRemoteTrustGate)({
+            store: memoryStore(),
+            prompt: async () => { prompted++; return true; },
+        });
+        const result = await gate.evaluate('http://attacker.example/serve');
+        assert.strictEqual(result.allowed, false);
+        assert.strictEqual(prompted, 0, 'cleartext is not a consent decision');
+    });
+    test('loopback is allowed without a prompt and never forces a sign-in', async () => {
+        let prompted = 0;
+        const gate = (0, remoteTrust_1.createRemoteTrustGate)({
+            store: memoryStore(),
+            prompt: async () => { prompted++; return true; },
+        });
+        const result = await gate.evaluate('http://127.0.0.1:7777');
+        assert.strictEqual(result.allowed, true);
+        assert.strictEqual(result.sendAuth, true, 'a token we already hold may go to our own machine');
+        assert.strictEqual(result.requireAuth, false, 'an unauthenticated local serve must keep working');
+        assert.strictEqual(prompted, 0);
+    });
+    test('a trusted host DOES force a sign-in — that is the point of signing in', async () => {
+        const gate = (0, remoteTrust_1.createRemoteTrustGate)({ store: memoryStore(), trustedDomains: ['agenthippo.ai'] });
+        const result = await gate.evaluate('https://serve.agenthippo.ai');
+        assert.strictEqual(result.allowed, true);
+        assert.strictEqual(result.sendAuth, true);
+        assert.strictEqual(result.requireAuth, true);
+    });
+});
+suite('remote trust store', () => {
+    test('approvals persist to a 0600 file outside any workspace, and a missing file approves nothing', () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ah-remote-trust-'));
+        const storePath = path.join(dir, 'nested', 'remote-trust.json');
+        try {
+            const store = new remoteTrust_1.RemoteTrustStore(storePath);
+            assert.deepStrictEqual(store.readApprovedOrigins(), [], 'no file ⇒ nothing approved (fail closed)');
+            store.approveOrigin('https://serve.corp.example');
+            assert.deepStrictEqual(store.readApprovedOrigins(), ['https://serve.corp.example']);
+            store.approveOrigin('https://serve.corp.example');
+            assert.strictEqual(store.readApprovedOrigins().length, 1, 'approving twice does not duplicate');
+            if (process.platform !== 'win32') {
+                assert.strictEqual(fs.statSync(storePath).mode & 0o777, 0o600, 'file is user-only');
+            }
+            store.revokeOrigin('https://serve.corp.example');
+            assert.deepStrictEqual(store.readApprovedOrigins(), []);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    test('a corrupt store file approves nothing rather than throwing', () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ah-remote-trust-'));
+        const storePath = path.join(dir, 'remote-trust.json');
+        try {
+            fs.writeFileSync(storePath, '{not json');
+            assert.deepStrictEqual(new remoteTrust_1.RemoteTrustStore(storePath).readApprovedOrigins(), []);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    test('extra trusted domains come from the environment, not from settings a repo could reach', () => {
+        assert.deepStrictEqual((0, remoteTrust_1.trustedDomainsFromEnv)({ AGENTHIPPO_REMOTE_TRUSTED_HOSTS: 'a.example, b.example ,' }), ['a.example', 'b.example']);
+        assert.deepStrictEqual((0, remoteTrust_1.trustedDomainsFromEnv)({}), []);
+    });
+});
+suite('serve client headers', () => {
+    test('no self-asserted identity header is sent alongside the bearer token', () => {
+        const headers = (0, serveClient_1.buildServeAuthHeaders)({ accessToken: 'tok', userEmail: 'victim@example.com' });
+        assert.strictEqual(headers.Authorization, 'Bearer tok');
+        // The serve side trusts `x-agent-user` as its first identity alias; sending a client-chosen
+        // value made cross-user session/state access a one-header change.
+        const identityHeaders = Object.keys(headers).filter((k) => k.toLowerCase() === 'x-agent-user');
+        assert.deepStrictEqual(identityHeaders, [], 'X-Agent-User must not be sent');
+    });
+    test('no credential means no headers at all', () => {
+        assert.deepStrictEqual((0, serveClient_1.buildServeAuthHeaders)(undefined), {});
+        assert.deepStrictEqual((0, serveClient_1.buildServeAuthHeaders)({ accessToken: '', userEmail: 'x@y.z' }), {});
+    });
+});
+suite('manifest remote URL extraction', () => {
+    test('a usable URL is returned unchanged', () => {
+        assert.strictEqual((0, serveClient_1.getRemoteServeUrl)({ spec: { remote: { url: 'https://serve.agenthippo.ai' } } }), 'https://serve.agenthippo.ai');
+        assert.strictEqual((0, serveClient_1.getRemoteServeUrl)({ spec: { remote: { url: 'http://127.0.0.1:8080' } } }), 'http://127.0.0.1:8080');
+    });
+    test('a cleartext remote host is dropped, with a diagnostic explaining why', () => {
+        const manifest = { spec: { remote: { url: 'http://attacker.example' } } };
+        assert.strictEqual((0, serveClient_1.getRemoteServeUrl)(manifest), undefined);
+        assert.ok((0, serveClient_1.getRemoteServeUrlDiagnostic)(manifest)?.includes('http://'), 'diagnostic explains the drop');
+    });
+    test('an absent remote block yields no URL and no diagnostic', () => {
+        assert.strictEqual((0, serveClient_1.getRemoteServeUrl)(undefined), undefined);
+        assert.strictEqual((0, serveClient_1.getRemoteServeUrlDiagnostic)({}), undefined);
+    });
+});