Files
stack/packages/cli/tests/proxy-context-join.test.mjs
T

113 lines
6.5 KiB
JavaScript

// Mos1961: exercise the actual P2 runtime -> launcher -> P3 harness/runner path.
// Only management/model HTTP and the model adapter are local stand-ins.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import { join } from 'node:path';
import { sandboxProblem } from '../../seat/src/sandbox.mjs';
import { managedLaunchFixture } from './model-managed-launch-fixture.mjs';
const skip = sandboxProblem() ?? false;
function editBusiness(f, update) {
const path = join(f.root, 'config', 'businesses', 'acme.json');
const document = JSON.parse(fs.readFileSync(path, 'utf8'));
update(document);
fs.writeFileSync(path, JSON.stringify(document) + '\n', { mode: 0o600 });
}
function runnerEnv(session) {
return Object.fromEntries(fs.readFileSync(`/proc/${session.runnerPid}/environ`, 'utf8')
.split('\0').filter(Boolean).map(entry => {
const at = entry.indexOf('='); return [entry.slice(0, at), entry.slice(at + 1)];
}));
}
function privateArtifacts(f, session, keys) {
const text = fs.readFileSync(join(session.runDir, 'session.json'), 'utf8');
const saved = JSON.parse(text);
for (const key of keys) assert.equal(text.includes(key), false, 'session.json contains no credential value');
for (const name of ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN', 'ZAI_API_KEY'])
assert.equal(Object.hasOwn(saved.harnessEnv, name), false, 'harnessEnv persists no provider credential');
for (const entry of fs.readdirSync(join(session.runDir, 'bundle'), { withFileTypes: true, recursive: true })) {
if (!entry.isFile()) continue;
const bytes = fs.readFileSync(join(entry.parentPath, entry.name), 'utf8');
for (const key of keys) assert.equal(bytes.includes(key), false, 'bundle contains no credential value');
}
f.valueFree();
}
for (const [provider, route, generated, api] of [
['zai', null, 'mosaic-proxy-glm', 'openai-completions'],
['anthropic', null, 'anthropic', 'anthropic-messages'],
['proxy', 'anthropic', 'anthropic', 'anthropic-messages'],
['proxy', 'glm', 'mosaic-proxy-glm', 'openai-completions'],
['proxy', 'codex', 'mosaic-proxy-codex', 'openai-responses'],
]) {
test(`P3 joined managed ${provider}${route ? ':' + route : ''} uses its one admitted P2 key and private run-local config`, { skip, timeout: 30000 }, async t => {
const f = await managedLaunchFixture(t);
assert.deepEqual(f.upstreamCredentialNames, [], 'managed proxy fixture has no inherited fake upstream credential');
editBusiness(f, doc => {
doc.launch.models['claude-opus-5-5'].provider = provider;
if (route) doc.launch.models['claude-opus-5-5'].route = route;
});
const answer = await f.launcher.launchPm();
const session = f.sessions().find(value => value.run === answer.run);
assert.ok(session?.live, 'same real confined runner is live');
assert.equal(f.trace.successfulPreflights, 1, 'one actual P2 acquisition, not one per check');
const own = f.bus.credentials.modelRecord('acme/chief');
assert.ok(own);
assert.equal(session.modelKeyId, own.keyId, 'binding/stall identity matches admitted generation');
assert.equal(f.trace.bindings[0].modelKeyId, own.keyId);
const other = await f.bus.modelPreflight({ business: 'acme', role: 'coder' });
assert.equal(other.key === own.key, false, 'different agent receives a different key');
const env = runnerEnv(session);
assert.equal(env.ANTHROPIC_API_KEY === own.key, true, 'runner gets exactly the admitted key');
assert.equal(Object.values(env).includes(other.key), false, 'another agent key never enters runner');
for (const name of ['CLAUDE_CODE_OAUTH_TOKEN', 'ANTHROPIC_AUTH_TOKEN', 'OPENAI_API_KEY', 'OPENROUTER_API_KEY', 'ZAI_API_KEY'])
assert.equal(Object.hasOwn(env, name), false, `${name} absent from managed runner`);
const path = join(session.runDir, 'home', '.pi', 'agent', 'models.json');
const text = fs.readFileSync(path, 'utf8');
const models = JSON.parse(text);
assert.equal(models.providers[generated].api, api);
assert.equal(models.providers[generated].baseUrl,
other.baseUrl + (api === 'anthropic-messages' ? '' : '/v1'));
assert.equal(models.providers[generated].models.some(model => model.id === 'claude-opus-5-5'), true);
for (const value of Object.values(models.providers)) assert.equal(value.apiKey, '$ANTHROPIC_API_KEY');
for (const key of [own.key, other.key]) assert.equal(text.includes(key), false, 'models contain no key value');
assert.equal(fs.statSync(path).mode & 0o777, 0o600);
for (const part of ['home', 'home/.pi', 'home/.pi/agent'])
assert.equal(fs.statSync(join(session.runDir, part)).mode & 0o777, 0o700);
privateArtifacts(f, session, [own.key, other.key]);
});
}
test('P3 joined Claude harness receives the admitted P2 key only through transient auth env', { skip, timeout: 30000 }, async t => {
const f = await managedLaunchFixture(t, { harness: 'claude-code' });
assert.deepEqual(f.upstreamCredentialNames, [], 'Claude proxy fixture holds no upstream credential');
editBusiness(f, doc => { doc.launch.models['claude-opus-5-5'].provider = 'anthropic'; });
const answer = await f.launcher.launchPm();
const session = f.sessions().find(value => value.run === answer.run);
assert.ok(session?.live);
assert.equal(f.trace.successfulPreflights, 1);
const own = f.bus.credentials.modelRecord('acme/chief');
const env = runnerEnv(session);
assert.equal(env.ANTHROPIC_AUTH_TOKEN === own.key, true, 'Claude receives admitted key without host login');
assert.equal(env.ANTHROPIC_BASE_URL?.startsWith('http://127.0.0.1:'), true);
assert.equal(Object.hasOwn(env, 'ANTHROPIC_API_KEY'), false);
assert.equal(Object.hasOwn(env, 'CLAUDE_CODE_OAUTH_TOKEN'), false);
assert.equal(session.modelKeyId, own.keyId);
privateArtifacts(f, session, [own.key]);
});
test('P3 joined unsupported provider refuses with no key acquisition, fallback, or spawned session', { skip, timeout: 30000 }, async t => {
const f = await managedLaunchFixture(t);
editBusiness(f, doc => {
doc.launch.models['claude-opus-5-5'].provider = 'unknown-wire';
Object.assign(doc.roles.chief.vars, { 'fallback.harness': 'pi', 'fallback.model': 'glm-5.3-flash', 'fallback.thinking': 'low' });
});
await assert.rejects(f.launcher.launchPm(), error => error.code === 'proxy-provider-unsupported');
assert.equal(f.trace.preflightAttempts, 0);
assert.equal(f.trace.bindings.length, 0);
assert.equal(f.sessions().length, 0);
assert.equal(f.runDirectories().length, 0);
f.valueFree();
});