mirror of
https://github.com/ranxianglei/billion-context.git
synced 2026-11-23 01:58:16 +08:00
2867 lines
152 KiB
TypeScript
2867 lines
152 KiB
TypeScript
import assert from "node:assert";
|
|
import http from "node:http";
|
|
import net from "node:net";
|
|
import type { AddressInfo } from "node:net";
|
|
import { once } from "node:events";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import test from "node:test";
|
|
import { rmrf } from "./tmp-rm.ts";
|
|
|
|
process.env.NODE_ENV = "test";
|
|
|
|
// A developer machine may leak ambient bili state into these tests:
|
|
// - BILLION_CONTEXT_PROXY (any shell launched THROUGH bili) — detectProxyBase
|
|
// would resolve it, the "inert host" tests would fetch a REAL manifest
|
|
// from the live proxy and register tools (CI has none, local runs broke);
|
|
// - ~/.pi/acp.json / billion-context.json delegate config — kept inert by
|
|
// the HOME isolation below.
|
|
// Strip both for the whole file (restored on exit). The manifest-fetch paths
|
|
// are exercised against the file's own fake servers, exactly like CI.
|
|
const realHome = process.env.HOME;
|
|
const realProxyEnv = process.env.BILLION_CONTEXT_PROXY;
|
|
const realConfigFileEnv = process.env.BILI_CONFIG_FILE;
|
|
process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), "bc-plugin-agent-"));
|
|
delete process.env.BILLION_CONTEXT_PROXY;
|
|
// #5659: the pi.commands default surface is ["acp", "acp-cache"] — this file also drives
|
|
// /acp-rule registration, so opt the full surface in explicitly.
|
|
process.env.BILI_CONFIG_FILE = path.join(process.env.HOME!, "billion-context.json");
|
|
fs.writeFileSync(process.env.BILI_CONFIG_FILE, JSON.stringify({ pi: { commands: true } }));
|
|
process.on("exit", () => {
|
|
try { fs.rmSync(process.env.HOME!, { recursive: true, force: true }); } catch { /* best effort */ }
|
|
process.env.HOME = realHome;
|
|
if (realProxyEnv !== undefined) process.env.BILLION_CONTEXT_PROXY = realProxyEnv;
|
|
if (realConfigFileEnv !== undefined) process.env.BILI_CONFIG_FILE = realConfigFileEnv;
|
|
else delete process.env.BILI_CONFIG_FILE;
|
|
});
|
|
|
|
import { proxyBaseFromUrl, proxyBaseFromEnv, detectProxyBase, fetchManifest, forwardTool, fetchStatus, destinationRoutedThroughProxy } from "../src/agent/shared.ts";
|
|
import { wrapCacheReport, wrapRuleReport } from "../src/acp-panel.ts";
|
|
import biliPlugin, { createBiliPlugin } from "../src/agent/pi.ts";
|
|
import ompPlugin from "../src/agent/omp.ts";
|
|
import { pluginInstall, pluginRemove, pluginStatusAll, PLUGIN_AGENTS, selfPackageRoot, pickPluginKey, detectOpencodeMajor, piEntryFor, PI_NPM_ENTRY, isPiEntry, claudeNativeInstalled } from "../src/plugin-install.ts";
|
|
import { resolveProxyOrigin, forwardTool as mcpForwardTool } from "../src/mcp.ts";
|
|
|
|
function withEnv(vars: Record<string, string | undefined>, fn: () => void | Promise<void>): Promise<void> {
|
|
const saved = new Map<string, string | undefined>();
|
|
for (const [k, v] of Object.entries(vars)) {
|
|
saved.set(k, process.env[k]);
|
|
if (v === undefined) delete process.env[k];
|
|
else process.env[k] = v;
|
|
}
|
|
return Promise.resolve(fn()).finally(() => {
|
|
for (const [k, v] of saved) {
|
|
if (v === undefined) delete process.env[k];
|
|
else process.env[k] = v;
|
|
}
|
|
});
|
|
}
|
|
|
|
test("proxyBaseFromUrl detects /bili/ prefix and returns origin", () => {
|
|
assert.equal(proxyBaseFromUrl("http://127.0.0.1:8787/bili/https://api.example.com/v1"), "http://127.0.0.1:8787");
|
|
assert.equal(proxyBaseFromUrl("https://proxy.example.com/bili/https://upstream"), "https://proxy.example.com");
|
|
assert.equal(proxyBaseFromUrl("https://api.example.com/v1"), undefined);
|
|
assert.equal(proxyBaseFromUrl(undefined), undefined);
|
|
assert.equal(proxyBaseFromUrl("not a url"), undefined);
|
|
assert.equal(proxyBaseFromUrl("http://x/api/bili/v1"), undefined);
|
|
assert.equal(proxyBaseFromUrl("http://x/bili/ftp://y"), undefined);
|
|
});
|
|
|
|
test("proxyBaseFromEnv accepts BILLION_CONTEXT_PROXY, detectProxyBase honors kill switch", async () => {
|
|
await withEnv({ BILLION_CONTEXT_PROXY: "http://127.0.0.1:8790/", BILLION_CONTEXT_PLUGIN: undefined }, () => {
|
|
assert.equal(proxyBaseFromEnv(), "http://127.0.0.1:8790");
|
|
assert.equal(detectProxyBase("https://api.example.com/v1"), "http://127.0.0.1:8790");
|
|
assert.equal(detectProxyBase("http://x/bili/https://y"), "http://x");
|
|
});
|
|
await withEnv({ BILLION_CONTEXT_PROXY: "http://127.0.0.1:8790/", BILLION_CONTEXT_PLUGIN: "0" }, () => {
|
|
assert.equal(detectProxyBase("http://x/bili/https://y"), undefined);
|
|
});
|
|
await withEnv({ BILLION_CONTEXT_PROXY: "ftp://bad" }, () => {
|
|
assert.equal(proxyBaseFromEnv(), undefined);
|
|
});
|
|
});
|
|
|
|
type FakeProxy = {
|
|
origin: string;
|
|
toolCalls: Array<{ conversationId: string; tool: string; args: unknown; nativeCaller?: boolean; toolCallId?: string }>;
|
|
registers: Array<{ conversationId: string; agent: string; identity: boolean; parentConversationId?: string }>;
|
|
runtimeInfos: Array<Record<string, unknown>>;
|
|
close(): Promise<void>;
|
|
};
|
|
|
|
async function startFakeProxy(opts: { failRegister?: number; statusOk?: boolean; decompressFailure?: boolean } = {}): Promise<FakeProxy> {
|
|
const toolCalls: FakeProxy["toolCalls"] = [];
|
|
const registers: FakeProxy["registers"] = [];
|
|
const runtimeInfos: FakeProxy["runtimeInfos"] = [];
|
|
const server = http.createServer((req, res) => {
|
|
const url = req.url ?? "";
|
|
if (url === "/__bili/plugin/manifest") {
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ tools: { anthropic: [
|
|
{ name: "compress", description: "Compress context ranges", input_schema: { type: "object", properties: { content: { type: "array" } }, required: ["content"] } },
|
|
// #2204: opt-in decompress slot so the business-failure lane can be exercised end-to-end.
|
|
...(opts.decompressFailure ? [{ name: "decompress", description: "Restore", input_schema: { type: "object", properties: { blockId: { type: "string" }, toFile: { type: "string" } }, required: ["blockId"] } }] : []),
|
|
{ name: "acp_status", description: "Status", input_schema: { type: "object", properties: {} } },
|
|
] } }));
|
|
return;
|
|
}
|
|
if (url === "/__bili/plugin/tool" && req.method === "POST") {
|
|
let body = "";
|
|
req.on("data", (c) => (body += c));
|
|
req.on("end", () => {
|
|
const data = JSON.parse(body) as { conversationId: string; tool: string; args: unknown; nativeCaller?: boolean };
|
|
toolCalls.push(data);
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
if (data.tool === "compress") {
|
|
res.end(JSON.stringify({ ok: true, result: "[Compressed m00001-m00002 -> b1]" }));
|
|
} else if (data.tool === "decompress" && opts.decompressFailure) {
|
|
res.end(JSON.stringify({ ok: true, result: "[decompress FAILED: could not write export to /tmp/x.txt: ENOENT]", outcome: "failure" }));
|
|
} else {
|
|
res.end(JSON.stringify({ ok: false, error: "boom" }));
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
if (url === "/__bili/plugin/register" && req.method === "POST") {
|
|
let body = "";
|
|
req.on("data", (c) => (body += c));
|
|
req.on("end", () => {
|
|
const data = JSON.parse(body) as { conversationId?: string; agent?: string; identity?: boolean; parentConversationId?: unknown };
|
|
registers.push({ conversationId: data.conversationId ?? "", agent: data.agent ?? "", identity: data.identity === true, ...(typeof data.parentConversationId === "string" && data.parentConversationId ? { parentConversationId: data.parentConversationId } : {}) });
|
|
if (opts.failRegister !== undefined) {
|
|
res.writeHead(opts.failRegister);
|
|
res.end("{}");
|
|
} else {
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: true }));
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
if (url === "/__bili/plugin/runtime-info" && req.method === "POST") {
|
|
let body = "";
|
|
req.on("data", (c) => (body += c));
|
|
req.on("end", () => {
|
|
runtimeInfos.push(JSON.parse(body) as Record<string, unknown>);
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: true }));
|
|
});
|
|
return;
|
|
}
|
|
if (url.startsWith("/__bili/plugin/status")) {
|
|
if (opts.statusOk === false) {
|
|
res.writeHead(404, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: false, error: "unknown plugin conversation" }));
|
|
} else {
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: true, contextTokens: 1234 }));
|
|
}
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as { port: number }).port}`;
|
|
// Idempotent close: respawn tests kill the "old" proxy mid-test and the
|
|
// finally block closes it again.
|
|
let closed = false;
|
|
return { origin, toolCalls, registers, runtimeInfos, close: () => {
|
|
if (closed) return Promise.resolve();
|
|
closed = true;
|
|
return new Promise<void>((resolve) => server.close(() => resolve()));
|
|
} };
|
|
}
|
|
|
|
test("shared manifest/tool/status against a fake proxy", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const tools = await fetchManifest(proxy.origin);
|
|
assert.equal(tools.length, 2);
|
|
assert.equal(tools[0]!.name, "compress");
|
|
const result = await forwardTool(proxy.origin, "conv-1", "compress", { content: [] });
|
|
assert.equal(result.text, "[Compressed m00001-m00002 -> b1]");
|
|
assert.equal(result.failed, false, "legacy envelope (no outcome) is not a failure");
|
|
await assert.rejects(forwardTool(proxy.origin, "conv-1", "acp_status", {}), /boom/);
|
|
const status = await fetchStatus(proxy.origin, "conv-1");
|
|
assert.equal(status?.contextTokens, 1234);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("forwardTool rejects immediately when the caller's signal is already aborted", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const ac = new AbortController();
|
|
ac.abort();
|
|
await assert.rejects(forwardTool(proxy.origin, "conv-1", "compress", { content: [] }, ac.signal), /abort/i);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
type TextBlock = { type: "text"; text: string };
|
|
type RecordedTool = { name: string; parameters: unknown; execute: (id: string, params: Record<string, unknown>, signal: undefined, onUpdate: undefined, ctx: Record<string, unknown>) => Promise<{ content: TextBlock[]; isError?: boolean }> };
|
|
|
|
type RecordedCommand = { name: string; description?: string; handler: (args: string, ctx: unknown) => void | Promise<void> };
|
|
|
|
type FakePi = {
|
|
events: Map<string, (event: unknown, ctx: unknown) => unknown>;
|
|
tools: RecordedTool[];
|
|
commands: Map<string, RecordedCommand>;
|
|
providers: Map<string, string>;
|
|
readonly registerCalls: number;
|
|
on: (event: string, handler: (event: never, ctx: never) => unknown) => void;
|
|
registerTool: (tool: RecordedTool) => void;
|
|
registerCommand: (name: string, options: RecordedCommand) => void;
|
|
registerProvider?: (name: string, config: { baseUrl: string }) => void;
|
|
// #2708: real pi exposes the registry contents; the plugin probes it to
|
|
// detect a mid-session drop. Optional so a host without it can be modeled.
|
|
getAllTools?: () => Array<{ name: string }>;
|
|
// #3542: real pi exposes the ACTIVE loadout (distinct from the registry);
|
|
// the plugin re-asserts it after a tree navigation. Optional so a host
|
|
// without it can be modeled.
|
|
activeTools: string[];
|
|
setActiveCalls: unknown[][];
|
|
getActiveTools?: () => string[];
|
|
setActiveTools?: (toolNames: string[]) => void;
|
|
};
|
|
|
|
function makeFakePi(): FakePi {
|
|
const events = new Map<string, (event: unknown, ctx: unknown) => unknown>();
|
|
const tools: RecordedTool[] = [];
|
|
const commands = new Map<string, RecordedCommand>();
|
|
const providers = new Map<string, string>();
|
|
// #3542: the active loadout, separate from the registry `tools` — a test
|
|
// can reset it (as pi's /tree does) while the registrations survive.
|
|
const activeTools: string[] = [];
|
|
const setActiveCalls: unknown[][] = [];
|
|
let registerCallCount = 0;
|
|
return {
|
|
events,
|
|
tools,
|
|
commands,
|
|
providers,
|
|
activeTools,
|
|
setActiveCalls,
|
|
get registerCalls() { return registerCallCount; },
|
|
on: (event, handler) => {
|
|
// Real pi dispatches each event to ALL registered handlers in
|
|
// registration order (the bili factory itself registers two
|
|
// session_start handlers, and #2186's wiring adds a third); a
|
|
// single-slot map would let the last registration shadow the rest.
|
|
const h = handler as (event: unknown, ctx: unknown) => unknown;
|
|
const prev = events.get(event);
|
|
events.set(event, prev ? ((e, c) => { const r = prev(e, c); return r instanceof Promise ? r.then(() => h(e, c)) : h(e, c); }) : h);
|
|
},
|
|
registerTool: (tool) => {
|
|
registerCallCount++;
|
|
const i = tools.findIndex((t) => t.name === tool.name);
|
|
if (i >= 0) tools[i] = tool;
|
|
else tools.push(tool);
|
|
},
|
|
registerCommand: (name, options) => {
|
|
commands.set(name, options);
|
|
},
|
|
registerProvider: (name, config) => {
|
|
providers.set(name, config.baseUrl);
|
|
},
|
|
// #2708: mirrors real pi's ExtensionAPI.getAllTools() — returns the
|
|
// registry contents by name. The test drops tools from `tools` directly
|
|
// to simulate pi rebuilding its registry with an empty instance map.
|
|
getAllTools: () => tools.map((t) => ({ name: t.name })),
|
|
// #3542: mirrors real pi's ExtensionAPI.getActiveTools()/setActiveTools().
|
|
// setActiveTools dedupes like pi (_setActiveTools via [...new Set(...)]).
|
|
getActiveTools: () => [...activeTools],
|
|
setActiveTools: (toolNames) => {
|
|
setActiveCalls.push([...toolNames]);
|
|
activeTools.splice(0, activeTools.length, ...new Set(toolNames));
|
|
},
|
|
};
|
|
}
|
|
|
|
function fakeCtx(proxy: FakeProxy | undefined, sessionId = "sess-42"): Record<string, unknown> {
|
|
return {
|
|
sessionManager: { getSessionId: () => sessionId },
|
|
model: { contextWindow: 1000000, baseUrl: proxy ? `${proxy.origin}/bili/https://api.example.com/v1` : "https://api.example.com/v1" },
|
|
cwd: "/tmp",
|
|
};
|
|
}
|
|
|
|
async function flush(): Promise<void> {
|
|
await new Promise((r) => setTimeout(r, 20));
|
|
}
|
|
|
|
const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
|
|
|
|
// Windows CI runners can take seconds on a cold loopback connect, so a fixed
|
|
// 20ms flush races the manifest fetch. Poll for registration instead.
|
|
async function waitForTools(pi: FakePi, count: number, timeoutMs = 15000): Promise<void> {
|
|
const deadline = Date.now() + timeoutMs;
|
|
while (pi.tools.length < count) {
|
|
if (Date.now() > deadline) throw new Error(`timed out waiting for ${count} registered tools; got ${pi.tools.length}`);
|
|
await new Promise((r) => setTimeout(r, 25));
|
|
}
|
|
}
|
|
|
|
test("#535: provider URL rewrites from env manifest applied at load", () => {
|
|
const prevRewrites = process.env.BILI_PROVIDER_REWRITES;
|
|
process.env.BILI_PROVIDER_REWRITES = JSON.stringify({
|
|
glm: "http://127.0.0.1:8787/bili/http://127.0.0.1:8199/v1",
|
|
other: "http://127.0.0.1:8787/bili/http://example.com",
|
|
});
|
|
try {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin()(pi as never);
|
|
assert.deepEqual(Object.fromEntries(pi.providers), {
|
|
glm: "http://127.0.0.1:8787/bili/http://127.0.0.1:8199/v1",
|
|
other: "http://127.0.0.1:8787/bili/http://example.com",
|
|
});
|
|
} finally {
|
|
if (prevRewrites === undefined) delete process.env.BILI_PROVIDER_REWRITES;
|
|
else process.env.BILI_PROVIDER_REWRITES = prevRewrites;
|
|
}
|
|
});
|
|
|
|
test("#535: invalid BILI_PROVIDER_REWRITES JSON → no rewrites applied", () => {
|
|
const prevRewrites = process.env.BILI_PROVIDER_REWRITES;
|
|
process.env.BILI_PROVIDER_REWRITES = "{not json";
|
|
try {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin()(pi as never);
|
|
assert.equal(pi.providers.size, 0);
|
|
} finally {
|
|
if (prevRewrites === undefined) delete process.env.BILI_PROVIDER_REWRITES;
|
|
else process.env.BILI_PROVIDER_REWRITES = prevRewrites;
|
|
}
|
|
});
|
|
|
|
test("#535: non-http(s) manifest entries are dropped", () => {
|
|
const prevRewrites = process.env.BILI_PROVIDER_REWRITES;
|
|
process.env.BILI_PROVIDER_REWRITES = JSON.stringify({ good: "http://x.example/v1", bad: "ftp://x.example", bad2: "not-a-url" });
|
|
try {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin()(pi as never);
|
|
assert.deepEqual(Object.fromEntries(pi.providers), { good: "http://x.example/v1" });
|
|
} finally {
|
|
if (prevRewrites === undefined) delete process.env.BILI_PROVIDER_REWRITES;
|
|
else process.env.BILI_PROVIDER_REWRITES = prevRewrites;
|
|
}
|
|
});
|
|
|
|
test("#535/#851: session_before_compact cancels only auto compaction under bili launch", async () => {
|
|
const prevProxy = process.env.BILLION_CONTEXT_PROXY;
|
|
process.env.BILLION_CONTEXT_PROXY = "http://127.0.0.1:8787";
|
|
try {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact");
|
|
assert.ok(handler, "pi under bili launch: handler registered");
|
|
assert.deepEqual(await handler({ reason: "threshold" }, undefined), { cancel: true });
|
|
assert.deepEqual(await handler({ reason: "overflow" }, undefined), { cancel: true });
|
|
assert.equal(await handler({ reason: "manual" }, undefined), undefined, "manual /compact stays user-owned");
|
|
assert.equal(await handler({ reason: "startup" }, undefined), undefined, "unknown reason → not cancelled");
|
|
|
|
// omp: the hook event carries no reason field, so the plugin tracks
|
|
// the auto_compaction_start announcement instead — only announced
|
|
// (auto) passes are cancelled, manual stays user-owned (#851).
|
|
const omp = makeFakePi();
|
|
createBiliPlugin("omp")(omp as never);
|
|
const ompHandler = omp.events.get("session_before_compact");
|
|
assert.ok(ompHandler, "omp under bili launch: handler registered");
|
|
assert.equal(await ompHandler({}, undefined), undefined, "unannounced (manual) compaction stays user-owned");
|
|
const ompStart = omp.events.get("auto_compaction_start");
|
|
const ompEnd = omp.events.get("auto_compaction_end");
|
|
assert.ok(ompStart, "omp tracks auto_compaction_start announcements");
|
|
assert.ok(ompEnd, "omp tracks auto_compaction_end announcements");
|
|
ompStart({}, undefined);
|
|
assert.deepEqual(await ompHandler({}, undefined), { cancel: true }, "announced auto compaction is cancelled");
|
|
assert.equal(await ompHandler({}, undefined), undefined, "the announcement is consumed by the cancel");
|
|
ompStart({}, undefined);
|
|
ompEnd({}, undefined);
|
|
assert.equal(await ompHandler({}, undefined), undefined, "aborted auto pass (end before hook) leaves manual unblocked");
|
|
} finally {
|
|
if (prevProxy === undefined) delete process.env.BILLION_CONTEXT_PROXY;
|
|
else process.env.BILLION_CONTEXT_PROXY = prevProxy;
|
|
}
|
|
});
|
|
|
|
test("#535/#519: no proxy at factory time → cancel inert until a proxy appears", async () => {
|
|
const prevProxy = process.env.BILLION_CONTEXT_PROXY;
|
|
delete process.env.BILLION_CONTEXT_PROXY;
|
|
try {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact");
|
|
assert.ok(handler, "handler registered; arming decided at event time");
|
|
assert.equal(await handler({ reason: "threshold" }, undefined), undefined, "no proxy → native compaction untouched");
|
|
// native mode (#519): BILLION_CONTEXT_PROXY lands only AFTER the factory ran
|
|
process.env.BILLION_CONTEXT_PROXY = "http://127.0.0.1:8787";
|
|
assert.deepEqual(await handler({ reason: "threshold" }, undefined), { cancel: true });
|
|
assert.deepEqual(await handler({ reason: "overflow" }, undefined), { cancel: true });
|
|
assert.equal(await handler({ reason: "manual" }, undefined), undefined, "manual /compact stays user-owned");
|
|
// /bili/ baseUrl routing (no env at all) arms the cancel too
|
|
delete process.env.BILLION_CONTEXT_PROXY;
|
|
const biliCtx = { model: { baseUrl: "http://127.0.0.1:8787/bili/https://api.example.com/v1" } };
|
|
assert.deepEqual(await handler({ reason: "threshold" }, biliCtx), { cancel: true });
|
|
} finally {
|
|
if (prevProxy === undefined) delete process.env.BILLION_CONTEXT_PROXY;
|
|
else process.env.BILLION_CONTEXT_PROXY = prevProxy;
|
|
}
|
|
});
|
|
|
|
test("#1382: compaction cancel requires evidence the proxy carries this conversation", async () => {
|
|
// Native mode sets BILLION_CONTEXT_PROXY for the whole process, but a
|
|
// provider like pi-claude-bridge runs its own child process against
|
|
// upstream directly (model.baseUrl = literal "claude-bridge") — the proxy
|
|
// never saw this conversation. Cancelling there killed ALL compaction:
|
|
// the bridge disables Claude Code's own auto-compact and takes over Pi's
|
|
// in its own session_before_compact handler, which never runs once an
|
|
// earlier handler returned cancel. The fix: positive evidence only.
|
|
const bridgeCtx = {
|
|
sessionManager: { getSessionId: () => "sess-bridge" },
|
|
model: { contextWindow: 1000000, baseUrl: "claude-bridge" },
|
|
cwd: "/tmp",
|
|
};
|
|
const httpCtx = (sid: string) => ({
|
|
sessionManager: { getSessionId: () => sid },
|
|
model: { contextWindow: 1000000, baseUrl: "https://api.example.com/v1" },
|
|
cwd: "/tmp",
|
|
});
|
|
|
|
const unknownProxy = await startFakeProxy({ statusOk: false });
|
|
const knownProxy = await startFakeProxy({ statusOk: true });
|
|
try {
|
|
// (A) The reported repro: non-http(s) provider AND the proxy has no
|
|
// such conversation → threshold/overflow must NOT be cancelled.
|
|
await withEnv({ BILLION_CONTEXT_PROXY: unknownProxy.origin }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.equal(await handler({ reason: "threshold" }, bridgeCtx), undefined, "non-http(s) provider + unknown conversation → native compaction proceeds");
|
|
assert.equal(await handler({ reason: "overflow" }, bridgeCtx), undefined, "same for overflow");
|
|
assert.equal(await handler({ reason: "manual" }, bridgeCtx), undefined, "manual /compact stays user-owned");
|
|
});
|
|
|
|
// (B) The veto alone: even if the proxy CONFIRMS the conversation id
|
|
// (stale state from an earlier proxied phase of the same session), a
|
|
// non-http(s) baseUrl means this turn's traffic cannot reach it.
|
|
await withEnv({ BILLION_CONTEXT_PROXY: knownProxy.origin }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.equal(await handler({ reason: "threshold" }, bridgeCtx), undefined, "non-http(s) baseUrl vetoes even a confirming proxy");
|
|
});
|
|
|
|
// (C) Positive evidence via the proxy: http provider, fresh instance
|
|
// (no local stamp), proxy confirms it carries the conversation → cancel.
|
|
await withEnv({ BILLION_CONTEXT_PROXY: knownProxy.origin }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.deepEqual(await handler({ reason: "threshold" }, httpCtx("sess-carried")), { cancel: true }, "proxy confirms carriage → auto compaction cancelled");
|
|
});
|
|
|
|
// (D) http provider whose traffic bypasses the proxy (e.g. a custom
|
|
// provider added after launch, never routed through it): no local
|
|
// stamp, proxy has no such conversation → native compaction proceeds.
|
|
await withEnv({ BILLION_CONTEXT_PROXY: unknownProxy.origin }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.equal(await handler({ reason: "threshold" }, httpCtx("sess-direct")), undefined, "proxy never saw this conversation → native compaction proceeds");
|
|
});
|
|
} finally {
|
|
await unknownProxy.close();
|
|
await knownProxy.close();
|
|
}
|
|
|
|
// (E) Local stamp fast path: x-bili-plugin-conversation stamped for this
|
|
// sid (tools registered + request routed through the proxy) is evidence
|
|
// on its own — no status round-trip needed, so it holds even when the
|
|
// proxy reports the conversation unknown.
|
|
const stampedProxy = await startFakeProxy({ statusOk: false });
|
|
try {
|
|
await withEnv({ BILLION_CONTEXT_PROXY: stampedProxy.origin }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const ctx = fakeCtx(stampedProxy, "sess-stamped");
|
|
await pi.events.get("session_start")!({}, ctx);
|
|
await waitForTools(pi, 2);
|
|
const headers: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers }, ctx);
|
|
assert.equal(headers["x-bili-plugin-conversation"], "sess-stamped");
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.deepEqual(await handler({ reason: "threshold" }, ctx), { cancel: true }, "locally stamped session is carried by construction");
|
|
});
|
|
} finally {
|
|
await stampedProxy.close();
|
|
}
|
|
|
|
// (F) Probe failure is safe-side: proxy unreachable (connection refused)
|
|
// and no local stamp → no evidence → defer to native compaction instead
|
|
// of cancelling into an overflow.
|
|
const probePort = await new Promise<number>((resolve) => {
|
|
const s = net.createServer();
|
|
s.listen(0, "127.0.0.1", () => {
|
|
const port = (s.address() as { port: number }).port;
|
|
s.close(() => resolve(port));
|
|
});
|
|
});
|
|
await withEnv({ BILLION_CONTEXT_PROXY: `http://127.0.0.1:${probePort}` }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.equal(await handler({ reason: "threshold" }, httpCtx("sess-down")), undefined, "unreachable proxy → no ownership evidence → native compaction proceeds");
|
|
});
|
|
|
|
// (G) omp parity: announced auto passes get the same evidence gate.
|
|
const ompCtx = httpCtx("sess-omp");
|
|
const runOmpCase = async (statusOk: boolean, expectCancel: boolean, label: string): Promise<void> => {
|
|
const proxy = await startFakeProxy({ statusOk });
|
|
try {
|
|
await withEnv({ BILLION_CONTEXT_PROXY: proxy.origin }, async () => {
|
|
const omp = makeFakePi();
|
|
createBiliPlugin("omp")(omp as never);
|
|
const handler = omp.events.get("session_before_compact")!;
|
|
omp.events.get("auto_compaction_start")!({}, undefined);
|
|
const got = await handler({}, ompCtx);
|
|
assert.deepEqual(got, expectCancel ? { cancel: true } : undefined, label);
|
|
});
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
};
|
|
await runOmpCase(true, true, "omp: proxy confirms carriage → announced auto compaction cancelled");
|
|
await runOmpCase(false, false, "omp: proxy never saw the conversation → announced auto compaction proceeds");
|
|
|
|
// (H) omp identity fast path: a successful identity register is local
|
|
// evidence — the cancel holds even though the proxy reports unknown.
|
|
const identityProxy = await startFakeProxy({ statusOk: false });
|
|
try {
|
|
await withEnv({ BILLION_CONTEXT_PROXY: identityProxy.origin }, async () => {
|
|
const omp = makeFakePi();
|
|
createBiliPlugin("omp")(omp as never);
|
|
// #1403: pck stamping (the identity signal) only fires for
|
|
// destinations bili actually processes — route through /bili/.
|
|
const ctx = { ...httpCtx("sess-omp-id"), model: { contextWindow: 1000000, baseUrl: `${identityProxy.origin}/bili/https://api.example.com/v1` } };
|
|
const payload = await omp.events.get("before_provider_request")!({ payload: { messages: [{ role: "user", content: "hi" }] } }, ctx);
|
|
assert.equal((payload as { prompt_cache_key?: string })?.prompt_cache_key, "sess-omp-id", "identity registration completed with the request");
|
|
omp.events.get("auto_compaction_start")!({}, undefined);
|
|
assert.deepEqual(await omp.events.get("session_before_compact")!({}, ctx), { cancel: true }, "identity-registered session is carried by construction");
|
|
});
|
|
} finally {
|
|
await identityProxy.close();
|
|
}
|
|
});
|
|
|
|
test("#1392: non-http(s) provider rides bili only when opted in AND carried", async () => {
|
|
// #1383's stopgap vetoed ALL non-http(s) baseUrls (e.g. pi-claude-bridge's literal
|
|
// "claude-bridge"), so a proxy's mere existence could never claim compaction for
|
|
// traffic that bypasses it. #1392 narrows that veto: an explicitly opted-in provider
|
|
// (BILI_NON_HTTP_PROVIDERS) falls through to the SAME carriage-evidence gate. Opt-in
|
|
// widens the candidate set only — unrouted traffic still never cancels (#1382 invariant).
|
|
const bridgeCtx = {
|
|
sessionManager: { getSessionId: () => "sess-optin" },
|
|
model: { contextWindow: 1000000, baseUrl: "claude-bridge", provider: "claude-bridge" },
|
|
cwd: "/tmp",
|
|
};
|
|
const unknownProxy = await startFakeProxy({ statusOk: false });
|
|
const knownProxy = await startFakeProxy({ statusOk: true });
|
|
try {
|
|
// (A) Unopted-in: byte-for-byte the #1382/stopgap behavior — even though the proxy
|
|
// confirms carriage here, no opt-in means the non-http(s) veto still holds.
|
|
await withEnv({ BILLION_CONTEXT_PROXY: knownProxy.origin, BILI_NON_HTTP_PROVIDERS: undefined }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.equal(await handler({ reason: "threshold" }, bridgeCtx), undefined, "non-opted-in non-http(s) provider stays vetoed even when the proxy confirms carriage");
|
|
});
|
|
|
|
// (B) Opted-in but UNROUTED: the veto lifts, yet there is no carriage evidence (no
|
|
// local stamp + proxy reports unknown) → still no cancel. This IS the safety property.
|
|
await withEnv({ BILLION_CONTEXT_PROXY: unknownProxy.origin, BILI_NON_HTTP_PROVIDERS: "claude-bridge" }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.equal(await handler({ reason: "threshold" }, bridgeCtx), undefined, "opted-in but unrouted → no carriage evidence → native compaction proceeds");
|
|
});
|
|
|
|
// (C) Opted-in AND routed: the proxy confirms it carries this conversation → the
|
|
// cancel now correctly fires (the whole point of the opt-in).
|
|
await withEnv({ BILLION_CONTEXT_PROXY: knownProxy.origin, BILI_NON_HTTP_PROVIDERS: "claude-bridge" }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.deepEqual(await handler({ reason: "threshold" }, bridgeCtx), { cancel: true }, "opted-in + proxy confirms carriage → compaction ownership claimed");
|
|
});
|
|
|
|
// (D) Mismatched allowlist id: opting in a DIFFERENT provider does not lift the veto
|
|
// for this one — ids match exactly, so a typo cannot accidentally opt a provider in.
|
|
await withEnv({ BILLION_CONTEXT_PROXY: knownProxy.origin, BILI_NON_HTTP_PROVIDERS: "some-other-provider" }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.equal(await handler({ reason: "threshold" }, bridgeCtx), undefined, "allowlist naming a different provider does not opt this one in");
|
|
});
|
|
|
|
// (E) [#1392 Phase A guard] Opt-in widens ONLY the compaction-ownership candidate
|
|
// set — it must never widen wire-side routing: a non-http baseUrl stays outside
|
|
// destinationRoutedThroughProxy (no /bili/ rewrites, no stamped cache keys, no MITM
|
|
// candidacy), whatever BILI_NON_HTTP_PROVIDERS says. Guards Phase B against
|
|
// accidentally wiring the flag into stamp eligibility.
|
|
await withEnv({ BILLION_CONTEXT_PROXY: knownProxy.origin, BILI_NON_HTTP_PROVIDERS: "claude-bridge" }, async () => {
|
|
assert.equal(destinationRoutedThroughProxy("claude-bridge"), false, "opt-in must not route a non-http baseUrl through the proxy wire surface");
|
|
assert.equal(destinationRoutedThroughProxy("claude-bridge://x"), false, "opaque scheme never parses as routable");
|
|
});
|
|
} finally {
|
|
await unknownProxy.close();
|
|
await knownProxy.close();
|
|
}
|
|
});
|
|
|
|
test("#1961: virtual-model selection resolves compaction ownership from the physical route", async () => {
|
|
// pi 0.99+ virtual models (router/auto, api "pi-virtual") carry an empty
|
|
// baseUrl — the selection names a router, not a destination. With no
|
|
// BILLION_CONTEXT_PROXY in env (manual /bili/-wrapped models.json routing),
|
|
// detectProxyBase("") had nothing to read, so ownsCompaction bailed even
|
|
// though the physical requests reached the proxy → double compression.
|
|
// Ownership now resolves from where the traffic actually went: the latest
|
|
// non-failed assistant response's registry baseUrl, then the rewrites
|
|
// manifest, then the env fallback — keeping the carriage-evidence gates
|
|
// (#1382/#1392) intact.
|
|
const knownProxy = await startFakeProxy({ statusOk: true });
|
|
const unknownProxy = await startFakeProxy({ statusOk: false });
|
|
try {
|
|
const assistantEntry = (provider: string, model: string, stopReason = "stop") => ({
|
|
type: "message",
|
|
message: { role: "assistant", content: [], api: "anthropic-messages", provider, model, stopReason, usage: {}, timestamp: Date.now() },
|
|
});
|
|
const virtualCtx = (branch: unknown, extra: Record<string, unknown> = {}) => ({
|
|
sessionManager: { getSessionId: () => "sess-virtual", getBranch: () => branch },
|
|
model: { contextWindow: 1000000, baseUrl: "", provider: "router", id: "auto", api: "pi-virtual" },
|
|
cwd: "/tmp",
|
|
...extra,
|
|
});
|
|
const run = async (env: Record<string, string | undefined>, ctx: unknown, eventBranchEntries?: unknown): Promise<unknown> => {
|
|
let result: unknown;
|
|
await withEnv(env, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
const event: Record<string, unknown> = { reason: "threshold" };
|
|
if (eventBranchEntries !== undefined) event.branchEntries = eventBranchEntries;
|
|
result = await handler(event, ctx);
|
|
});
|
|
return result;
|
|
};
|
|
// Shaped like the REAL host surface: pi 0.99 ModelRegistry exposes
|
|
// find(provider, modelId), not getModel — a stub inventing a
|
|
// non-existent method once let this tier pass tests as dead code on
|
|
// the live host (#1943 lesson, restated for #1961).
|
|
const wrappedRegistry = (origin: string) => ({ find: (provider: string, modelId: string) => (provider === "anthropic" && modelId === "claude-x" ? { baseUrl: `${origin}/bili/https://api.anthropic.com/v1` } : undefined) });
|
|
const noProxyEnv = { BILLION_CONTEXT_PROXY: undefined, BILI_PROVIDER_REWRITES: undefined };
|
|
|
|
// (A) The reported repro: no env, the registry holds the physically
|
|
// routed (manually /bili/-wrapped) baseUrl of the model that answered
|
|
// → the exact proxy is resolved and confirms carriage → cancel.
|
|
assert.deepEqual(
|
|
await run(noProxyEnv, virtualCtx([assistantEntry("anthropic", "claude-x")], { modelRegistry: wrappedRegistry(knownProxy.origin) }), [assistantEntry("anthropic", "claude-x")]),
|
|
{ cancel: true },
|
|
"registry-wrapped physical route resolves the proxy without env",
|
|
);
|
|
|
|
// (B) Same route, but the proxy never saw this conversation → the
|
|
// carriage gate still vetoes: resolving WHICH proxy must not bypass #1382.
|
|
assert.equal(
|
|
await run(noProxyEnv, virtualCtx([assistantEntry("anthropic", "claude-x")], { modelRegistry: wrappedRegistry(unknownProxy.origin) }), [assistantEntry("anthropic", "claude-x")]),
|
|
undefined,
|
|
"resolved but uncarried conversation → native compaction proceeds",
|
|
);
|
|
|
|
// (C) Host without modelRegistry on the ctx AND no branchEntries on the
|
|
// event: falls back to ctx.sessionManager.getBranch(), then to the
|
|
// launcher rewrites manifest for the answering provider.
|
|
assert.deepEqual(
|
|
await run({ BILLION_CONTEXT_PROXY: undefined, BILI_PROVIDER_REWRITES: JSON.stringify({ anthropic: `${knownProxy.origin}/bili/https://api.anthropic.com/v1` }) }, virtualCtx([assistantEntry("anthropic", "claude-x")])),
|
|
{ cancel: true },
|
|
"getBranch + manifest rewrite resolve the proxy",
|
|
);
|
|
|
|
// (D) No evidence anywhere: raw upstream baseUrl, no manifest, no env →
|
|
// the traffic genuinely bypassed the proxy → native compaction proceeds.
|
|
assert.equal(
|
|
await run(noProxyEnv, virtualCtx([assistantEntry("anthropic", "claude-x")], { modelRegistry: { find: () => ({ baseUrl: "https://api.anthropic.com/v1" }) } }), [assistantEntry("anthropic", "claude-x")]),
|
|
undefined,
|
|
"unwrapped upstream + no env → no proxy candidate",
|
|
);
|
|
|
|
// (E) Failed routing attempts are skipped when finding the last response
|
|
// (mirrors pi's findLatestResponse).
|
|
assert.deepEqual(
|
|
await run(noProxyEnv, virtualCtx([assistantEntry("anthropic", "claude-x"), assistantEntry("openai", "gpt-x", "error")], { modelRegistry: wrappedRegistry(knownProxy.origin) }), [assistantEntry("anthropic", "claude-x"), assistantEntry("openai", "gpt-x", "error")]),
|
|
{ cancel: true },
|
|
"error/aborted tail entries do not mask the carrying route",
|
|
);
|
|
|
|
// (F) Fresh session (nothing answered yet): degrades to the env
|
|
// fallback — no candidate without env; old behavior holds with env set.
|
|
assert.equal(await run(noProxyEnv, virtualCtx([])), undefined, "no responses and no env → native compaction proceeds");
|
|
assert.deepEqual(await run({ BILLION_CONTEXT_PROXY: knownProxy.origin, BILI_PROVIDER_REWRITES: undefined }, virtualCtx([])), { cancel: true }, "env fallback still arms when env is set");
|
|
|
|
// (G) Local-stamp fast path is reachable for virtual sessions too:
|
|
// before_provider_headers resolves the same way, stamps the sid, and
|
|
// ownership then needs no status round-trip.
|
|
const stampedProxy = await startFakeProxy({ statusOk: false });
|
|
try {
|
|
await withEnv(noProxyEnv, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const ctx = virtualCtx([assistantEntry("anthropic", "claude-x")], { modelRegistry: wrappedRegistry(stampedProxy.origin) });
|
|
await pi.events.get("session_start")!({}, ctx);
|
|
await waitForTools(pi, 2);
|
|
const headers: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers }, ctx);
|
|
assert.equal(headers["x-bili-plugin-conversation"], "sess-virtual", "virtual session stamps its conversation id without env");
|
|
const handler = pi.events.get("session_before_compact")!;
|
|
assert.deepEqual(await handler({ reason: "threshold" }, ctx), { cancel: true }, "locally stamped virtual session is carried by construction");
|
|
});
|
|
} finally {
|
|
await stampedProxy.close();
|
|
}
|
|
|
|
// (H) Non-virtual selections are untouched by the new path.
|
|
const emptyPhysical = {
|
|
sessionManager: { getSessionId: () => "sess-phys" },
|
|
model: { contextWindow: 1000000, baseUrl: "" },
|
|
cwd: "/tmp",
|
|
};
|
|
assert.equal(await run(noProxyEnv, emptyPhysical), undefined, "physical model with empty baseUrl keeps today's behavior (no env → no proxy)");
|
|
const biliPhysical = { ...emptyPhysical, model: { contextWindow: 1000000, baseUrl: `${knownProxy.origin}/bili/https://api.example.com/v1` } };
|
|
assert.deepEqual(await run(noProxyEnv, biliPhysical), { cancel: true }, "/bili/-wrapped physical baseUrl still cancels");
|
|
|
|
// (I) Kill switch wins over every virtual-model candidate.
|
|
assert.equal(
|
|
await run({ BILLION_CONTEXT_PLUGIN: "0", BILLION_CONTEXT_PROXY: undefined, BILI_PROVIDER_REWRITES: undefined }, virtualCtx([assistantEntry("anthropic", "claude-x")], { modelRegistry: wrappedRegistry(knownProxy.origin) }), [assistantEntry("anthropic", "claude-x")]),
|
|
undefined,
|
|
"BILLION_CONTEXT_PLUGIN=0 disables ownership even for virtual routes",
|
|
);
|
|
} finally {
|
|
await unknownProxy.close();
|
|
await knownProxy.close();
|
|
}
|
|
});
|
|
|
|
test("pi extension registers manifest tools and stamps headers when proxied", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
// The header is only stamped once tools are registered, so register
|
|
// first (a real session does this via session_start before the first
|
|
// provider request; launcher-mode -p wins that race via the load-time
|
|
// manifest prime — #1217, covered by the dedicated test below).
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
const headers: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers }, fakeCtx(proxy));
|
|
assert.equal(headers["x-bili-plugin"], "pi");
|
|
assert.equal(headers["x-bili-plugin-conversation"], "sess-42");
|
|
assert.equal(headers["x-bili-plugin-context-window"], "1000000");
|
|
assert.equal(headers["x-bili-plugin-purpose"], "conversation", "#6884: every pi dispatch is a declared main turn (pi has no aux calls)");
|
|
assert.equal(pi.tools.length, 2);
|
|
assert.equal(pi.tools[0]!.name, "compress");
|
|
assert.deepEqual(pi.tools[0]!.parameters, { type: "object", properties: { content: { type: "array" } }, required: ["content"] });
|
|
const out = await pi.tools[0]!.execute("call-1", { content: [] }, undefined, undefined, fakeCtx(proxy));
|
|
assert.equal(out.content[0]!.text, "[Compressed m00001-m00002 -> b1]");
|
|
assert.equal(out.isError, undefined);
|
|
// #2072: the pi host stamps its session-manager id as a confirmed
|
|
// native caller — the captured wire body carries the flag.
|
|
assert.deepEqual(proxy.toolCalls, [{ conversationId: "sess-42", tool: "compress", args: { content: [] }, nativeCaller: true, toolCallId: "call-1" }]);
|
|
const errOut = await pi.tools[1]!.execute("call-2", {}, undefined, undefined, fakeCtx(proxy));
|
|
assert.match(errOut.content[0]!.text, /bili tool error:.*boom/);
|
|
assert.equal(errOut.isError, true);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#2204: a business-failure receipt (ok:true + outcome:failure) reaches the host as isError with full text", async () => {
|
|
const proxy = await startFakeProxy({ decompressFailure: true });
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 3);
|
|
const decompress = pi.tools.find((t) => t.name === "decompress");
|
|
assert.ok(decompress, "manifest serves the decompress slot");
|
|
// The exact OMP shape from #2204: a toFile export that the proxy could
|
|
// not write. The endpoint says ok:true (the tool RAN) — only outcome
|
|
// marks it failed, and the host must render isError accordingly.
|
|
const out = await decompress!.execute("call-1", { blockId: "b2", toFile: "local://bili-investigation-b2.txt" }, undefined, undefined, fakeCtx(proxy));
|
|
assert.equal(out.isError, true, "business failure must surface as isError (the #2204 gap)");
|
|
assert.match(out.content[0]!.text, /^\[decompress FAILED:/, "the full receipt text is preserved");
|
|
assert.match(out.content[0]!.text, /could not write export/);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#2416: registered tools track the respawned proxy origin — live re-read per call, no restart", async () => {
|
|
const oldProxy = await startFakeProxy();
|
|
const newProxy = await startFakeProxy();
|
|
const prevEnv = process.env.BILLION_CONTEXT_PROXY;
|
|
// Native-mode shape: the model baseUrl is the REAL upstream (no /bili/
|
|
// prefix), so the proxy origin lives ONLY in BILLION_CONTEXT_PROXY — the
|
|
// channel the interceptor rewrites when it respawns the proxy mid-session
|
|
// (pi-native.ts writes process.env.BILLION_CONTEXT_PROXY on
|
|
// (re-)establishment). The captured-at-registration base must not outlive
|
|
// the origin it names.
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-42" },
|
|
model: { contextWindow: 1000000, baseUrl: "https://api.example.com/v1" },
|
|
cwd: "/tmp",
|
|
};
|
|
process.env.BILLION_CONTEXT_PROXY = oldProxy.origin;
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, ctx);
|
|
await waitForTools(pi, 2);
|
|
let out = await pi.tools[0]!.execute("call-1", { content: [] }, undefined, undefined, ctx);
|
|
assert.equal(out.isError, undefined, "baseline: first call lands on the registered origin");
|
|
assert.equal(oldProxy.toolCalls.length, 1);
|
|
assert.equal(newProxy.toolCalls.length, 0);
|
|
// Respawn: the old proxy dies and the interceptor publishes the new
|
|
// origin through the env channel. No host restart, no re-registration.
|
|
await oldProxy.close();
|
|
process.env.BILLION_CONTEXT_PROXY = newProxy.origin;
|
|
out = await pi.tools[0]!.execute("call-2", { content: [] }, undefined, undefined, ctx);
|
|
assert.equal(out.isError, undefined, "the tool must reach the respawned proxy, not keep firing at the dead port");
|
|
assert.match(out.content[0]!.text, /\[Compressed/);
|
|
assert.deepEqual(newProxy.toolCalls, [{ conversationId: "sess-42", tool: "compress", args: { content: [] }, nativeCaller: true, toolCallId: "call-2" }]);
|
|
assert.equal(oldProxy.toolCalls.length, 1, "nothing further may hit the dead origin");
|
|
} finally {
|
|
if (prevEnv === undefined) delete process.env.BILLION_CONTEXT_PROXY;
|
|
else process.env.BILLION_CONTEXT_PROXY = prevEnv;
|
|
await Promise.allSettled([oldProxy.close(), newProxy.close()]);
|
|
}
|
|
});
|
|
|
|
test("#1214: before_provider_headers awaits tool registration — one-shot (-p) first request claims plugin mode", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
// The -p shape: NO session_start prewarm — the one and only request
|
|
// dispatches at boot. pi's runner awaits async handlers, so awaiting
|
|
// the handler mirrors the real host; the stamp must already carry
|
|
// the full plugin-ownership header set on the FIRST fire.
|
|
const headers: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers }, fakeCtx(proxy));
|
|
assert.equal(headers["x-bili-plugin"], "pi");
|
|
assert.equal(headers["x-bili-plugin-conversation"], "sess-42");
|
|
assert.equal(headers["x-bili-plugin-context-window"], "1000000");
|
|
assert.equal(pi.tools.length, 2, "tools registered before the request could leave");
|
|
// Subsequent fires stay stamped (cached registration, no re-fetch).
|
|
const again: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers: again }, fakeCtx(proxy));
|
|
assert.equal(again["x-bili-plugin"], "pi");
|
|
assert.equal(again["x-bili-plugin-purpose"], "conversation", "#6884: one-shot `pi -p` sessions are main turns too");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("before_provider_headers stamps after a session_start prewarm too", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
const late: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers: late }, fakeCtx(proxy));
|
|
assert.equal(late["x-bili-plugin"], "pi");
|
|
assert.equal(late["x-bili-plugin-conversation"], "sess-42");
|
|
assert.equal(late["x-bili-plugin-purpose"], "conversation");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#2708: a mid-session registry rebuild that drops bili tools self-heals on the next request", async () => {
|
|
const proxy = await startFakeProxy();
|
|
const stateHome = fs.mkdtempSync(path.join(os.tmpdir(), "bc-plugin-agent-log-"));
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
assert.equal(pi.tools.length, 2, "baseline: both manifest tools registered");
|
|
const before = pi.registerCalls;
|
|
|
|
const termLines: string[] = [];
|
|
const origWarn = console.warn;
|
|
const headers: Record<string, string> = {};
|
|
console.warn = (...args: unknown[]) => { termLines.push(args.map(String).join(" ")); };
|
|
try {
|
|
await withEnv({ XDG_STATE_HOME: stateHome }, async () => {
|
|
// pi rebuilds its registry while our instance's tool map is empty
|
|
// (runtime replacement / reload): the ACP tools vanish from the
|
|
// executable list, but our plugin still believes they're registered.
|
|
pi.tools.length = 0;
|
|
await pi.events.get("before_provider_headers")!({ headers }, fakeCtx(proxy));
|
|
});
|
|
} finally {
|
|
console.warn = origWarn;
|
|
}
|
|
|
|
assert.equal(pi.tools.length, 2, "the dropped tools were re-registered");
|
|
assert.ok(pi.tools.some((t) => t.name === "compress"), "compress restored");
|
|
assert.equal(headers["x-bili-plugin"], "pi", "ownership header still stamped after recovery");
|
|
assert.equal(headers["x-bili-plugin-conversation"], "sess-42");
|
|
assert.equal(pi.registerCalls, before + 2, "exactly the two dropped tools were re-asserted");
|
|
const dropLogPath = path.join(stateHome, "billion-context", "bili.log");
|
|
const dropLines = (fs.existsSync(dropLogPath) ? fs.readFileSync(dropLogPath, "utf8") : "").split("\n").filter((l) => l.length > 0 && l.includes("dropped from the host registry"));
|
|
assert.ok(dropLines.length >= 1, `the silent drop is logged in bili.log, got: ${JSON.stringify(dropLines)}`);
|
|
assert.ok(dropLines.some((l) => l.includes("compress")), "the dropped tool name is named in the log");
|
|
assert.equal(termLines.filter((w) => w.includes("dropped from the host registry")).length, 0, "#2831: must not reach the terminal surface");
|
|
} finally {
|
|
await proxy.close();
|
|
fs.rmSync(stateHome, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("#2708: the fast path skips re-registration when nothing was dropped", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
const before = pi.registerCalls;
|
|
|
|
const warns: string[] = [];
|
|
const origWarn = console.warn;
|
|
const h1: Record<string, string> = {};
|
|
const h2: Record<string, string> = {};
|
|
console.warn = (...args: unknown[]) => { warns.push(args.map(String).join(" ")); };
|
|
try {
|
|
await pi.events.get("before_provider_headers")!({ headers: h1 }, fakeCtx(proxy));
|
|
await pi.events.get("before_provider_headers")!({ headers: h2 }, fakeCtx(proxy));
|
|
} finally {
|
|
console.warn = origWarn;
|
|
}
|
|
|
|
assert.equal(pi.registerCalls, before, "no redundant re-registration when the tools are intact");
|
|
assert.equal(warns.filter((w) => w.includes("dropped from the host registry")).length, 0, "no spurious drop warning");
|
|
assert.equal(h1["x-bili-plugin"], "pi");
|
|
assert.equal(h2["x-bili-plugin"], "pi");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#2708: a host without a registry query keeps the once-per-sid behavior", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
delete pi.getAllTools; // older pi / omp: no registry query surface
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
const before = pi.registerCalls;
|
|
// Drop the tools from the host registry. With no query available the
|
|
// plugin cannot detect it and must NOT crash or guess-re-register.
|
|
pi.tools.length = 0;
|
|
const headers: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers }, fakeCtx(proxy));
|
|
assert.equal(pi.registerCalls, before, "no blind re-registration without a registry query");
|
|
assert.equal(pi.tools.length, 0, "nothing re-registered on a host that exposes no query");
|
|
assert.equal(headers["x-bili-plugin"], "pi", "ownership claim is independent of the probe");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#2708: a same-id session_start after a drop re-asserts during registration", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
// pi drops the tools, then a same-id session_start (resume/reload) fires.
|
|
// Its register loop is skipped (toolsFor already === sid), so healing
|
|
// depends on the post-registration re-assert, not the loop.
|
|
pi.tools.length = 0;
|
|
assert.equal(pi.tools.length, 0, "precondition: tools dropped from the registry");
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
// Recovery runs inside the async registration block (manifest fetch),
|
|
// so poll rather than asserting synchronously.
|
|
await waitForTools(pi, 2);
|
|
assert.ok(pi.tools.some((t) => t.name === "compress"), "tools re-asserted on same-id session_start");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#3542: a /tree rewind that resets the active loadout self-heals on session_tree", async () => {
|
|
const proxy = await startFakeProxy();
|
|
const stateHome = fs.mkdtempSync(path.join(os.tmpdir(), "bc-plugin-agent-log-"));
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
pi.activeTools.splice(0, pi.activeTools.length, "bash", "read", "compress", "acp_status");
|
|
const before = pi.registerCalls;
|
|
|
|
await withEnv({ XDG_STATE_HOME: stateHome }, async () => {
|
|
// pi's navigateTree() rewinds past the entry that declared our tools
|
|
// and _restoreToolsFromTranscript() resets the loadout to what
|
|
// survives — the definitions stay in the registry, only the loadout
|
|
// loses them (the exact shape #2708's probe cannot see).
|
|
pi.activeTools.splice(0, pi.activeTools.length, "bash", "read");
|
|
assert.deepEqual([...pi.getAllTools!().map((t) => t.name)].sort(), ["acp_status", "compress"], "precondition: definitions still registered");
|
|
await pi.events.get("session_tree")!({ type: "session_tree", newLeafId: null, oldLeafId: "leaf-1" }, undefined);
|
|
});
|
|
|
|
assert.deepEqual([...pi.activeTools].sort(), ["acp_status", "bash", "compress", "read"], "the dropped tools are back in the active loadout");
|
|
assert.equal(pi.registerCalls, before, "no re-registration needed — the definitions never left the registry");
|
|
const dropLogPath = path.join(stateHome, "billion-context", "bili.log");
|
|
const dropLines = (fs.existsSync(dropLogPath) ? fs.readFileSync(dropLogPath, "utf8") : "").split("\n").filter((l) => l.length > 0 && l.includes("dropped from the active loadout"));
|
|
assert.ok(dropLines.length >= 1, `the silent loadout reset is logged in bili.log, got: ${JSON.stringify(dropLines)}`);
|
|
assert.ok(dropLines.some((l) => l.includes("compress")), "the dropped tool name is named in the log");
|
|
} finally {
|
|
await proxy.close();
|
|
fs.rmSync(stateHome, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("#3542: the re-assert is additive-only — names the host holds are never removed", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
// Host keeps its own tools plus one of ours active; the rewind drops
|
|
// only acp_status from the loadout.
|
|
pi.activeTools.splice(0, pi.activeTools.length, "bash", "read", "compress");
|
|
await pi.events.get("session_tree")!({ type: "session_tree", newLeafId: null, oldLeafId: "leaf-1" }, undefined);
|
|
assert.equal(pi.setActiveCalls.length, 1, "exactly one setter call");
|
|
assert.deepEqual(pi.setActiveCalls[0], ["bash", "read", "compress", "acp_status"], "previously-active names kept, missing ones appended");
|
|
assert.deepEqual(pi.activeTools, ["bash", "read", "compress", "acp_status"]);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#3542: the fast path leaves the loadout untouched when nothing was dropped", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
pi.activeTools.splice(0, pi.activeTools.length, "bash", "read", "compress", "acp_status");
|
|
const before = pi.registerCalls;
|
|
await pi.events.get("session_tree")!({ type: "session_tree", newLeafId: null, oldLeafId: "leaf-1" }, undefined);
|
|
assert.equal(pi.setActiveCalls.length, 0, "no setter call when the loadout is intact");
|
|
assert.equal(pi.registerCalls, before, "no re-registration either");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#3542: a host without a loadout query/setter keeps working", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
delete pi.getActiveTools;
|
|
delete pi.setActiveTools; // older pi / omp: no loadout surface
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
pi.activeTools.splice(0, pi.activeTools.length, "bash", "read");
|
|
await pi.events.get("session_tree")!({ type: "session_tree", newLeafId: null, oldLeafId: "leaf-1" }, undefined);
|
|
assert.equal(pi.setActiveCalls.length, 0, "no blind set without a loadout surface");
|
|
assert.deepEqual(pi.activeTools, ["bash", "read"], "loadout untouched");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#3542: a throwing loadout query degrades to a no-op", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
pi.getActiveTools = () => { throw new Error("ctx is stale"); };
|
|
await pi.events.get("session_tree")!({ type: "session_tree", newLeafId: null, oldLeafId: "leaf-1" }, undefined);
|
|
assert.equal(pi.setActiveCalls.length, 0, "never sets blindly after a failed query");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#1217: launcher-mode manifest fetch is primed at extension load time", async () => {
|
|
// Correctness of the -p first-request stamp under ANY latency is #1228's
|
|
// awaited ownership claim; this prime is the latency half: the manifest
|
|
// fetch must be IN FLIGHT before any event fires (load time, not
|
|
// session_start), so that awaited claim resolves without waiting on the
|
|
// network RTT. omp has no header hook at all — for it the prime is the
|
|
// only way round 1 can carry plugin headers. Assert on observed request
|
|
// arrival, not wall-clock margins.
|
|
const manifest = JSON.stringify({ tools: { anthropic: [
|
|
{ name: "compress", description: "c", input_schema: { type: "object", properties: {} } },
|
|
{ name: "acp_status", description: "s", input_schema: { type: "object", properties: {} } },
|
|
] } });
|
|
let manifestHits = 0;
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url === "/__bili/plugin/manifest") {
|
|
manifestHits++;
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(manifest);
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
|
|
try {
|
|
const ctx = { sessionManager: { getSessionId: () => "sess-42" }, model: { contextWindow: 1000000, baseUrl: "https://api.example.com/v1" } };
|
|
await withEnv({ BILLION_CONTEXT_PROXY: origin }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const deadline = Date.now() + 5000;
|
|
while (manifestHits === 0 && Date.now() < deadline) await sleep(5);
|
|
assert.ok(manifestHits >= 1, "manifest fetch must already be in flight before any event (load-time prime)");
|
|
await pi.events.get("session_start")!({}, ctx);
|
|
await waitForTools(pi, 2);
|
|
const headers: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers }, ctx);
|
|
assert.equal(headers["x-bili-plugin"], "pi");
|
|
assert.equal(headers["x-bili-plugin-conversation"], "sess-42");
|
|
assert.equal(pi.tools.length, 2);
|
|
});
|
|
} finally {
|
|
server.close();
|
|
}
|
|
});
|
|
|
|
test("#1217: a failed manifest prime falls back to the event-time fetch and retry throttle", async () => {
|
|
// A failed prime must degrade to the EXISTING event-time path: one
|
|
// fallback fetch, then retry-throttled. With #1228's awaited claim, round
|
|
// 1 rides wire mode while throttled, and the next awaited event performs
|
|
// the recovery fetch and stamps in the same call. The first two requests
|
|
// always fail and later ones succeed, so settlement is detected by
|
|
// observed request arrival — never by wall-clock margins.
|
|
let manifestRequests = 0;
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url === "/__bili/plugin/manifest") {
|
|
manifestRequests++;
|
|
if (manifestRequests > 2) {
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ tools: { anthropic: [
|
|
{ name: "compress", description: "c", input_schema: { type: "object", properties: {} } },
|
|
{ name: "acp_status", description: "s", input_schema: { type: "object", properties: {} } },
|
|
] } }));
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
|
|
try {
|
|
const ctx = { sessionManager: { getSessionId: () => "sess-42" }, model: { contextWindow: 1000000, baseUrl: "https://api.example.com/v1" } };
|
|
await withEnv({ BILLION_CONTEXT_PROXY: origin }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi", { retryIntervalMs: 500 })(pi as never);
|
|
// Request #1 = the failed load-time prime; request #2 = the
|
|
// event-time fallback fetch kicked off by session_start. Wait
|
|
// until BOTH are observed at the still-failing server, then drain.
|
|
await pi.events.get("session_start")!({}, ctx);
|
|
const settleDeadline = Date.now() + 5000;
|
|
while (manifestRequests < 2 && Date.now() < settleDeadline) await sleep(5);
|
|
assert.ok(manifestRequests >= 2, "failed prime must fall through to the event-time fetch");
|
|
await flush();
|
|
assert.equal(pi.tools.length, 0, "two failed fetches → no tools yet");
|
|
// Round 1 while throttled: the awaited claim finds retryAt armed →
|
|
// NO third request, NO stamp — graceful wire-mode degradation.
|
|
const round1: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers: round1 }, ctx);
|
|
assert.deepEqual(round1, {}, "throttled round 1 rides wire mode");
|
|
assert.equal(manifestRequests, 2, "throttle window makes no extra fetches");
|
|
// Recovery: once the throttle expires, the next awaited event does
|
|
// exactly one recovery fetch and stamps in the same call.
|
|
let stamped: Record<string, string> | undefined;
|
|
const recoverDeadline = Date.now() + 5000;
|
|
while (!stamped && Date.now() < recoverDeadline) {
|
|
const h: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers: h }, ctx);
|
|
if (h["x-bili-plugin"] === "pi") stamped = h;
|
|
else await sleep(10);
|
|
}
|
|
assert.ok(stamped !== undefined, "recovery fetch succeeds once the throttle expires");
|
|
assert.equal(stamped["x-bili-plugin-conversation"], "sess-42");
|
|
assert.equal(pi.tools.length, 2);
|
|
assert.equal(manifestRequests, 3, "recovery is a single fetch, not a storm");
|
|
});
|
|
} finally {
|
|
server.close();
|
|
}
|
|
});
|
|
|
|
test("#1217: kill switch suppresses the load-time manifest prime", async () => {
|
|
let manifestHits = 0;
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url === "/__bili/plugin/manifest") {
|
|
manifestHits++;
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ tools: { anthropic: [] } }));
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
|
|
try {
|
|
await withEnv({ BILLION_CONTEXT_PROXY: origin, BILLION_CONTEXT_PLUGIN: "0" }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
await sleep(50);
|
|
assert.equal(manifestHits, 0, "BILLION_CONTEXT_PLUGIN=0 must keep the plugin fully inert at load time");
|
|
});
|
|
} finally {
|
|
server.close();
|
|
}
|
|
});
|
|
|
|
test("before_provider_headers stays silent when the manifest fetch keeps failing", async () => {
|
|
// Graceful degradation: a dead manifest endpoint means the plugin never
|
|
// claims ownership, so the session rides the proxy's wire mode forever.
|
|
// #1214: the handler must RESOLVE (bounded await), never throw.
|
|
const server = http.createServer((req, res) => {
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(origin as unknown as FakeProxy));
|
|
await flush();
|
|
await flush();
|
|
assert.equal(pi.tools.length, 0);
|
|
const headers: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers }, fakeCtx(origin as unknown as FakeProxy));
|
|
assert.deepEqual(headers, {});
|
|
} finally {
|
|
server.close();
|
|
}
|
|
});
|
|
|
|
test("pi extension survives hostile host shapes without throwing", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
pi.events.get("before_provider_headers")!({}, {});
|
|
pi.events.get("before_provider_headers")!({ headers: null }, fakeCtx(proxy));
|
|
pi.events.get("before_provider_headers")!({ headers: [] }, { sessionManager: {}, model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` } });
|
|
await pi.events.get("session_start")!({}, {});
|
|
await waitForTools(pi, 2);
|
|
// proxied baseUrl above intentionally triggers header-fallback registration
|
|
assert.equal(pi.tools.length, 2);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("registration retries are throttled and deduped", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
assert.equal(pi.tools.length, 2);
|
|
const calls = proxy.toolCalls.length;
|
|
for (let i = 0; i < 5; i++) pi.events.get("before_provider_headers")!({ headers: {} }, fakeCtx(proxy));
|
|
await flush();
|
|
assert.equal(pi.tools.length, 2);
|
|
assert.equal(proxy.toolCalls.length, calls);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("pi extension is inert without a proxy", async () => {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
const headers: Record<string, string> = {};
|
|
pi.events.get("before_provider_headers")!({ headers }, fakeCtx(undefined));
|
|
assert.deepEqual(headers, {});
|
|
await pi.events.get("session_start")!({}, fakeCtx(undefined));
|
|
await flush();
|
|
assert.equal(pi.tools.length, 0);
|
|
});
|
|
|
|
test("/acp command is registered and renders proxy status", async () => {
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url?.startsWith("/__bili/plugin/status")) {
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({
|
|
ok: true,
|
|
contextLimit: 200000,
|
|
contextTokens: 12345,
|
|
inputTokens: 10000,
|
|
outputTokens: 1234,
|
|
cachedTokens: 8000,
|
|
requests: 7,
|
|
blocks: [{ id: "b1", tier: 1, active: true }, { id: "b2", tier: 2, active: false }],
|
|
}));
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as { port: number }).port}`;
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
const cmd = pi.commands.get("acp");
|
|
assert.ok(cmd, "acp command should be registered");
|
|
assert.match(cmd!.description ?? "", /ACP/);
|
|
const notes: Array<{ msg: string; type?: string }> = [];
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-acp" },
|
|
model: { baseUrl: `${origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string, type?: string) => notes.push({ msg, type }) },
|
|
};
|
|
await cmd!.handler("", ctx);
|
|
assert.equal(notes.length, 1);
|
|
assert.equal(notes[0]!.type, "info");
|
|
assert.match(notes[0]!.msg, /📊 ACP status/);
|
|
assert.match(notes[0]!.msg, /context: 12\.3K \/ 200\.0K \(6\.2%\)/);
|
|
assert.match(notes[0]!.msg, /in\/out\/cached: 10\.0K \/ 1\.2K \/ 8\.0K/);
|
|
assert.match(notes[0]!.msg, /requests: 7/);
|
|
assert.match(notes[0]!.msg, /blocks: 2 \(1 active\)/);
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
});
|
|
|
|
test("/acp command warns when no proxy is detected", async () => {
|
|
await withEnv({ BILLION_CONTEXT_PROXY: undefined }, async () => {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
const cmd = pi.commands.get("acp")!;
|
|
const notes: Array<{ msg: string; type?: string }> = [];
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess" },
|
|
model: { baseUrl: "https://api.example.com/v1" },
|
|
ui: { notify: (msg: string, type?: string) => notes.push({ msg, type }) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(notes.length, 1);
|
|
assert.equal(notes[0]!.type, "warning");
|
|
// #788: neutral wording — offers BOTH exits (proxy mode or remove the
|
|
// plugin) instead of assuming proxy intent.
|
|
assert.match(notes[0]!.msg, /no proxy detected/);
|
|
assert.match(notes[0]!.msg, /run via `bili pi` \(or set a \/bili\/ baseURL\) to use proxy mode/);
|
|
assert.match(notes[0]!.msg, /`bili plugin remove pi`/);
|
|
assert.match(notes[0]!.msg, /billion-context-pi/);
|
|
});
|
|
});
|
|
|
|
test("/acp no-proxy warning offers the remove exit for omp without billion-context-pi mention", async () => {
|
|
await withEnv({ BILLION_CONTEXT_PROXY: undefined }, async () => {
|
|
const pi = makeFakePi();
|
|
ompPlugin(pi as never);
|
|
const cmd = pi.commands.get("acp")!;
|
|
const notes: Array<{ msg: string; type?: string }> = [];
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess" },
|
|
model: { baseUrl: "https://api.example.com/v1" },
|
|
ui: { notify: (msg: string, type?: string) => notes.push({ msg, type }) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(notes.length, 1);
|
|
assert.equal(notes[0]!.type, "warning");
|
|
assert.match(notes[0]!.msg, /no proxy detected/);
|
|
assert.match(notes[0]!.msg, /run via `bili omp`/);
|
|
assert.match(notes[0]!.msg, /`bili plugin remove omp`/);
|
|
assert.doesNotMatch(notes[0]!.msg, /billion-context-pi/);
|
|
});
|
|
});
|
|
|
|
test("/acp command warns when the session is unknown", async () => {
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url?.startsWith("/__bili/plugin/status")) {
|
|
res.writeHead(404, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: false, error: "unknown plugin conversation" }));
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as { port: number }).port}`;
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
const cmd = pi.commands.get("acp")!;
|
|
const notes: Array<{ msg: string; type?: string }> = [];
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-unknown" },
|
|
model: { baseUrl: `${origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string, type?: string) => notes.push({ msg, type }) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(notes.length, 1);
|
|
assert.equal(notes[0]!.type, "warning");
|
|
assert.match(notes[0]!.msg, /no ACP session yet/);
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
});
|
|
|
|
test("/acp shows armed info when the proxy is live but the session is unknown", async () => {
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url?.startsWith("/__bili/plugin/status")) {
|
|
res.writeHead(404, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: false, error: "unknown plugin conversation" }));
|
|
return;
|
|
}
|
|
if (req.url?.startsWith("/__bili/plugin/manifest")) {
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: true, version: "9.9.9", toolNames: [] }));
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as { port: number }).port}`;
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
const cmd = pi.commands.get("acp")!;
|
|
const notes: Array<{ msg: string; type?: string }> = [];
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-fresh" },
|
|
model: { baseUrl: `${origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string, type?: string) => notes.push({ msg, type }) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(notes.length, 1);
|
|
assert.equal(notes[0]!.type, "info");
|
|
assert.match(notes[0]!.msg, /billion-context@9\.9\.9/);
|
|
assert.match(notes[0]!.msg, /compression armed/);
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
});
|
|
|
|
test("/acp emits a persistent custom message via pi.sendMessage when available (issue #359)", async () => {
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url?.startsWith("/__bili/plugin/status")) {
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: true, panel: "PANEL-BODY", contextTokens: 12345 }));
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as { port: number }).port}`;
|
|
try {
|
|
const sent: Array<{ customType: string; content: string; display: boolean }> = [];
|
|
const notes: string[] = [];
|
|
const pi = { ...makeFakePi(), sendMessage: (m: { customType: string; content: string; display: boolean }) => sent.push(m) };
|
|
biliPlugin(pi as never);
|
|
const cmd = pi.commands.get("acp")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-send" },
|
|
model: { baseUrl: `${origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string) => notes.push(msg) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(sent.length, 1, "one custom message sent");
|
|
assert.equal(notes.length, 0, "notify must not fire when sendMessage is available");
|
|
assert.equal(sent[0]!.customType, "bili-acp-status");
|
|
assert.equal(sent[0]!.display, true);
|
|
assert.equal(sent[0]!.content, "PANEL-BODY");
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
});
|
|
|
|
test("/acp renderer collapses large reports and restores every block when expanded", () => {
|
|
type Renderer = NonNullable<Parameters<ReturnType<typeof createBiliPlugin>>[0]["registerMessageRenderer"]>;
|
|
let render: Parameters<Renderer>[1] | undefined;
|
|
biliPlugin({ on() {}, registerTool() {}, registerMessageRenderer: (name, renderer) => {
|
|
assert.equal(name, "bili-acp-status");
|
|
render = renderer;
|
|
} });
|
|
assert.ok(render, "register a renderer so Ctrl+O can control the report");
|
|
const text = ["╭─────────────────────────────────────────────╮", "│ ACP Context Analysis │",
|
|
"╰─────────────────────────────────────────────╯", "billion-context@0.1.202", "storage: full", "",
|
|
"Context (session accounting): 50%", "", "Sent to LLM (after compression, est.): 50k",
|
|
"Prompt cache (provider-reported): 90%", "", "Blocks: 250 active / 250 total",
|
|
...Array.from({ length: 250 }, (_, i) => ` [b${i}] T1 10k→1k: topic ${i}`),
|
|
"Web UI: http://127.0.0.1:8787/__bili/", "Tag visibility: footer"].join("\n");
|
|
const message = { role: "custom" as const, customType: "bili-acp-status", content: text, display: true, timestamp: 0 };
|
|
const backgrounds: string[] = [];
|
|
const theme = {
|
|
fg: (_color: string, value: string) => value,
|
|
bg: (color: string, value: string) => { backgrounds.push(color); return value; },
|
|
bold: (value: string) => value,
|
|
italic: (value: string) => value,
|
|
underline: (value: string) => value,
|
|
strikethrough: (value: string) => value,
|
|
} as Parameters<typeof render>[2];
|
|
const collapsed = render(message, { expanded: false, outputPad: 1 }, theme)!.render(120).join("\n");
|
|
assert.ok(collapsed.split("\n").length < 25);
|
|
assert.match(collapsed, /╭─/);
|
|
assert.match(collapsed, /ACP Context Analysis/);
|
|
assert.match(collapsed, /storage: full/);
|
|
assert.match(collapsed, /storage: full[^\n]*\n\s*\n/);
|
|
assert.match(collapsed, /Tag visibility: footer/);
|
|
assert.match(collapsed, /Blocks: 250 active/);
|
|
assert.match(collapsed, /Context .*50%/);
|
|
assert.match(collapsed, /Prompt cache .*90%/);
|
|
assert.match(collapsed, /Web UI:/);
|
|
assert.match(collapsed, /Ctrl\+O/);
|
|
assert.ok(!collapsed.includes("topic 249"));
|
|
assert.match(collapsed, /\[bili-acp-status\]/);
|
|
assert.ok(backgrounds.length > 0 && backgrounds.every((color) => color === "customMessageBg"));
|
|
assert.equal(render(message, { expanded: true, outputPad: 1 }, theme), undefined,
|
|
"expanded reports use pi's original styled Markdown renderer");
|
|
assert.equal(message.content, text, "display folding must preserve persisted report content");
|
|
assert.equal(render({ ...message, content: "Context: 0%\n\nBlocks: none" }, { expanded: false, outputPad: 1 }, theme),
|
|
undefined, "reports without block details keep pi's original renderer");
|
|
});
|
|
|
|
test("/acp sends renderAcpStatus fallback content via sendMessage when no panel string", async () => {
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url?.startsWith("/__bili/plugin/status")) {
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: true, contextLimit: 200000, contextTokens: 12345, inputTokens: 10000, outputTokens: 1234, cachedTokens: 8000, requests: 7, blocks: [{ id: "b1", tier: 1, active: true }] }));
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as { port: number }).port}`;
|
|
try {
|
|
const sent: Array<{ customType: string; content: string; display: boolean }> = [];
|
|
const pi = { ...makeFakePi(), sendMessage: (m: { customType: string; content: string; display: boolean }) => sent.push(m) };
|
|
biliPlugin(pi as never);
|
|
const cmd = pi.commands.get("acp")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-send2" },
|
|
model: { baseUrl: `${origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: () => { throw new Error("notify must not fire"); } },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(sent.length, 1);
|
|
assert.equal(sent[0]!.customType, "bili-acp-status");
|
|
assert.match(sent[0]!.content, /📊 ACP status/);
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
});
|
|
|
|
test("/acp falls back to notify when pi.sendMessage throws", async () => {
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url?.startsWith("/__bili/plugin/status")) {
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: true, panel: "PANEL-BODY", contextTokens: 1 }));
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as { port: number }).port}`;
|
|
try {
|
|
const notes: string[] = [];
|
|
const pi = { ...makeFakePi(), sendMessage: () => { throw new Error("host sendMessage failed"); } };
|
|
biliPlugin(pi as never);
|
|
const cmd = pi.commands.get("acp")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-send3" },
|
|
model: { baseUrl: `${origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string) => notes.push(msg) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(notes.length, 1, "notify fallback fires");
|
|
assert.equal(notes[0], "PANEL-BODY");
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
});
|
|
|
|
function startCacheReportProxy(result: string | undefined, error?: string): Promise<{ origin: string; calls: Array<{ conversationId: string; tool: string }>; close(): Promise<void> }> {
|
|
const calls: Array<{ conversationId: string; tool: string }> = [];
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url === "/__bili/plugin/tool" && req.method === "POST") {
|
|
let body = "";
|
|
req.on("data", (c) => (body += c));
|
|
req.on("end", () => {
|
|
const data = JSON.parse(body) as { conversationId: string; tool: string };
|
|
calls.push({ conversationId: data.conversationId, tool: data.tool });
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
if (error !== undefined) res.end(JSON.stringify({ ok: false, error }));
|
|
else res.end(JSON.stringify({ ok: true, result }));
|
|
});
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
return new Promise((resolve) => {
|
|
server.listen(0, "127.0.0.1", () => {
|
|
resolve({
|
|
origin: `http://127.0.0.1:${(server.address() as { port: number }).port}`,
|
|
calls,
|
|
close: () => new Promise<void>((r) => server.close(() => r())),
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
test("/acp-cache forwards acp_cache and persists the wrapped report via sendMessage (#800)", async () => {
|
|
const proxy = await startCacheReportProxy("CACHE-REPORT-BODY");
|
|
try {
|
|
const sent: Array<{ customType: string; content: string; display: boolean }> = [];
|
|
const notes: string[] = [];
|
|
const pi = { ...makeFakePi(), sendMessage: (m: { customType: string; content: string; display: boolean }) => sent.push(m) };
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-cache");
|
|
assert.ok(cmd, "acp-cache command should be registered");
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-cache" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string) => notes.push(msg) },
|
|
};
|
|
await cmd!.handler("", ctx);
|
|
// the model-facing tool is forwarded with the session's conversation id
|
|
assert.deepEqual(proxy.calls, [{ conversationId: "sess-cache", tool: "acp_cache" }]);
|
|
assert.equal(sent.length, 1, "one custom message sent");
|
|
assert.equal(notes.length, 0, "notify must not fire when sendMessage is available");
|
|
assert.equal(sent[0]!.customType, "bili-acp-cache");
|
|
assert.equal(sent[0]!.display, true);
|
|
assert.equal(sent[0]!.content, wrapCacheReport("CACHE-REPORT-BODY"));
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("/acp-cache falls back to raw-text notify when the host has no sendMessage (#800)", async () => {
|
|
const proxy = await startCacheReportProxy("CACHE-REPORT-BODY");
|
|
try {
|
|
const notes: Array<{ msg: string; type?: string }> = [];
|
|
const pi = makeFakePi();
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-cache")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-cache" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string, type?: string) => notes.push({ msg, type }) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(notes.length, 1, "notify fallback fires");
|
|
assert.equal(notes[0]!.type, "info");
|
|
// transient notice carries the RAW report (no wrapper) — the wrapper is
|
|
// only meaningful for the persistent-message strip path.
|
|
assert.equal(notes[0]!.msg, "CACHE-REPORT-BODY");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("/acp-cache warns when no proxy is detected (#800)", async () => {
|
|
await withEnv({ BILLION_CONTEXT_PROXY: undefined }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-cache")!;
|
|
const notes: Array<{ msg: string; type?: string }> = [];
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess" },
|
|
model: { baseUrl: "https://api.example.com/v1" },
|
|
ui: { notify: (msg: string, type?: string) => notes.push({ msg, type }) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(notes.length, 1);
|
|
assert.equal(notes[0]!.type, "warning");
|
|
assert.match(notes[0]!.msg, /no proxy detected/);
|
|
});
|
|
});
|
|
|
|
test("/acp-cache reports a proxy-side failure via notify error (#800)", async () => {
|
|
const proxy = await startCacheReportProxy(undefined, "boom");
|
|
try {
|
|
const notes: Array<{ msg: string; type?: string }> = [];
|
|
const pi = makeFakePi();
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-cache")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-cache" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string, type?: string) => notes.push({ msg, type }) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(notes.length, 1);
|
|
assert.equal(notes[0]!.type, "error");
|
|
assert.match(notes[0]!.msg, /cache report failed/);
|
|
assert.match(notes[0]!.msg, /boom/);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
function startRuleProxy(result: string | undefined, error?: string): Promise<{ origin: string; calls: Array<{ conversationId: string; tool: string; args: Record<string, unknown> }>; close(): Promise<void> }> {
|
|
const calls: Array<{ conversationId: string; tool: string; args: Record<string, unknown> }> = [];
|
|
const server = http.createServer((req, res) => {
|
|
if (req.url === "/__bili/plugin/tool" && req.method === "POST") {
|
|
let body = "";
|
|
req.on("data", (c) => (body += c));
|
|
req.on("end", () => {
|
|
const data = JSON.parse(body) as { conversationId: string; tool: string; args?: Record<string, unknown> };
|
|
calls.push({ conversationId: data.conversationId, tool: data.tool, args: data.args ?? {} });
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
if (error !== undefined) res.end(JSON.stringify({ ok: false, error }));
|
|
else res.end(JSON.stringify({ ok: true, result }));
|
|
});
|
|
return;
|
|
}
|
|
res.writeHead(404);
|
|
res.end("{}");
|
|
});
|
|
return new Promise((resolve) => {
|
|
server.listen(0, "127.0.0.1", () => {
|
|
resolve({
|
|
origin: `http://127.0.0.1:${(server.address() as { port: number }).port}`,
|
|
calls,
|
|
close: () => new Promise<void>((r) => server.close(() => r())),
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
test("/acp-rule forwards acp_rule with empty args and persists the wrapped list via sendMessage (#1251)", async () => {
|
|
const proxy = await startRuleProxy("rule1: always run typecheck");
|
|
try {
|
|
const sent: Array<{ customType: string; content: string; display: boolean }> = [];
|
|
const notes: string[] = [];
|
|
const pi = { ...makeFakePi(), sendMessage: (m: { customType: string; content: string; display: boolean }) => sent.push(m) };
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-rule");
|
|
assert.ok(cmd, "acp-rule command should be registered");
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-rules" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string) => notes.push(msg) },
|
|
};
|
|
await cmd!.handler("", ctx);
|
|
assert.deepEqual(proxy.calls, [{ conversationId: "sess-rules", tool: "acp_rule", args: {} }], "no-arg list forwards empty args");
|
|
assert.equal(sent.length, 1, "one custom message sent");
|
|
assert.equal(notes.length, 0, "notify must not fire when sendMessage is available");
|
|
assert.equal(sent[0]!.customType, "bili-acp-rule");
|
|
assert.equal(sent[0]!.display, true);
|
|
assert.equal(sent[0]!.content, wrapRuleReport("rule1: always run typecheck"));
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("/acp-rule forwards the text as { rule } to record a rule (#1251)", async () => {
|
|
const proxy = await startRuleProxy("Recorded rule2: prefer pnpm");
|
|
try {
|
|
const sent: Array<{ customType: string; content: string }> = [];
|
|
const pi = { ...makeFakePi(), sendMessage: (m: { customType: string; content: string }) => sent.push(m) };
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-rule")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-rules-add" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (_msg: string) => {} },
|
|
};
|
|
await cmd.handler(" prefer pnpm ", ctx);
|
|
assert.deepEqual(proxy.calls, [{ conversationId: "sess-rules-add", tool: "acp_rule", args: { rule: "prefer pnpm" } }], "trimmed text forwarded as { rule }");
|
|
assert.equal(sent[0]!.customType, "bili-acp-rule");
|
|
assert.equal(sent[0]!.content, wrapRuleReport("Recorded rule2: prefer pnpm"));
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("/acp-rule falls back to raw-text notify when the host has no sendMessage (#1251)", async () => {
|
|
const proxy = await startRuleProxy("No rules recorded.");
|
|
try {
|
|
const notes: string[] = [];
|
|
const pi = makeFakePi();
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-rule")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-rules-notify" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string) => notes.push(msg) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(notes.length, 1, "notify fallback fires");
|
|
assert.equal(notes[0], "No rules recorded.");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("/acp-rule warns with an enablement hint when the proxy reports the feature disabled (#1251)", async () => {
|
|
const proxy = await startRuleProxy("acp_rule is not enabled on this bili proxy (compress.rules.enabled is not true) — nothing was recorded.");
|
|
try {
|
|
const sent: Array<{ customType: string }> = [];
|
|
const notes: Array<{ msg: string; type?: string }> = [];
|
|
const pi = { ...makeFakePi(), sendMessage: (m: { customType: string }) => sent.push(m) };
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-rule")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-rules-off" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string, type?: string) => notes.push({ msg, type }) },
|
|
};
|
|
await cmd.handler("", ctx);
|
|
assert.equal(sent.length, 0, "no transcript message when disabled");
|
|
assert.equal(notes.length, 1);
|
|
assert.equal(notes[0]!.type, "warning");
|
|
assert.match(notes[0]!.msg, /compress\.rules\.enabled/);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("/acp-rule forwards `remove <id>` as { delete } to acp_rule (#1399)", async () => {
|
|
const proxy = await startRuleProxy("Removed rule1: always run tests first");
|
|
try {
|
|
const sent: Array<{ customType: string; content: string }> = [];
|
|
const pi = { ...makeFakePi(), sendMessage: (m: { customType: string; content: string }) => sent.push(m) };
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-rule")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-rules-remove" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (_msg: string) => {} },
|
|
};
|
|
await cmd.handler("remove rule1", ctx);
|
|
assert.deepEqual(proxy.calls, [{ conversationId: "sess-rules-remove", tool: "acp_rule", args: { delete: "rule1" } }], "`remove <id>` forwarded as { delete }");
|
|
assert.equal(sent[0]!.customType, "bili-acp-rule");
|
|
assert.equal(sent[0]!.content, wrapRuleReport("Removed rule1: always run tests first"));
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("/acp-rule forwards bare `clear` as { clear: true } to acp_rule (#1399)", async () => {
|
|
const proxy = await startRuleProxy("Cleared 2 rule(s).");
|
|
try {
|
|
const sent: Array<{ customType: string; content: string }> = [];
|
|
const pi = { ...makeFakePi(), sendMessage: (m: { customType: string; content: string }) => sent.push(m) };
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-rule")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-rules-clear" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (_msg: string) => {} },
|
|
};
|
|
await cmd.handler("clear", ctx);
|
|
assert.deepEqual(proxy.calls, [{ conversationId: "sess-rules-clear", tool: "acp_rule", args: { clear: true } }], "bare clear forwarded as { clear: true }");
|
|
assert.equal(sent[0]!.content, wrapRuleReport("Cleared 2 rule(s)."));
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("/acp-rule bare `remove` warns with usage instead of forwarding (#1399)", async () => {
|
|
const proxy = await startRuleProxy("No rules recorded.");
|
|
try {
|
|
const notes: Array<{ msg: string; type?: string }> = [];
|
|
const pi = makeFakePi();
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-rule")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-rules-remove-usage" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (msg: string, type?: string) => notes.push({ msg, type }) },
|
|
};
|
|
await cmd.handler("remove", ctx);
|
|
assert.equal(proxy.calls.length, 0, "nothing forwarded for a missing id");
|
|
assert.equal(notes.length, 1);
|
|
assert.equal(notes[0]!.type, "warning");
|
|
assert.match(notes[0]!.msg, /Usage: \/acp-rule remove <rule-id>/);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("/acp-rule `clear <text>` records the text instead of wiping (#1399)", async () => {
|
|
const proxy = await startRuleProxy("Recorded rule3: clear all caches before deploys");
|
|
try {
|
|
const sent: Array<{ customType: string }> = [];
|
|
const pi = { ...makeFakePi(), sendMessage: (m: { customType: string }) => sent.push(m) };
|
|
createBiliPlugin()(pi as never);
|
|
const cmd = pi.commands.get("acp-rule")!;
|
|
const ctx = {
|
|
sessionManager: { getSessionId: () => "sess-rules-clear-words" },
|
|
model: { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` },
|
|
ui: { notify: (_msg: string) => {} },
|
|
};
|
|
await cmd.handler("clear all caches before deploys", ctx);
|
|
assert.deepEqual(proxy.calls, [{ conversationId: "sess-rules-clear-words", tool: "acp_rule", args: { rule: "clear all caches before deploys" } }], "extra words after clear are recorded, never wiped");
|
|
assert.equal(sent.length, 1);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("omp entry reports x-bili-plugin: omp without env vars", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
await withEnv({ BILLION_CONTEXT_PLUGIN_AGENT: undefined, BILLION_CONTEXT_PROXY: proxy.origin }, async () => {
|
|
const pi = makeFakePi();
|
|
ompPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(undefined));
|
|
await waitForTools(pi, 2);
|
|
const headers: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers }, fakeCtx(undefined));
|
|
assert.equal(headers["x-bili-plugin"], "omp");
|
|
});
|
|
await withEnv({ BILLION_CONTEXT_PLUGIN_AGENT: "omp", BILLION_CONTEXT_PROXY: proxy.origin }, async () => {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(undefined));
|
|
await waitForTools(pi, 2);
|
|
const headers: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers }, fakeCtx(undefined));
|
|
assert.equal(headers["x-bili-plugin"], "omp");
|
|
});
|
|
await withEnv({ BILLION_CONTEXT_PLUGIN_AGENT: undefined }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("dsh")(pi as never);
|
|
const ctx = { sessionManager: { getSessionId: () => "s" }, model: { baseUrl: `${proxy.origin}/bili/https://x` } };
|
|
await pi.events.get("session_start")!({}, ctx);
|
|
await waitForTools(pi, 2);
|
|
const headers: Record<string, string> = {};
|
|
await pi.events.get("before_provider_headers")!({ headers }, ctx);
|
|
assert.equal(headers["x-bili-plugin"], "dsh");
|
|
});
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
function hintEnv(home: string, piAgentDir: string): Record<string, string> {
|
|
return {
|
|
PI_CODING_AGENT_DIR: piAgentDir,
|
|
CODEX_HOME: home,
|
|
OPENCODE_CONFIG: path.join(home, ".config/opencode/opencode.json"),
|
|
CLAUDE_CONFIG_DIR: home,
|
|
CLAUDE: "/nonexistent/bili-claude-stub",
|
|
BILI_MCP_PROXY: "http://127.0.0.1:8787",
|
|
};
|
|
}
|
|
|
|
test("plugin install/remove roundtrips for pi/omp/codex/opencode under a fake HOME", async () => {
|
|
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-plugin-home-"));
|
|
const piAgentDir = path.join(home, ".pi/agent");
|
|
// #925 pi entry form: npm installs write the pi-managed npm spec
|
|
// (auto-installed at pi startup, upgraded by `pi update`, survives node
|
|
// prefix moves); dev/checkout installs keep the abs root.
|
|
{
|
|
const devRoot = "/home/x/projects/billion-context";
|
|
assert.equal(piEntryFor(devRoot), devRoot);
|
|
const npmRoot = "/home/x/.local/lib/node_modules/billion-context";
|
|
assert.equal(piEntryFor(npmRoot), PI_NPM_ENTRY);
|
|
assert.equal(PI_NPM_ENTRY, "npm:billion-context");
|
|
assert.equal(isPiEntry(PI_NPM_ENTRY, devRoot), true);
|
|
assert.equal(isPiEntry(PI_NPM_ENTRY, npmRoot), true);
|
|
assert.equal(isPiEntry("npm:billion-context@0.1.40", devRoot), true);
|
|
}
|
|
await withEnv(hintEnv(home, piAgentDir), async () => {
|
|
const root = selfPackageRoot();
|
|
|
|
const freshInstall = pluginInstall("pi");
|
|
assert.match(freshInstall, /installed/);
|
|
assert.doesNotMatch(freshInstall, /replaced existing entries/);
|
|
const piSettings = JSON.parse(fs.readFileSync(path.join(piAgentDir, "settings.json"), "utf8")) as { packages: string[] };
|
|
assert.ok(piSettings.packages.includes(root));
|
|
assert.match(pluginInstall("pi"), /already installed/);
|
|
const firstRemove = pluginRemove("pi");
|
|
assert.match(firstRemove, /removed/);
|
|
assert.ok(firstRemove.includes(root), "remove reports the entry it dropped");
|
|
assert.ok(!(JSON.parse(fs.readFileSync(path.join(piAgentDir, "settings.json"), "utf8")) as { packages: string[] }).packages.includes(root));
|
|
assert.match(pluginRemove("pi"), /not installed/);
|
|
|
|
// Legacy entries (old billion-context-pi npm package, a dev checkout
|
|
// path, backslash Windows paths) must be REPLACED by install so only
|
|
// one bili plugin stays live.
|
|
fs.writeFileSync(path.join(piAgentDir, "settings.json"), JSON.stringify({
|
|
packages: [
|
|
"npm:billion-context-pi",
|
|
"npm:billion-context-pi@0.1.48",
|
|
"npm:billion-context@0.1.40",
|
|
"/home/x/projects/billion-context",
|
|
"C:\\Users\\x\\AppData\\Roaming\\npm\\node_modules\\billion-context-pi",
|
|
"/home/x/other-package",
|
|
],
|
|
theme: "dark",
|
|
}, null, 2));
|
|
const replaceMsg = pluginInstall("pi");
|
|
assert.match(replaceMsg, /installed/);
|
|
// #788: every dropped entry is named in the output — the
|
|
// billion-context-pi removal in particular must not be silent.
|
|
assert.ok(replaceMsg.includes("replaced existing entries:"));
|
|
// #939: project-scope reminder mirrors the opencode LOCAL-scope note
|
|
assert.match(replaceMsg, /<project>\/\.pi\/settings\.json/);
|
|
for (const gone of [
|
|
"npm:billion-context-pi",
|
|
"npm:billion-context-pi@0.1.48",
|
|
"npm:billion-context@0.1.40",
|
|
"/home/x/projects/billion-context",
|
|
"C:\\Users\\x\\AppData\\Roaming\\npm\\node_modules\\billion-context-pi",
|
|
]) {
|
|
assert.ok(replaceMsg.includes(gone), `install output names removed entry ${gone}`);
|
|
}
|
|
assert.doesNotMatch(replaceMsg, /other-package/);
|
|
const replaced = JSON.parse(fs.readFileSync(path.join(piAgentDir, "settings.json"), "utf8")) as { packages: string[]; theme: string };
|
|
assert.deepEqual(replaced.packages, ["/home/x/other-package", root]);
|
|
assert.equal(replaced.theme, "dark");
|
|
const legacyRemove = pluginRemove("pi");
|
|
assert.match(legacyRemove, /removed/);
|
|
assert.ok(legacyRemove.includes(root), "remove reports the entry it dropped");
|
|
assert.doesNotMatch(legacyRemove, /other-package/);
|
|
assert.deepEqual((JSON.parse(fs.readFileSync(path.join(piAgentDir, "settings.json"), "utf8")) as { packages: string[] }).packages, ["/home/x/other-package"]);
|
|
|
|
// omp install/status/remove verify the entry's target exists, so
|
|
// materialize the (gitignored) dist artifact for this sub-test.
|
|
const ompDistFile = path.join(root, "dist", "agent", "omp-native.js");
|
|
const createdOmpDist = !fs.existsSync(ompDistFile);
|
|
if (createdOmpDist) {
|
|
fs.mkdirSync(path.dirname(ompDistFile), { recursive: true });
|
|
fs.writeFileSync(ompDistFile, "// test stub\n");
|
|
}
|
|
fs.mkdirSync(path.join(home, ".omp/agent"), { recursive: true });
|
|
await withEnv({ PI_CODING_AGENT_DIR: path.join(home, ".omp/agent") }, async () => {
|
|
fs.writeFileSync(path.join(home, ".omp/agent/config.yml"), "extensions:\n - /some/other/ext.js\nfirstRunComplete: true\n");
|
|
assert.match(pluginInstall("omp"), /installed/);
|
|
const ompText = fs.readFileSync(path.join(home, ".omp/agent/config.yml"), "utf8");
|
|
assert.match(ompText, /extensions:\n - \/some\/other\/ext\.js\n - .*dist[\\/]agent[\\/]omp-native\.js\nfirstRunComplete: true\n/);
|
|
assert.match(pluginInstall("omp"), /already installed/);
|
|
assert.match(pluginRemove("omp"), /removed/);
|
|
assert.equal(fs.readFileSync(path.join(home, ".omp/agent/config.yml"), "utf8"), "extensions:\n - /some/other/ext.js\nfirstRunComplete: true\n");
|
|
|
|
const noExtYml = "firstRunComplete: true\n";
|
|
fs.writeFileSync(path.join(home, ".omp/agent/config.yml"), noExtYml);
|
|
pluginInstall("omp");
|
|
assert.match(fs.readFileSync(path.join(home, ".omp/agent/config.yml"), "utf8"), /firstRunComplete: true\nextensions:\n - .*omp-native\.js\n/);
|
|
pluginRemove("omp");
|
|
|
|
const noNlYml = "extensions:";
|
|
fs.writeFileSync(path.join(home, ".omp/agent/config.yml"), noNlYml);
|
|
pluginInstall("omp");
|
|
assert.match(fs.readFileSync(path.join(home, ".omp/agent/config.yml"), "utf8"), /extensions:\n - .*omp-native\.js\n/);
|
|
pluginRemove("omp");
|
|
|
|
const colZeroYml = "extensions:\n- /a.js\n- /b.js\nother: 1\n";
|
|
fs.writeFileSync(path.join(home, ".omp/agent/config.yml"), colZeroYml);
|
|
pluginInstall("omp");
|
|
assert.match(fs.readFileSync(path.join(home, ".omp/agent/config.yml"), "utf8"), /^extensions:\n- \/a\.js\n- \/b\.js\n- .*omp-native\.js\nother: 1\n$/);
|
|
pluginRemove("omp");
|
|
assert.equal(fs.readFileSync(path.join(home, ".omp/agent/config.yml"), "utf8"), colZeroYml);
|
|
|
|
const flowYml = "extensions: [/a.js]\n";
|
|
fs.writeFileSync(path.join(home, ".omp/agent/config.yml"), flowYml);
|
|
assert.throws(() => pluginInstall("omp"), /flow style|inline value/);
|
|
const quotedYml = `extensions:\n - "${path.join(root, "dist/agent/omp.js")}" # my ext\n`;
|
|
fs.writeFileSync(path.join(home, ".omp/agent/config.yml"), quotedYml);
|
|
assert.match(pluginInstall("omp"), /installed.*replaced/);
|
|
assert.match(pluginRemove("omp"), /removed/);
|
|
assert.equal(fs.readFileSync(path.join(home, ".omp/agent/config.yml"), "utf8"), "extensions:\n");
|
|
});
|
|
if (createdOmpDist) fs.rmSync(ompDistFile, { force: true });
|
|
|
|
assert.match(pluginInstall("codex"), /installed/);
|
|
const toml = fs.readFileSync(path.join(home, "config.toml"), "utf8");
|
|
assert.match(toml, /\[mcp_servers\.bili\]\ncommand = /);
|
|
// #1660: no baked origin — the MCP shell discovers the live proxy at
|
|
// startup (env > instance file > 8787), so the block cannot go stale.
|
|
assert.doesNotMatch(toml, /BILI_MCP_PROXY/);
|
|
fs.writeFileSync(path.join(home, "config.toml"), toml + "\n[mcp_servers.other]\ncommand = \"x\"\n");
|
|
assert.match(pluginInstall("codex"), /already installed/);
|
|
// a user-tampered command (their own node path) is not canonical →
|
|
// refreshed back to the current canonical block
|
|
fs.writeFileSync(path.join(home, "config.toml"), fs.readFileSync(path.join(home, "config.toml"), "utf8").replace(JSON.stringify(process.execPath), JSON.stringify("/tampered/node")));
|
|
assert.match(pluginInstall("codex"), /refreshed/);
|
|
assert.doesNotMatch(fs.readFileSync(path.join(home, "config.toml"), "utf8"), /tampered/);
|
|
assert.match(pluginRemove("codex"), /removed/);
|
|
const tomlAfter = fs.readFileSync(path.join(home, "config.toml"), "utf8");
|
|
assert.doesNotMatch(tomlAfter, /mcp_servers\.bili/);
|
|
assert.match(tomlAfter, /\[mcp_servers\.other\]\ncommand = "x"\n/);
|
|
|
|
// Regression: a header-only [mcp_servers.bili] block as the final
|
|
// line with no trailing newline must be fully removed (previously
|
|
// the header line survived because the next-table search matched
|
|
// the header itself when after.indexOf("\n") was -1).
|
|
fs.writeFileSync(path.join(home, "config.toml"), "[mcp_servers.other]\ncommand = \"x\"\n[mcp_servers.bili]");
|
|
assert.match(pluginRemove("codex"), /removed/);
|
|
const tomlEdge = fs.readFileSync(path.join(home, "config.toml"), "utf8");
|
|
assert.doesNotMatch(tomlEdge, /mcp_servers\.bili/);
|
|
assert.match(tomlEdge, /\[mcp_servers\.other\]\ncommand = "x"\n/);
|
|
|
|
// #638: a malformed block (args as string - legal TOML, invalid codex
|
|
// schema). Legacy blocks carried a baked env origin — the heal must
|
|
// drop it, not preserve it (#1660).
|
|
const selfRoot = path.dirname(path.dirname(path.resolve("src/plugin-install.ts")));
|
|
const malformed = `[mcp_servers.other]\ncommand = "x"\n[mcp_servers.bili]\ncommand = "node"\nargs = '[\"${path.join(selfRoot, "dist", "mcp.js")}\"]'\nenv = { BILI_MCP_PROXY = "http://127.0.0.1:8787" }\n`;
|
|
fs.writeFileSync(path.join(home, "config.toml"), malformed);
|
|
const healedMsg = pluginInstall("codex");
|
|
assert.match(healedMsg, /repaired args: was not an array/);
|
|
const tomlHealed = fs.readFileSync(path.join(home, "config.toml"), "utf8");
|
|
assert.match(tomlHealed, /args = \[/);
|
|
assert.doesNotMatch(tomlHealed, /args = '\[/);
|
|
assert.doesNotMatch(tomlHealed, /BILI_MCP_PROXY/, "legacy baked origin dropped on heal (#1660)");
|
|
assert.match(tomlHealed, /\[mcp_servers\.other\]\ncommand = "x"\n/);
|
|
// A now-canonical block stays "already installed" on rerun.
|
|
assert.match(pluginInstall("codex"), /already installed/);
|
|
assert.match(pluginRemove("codex"), /removed/);
|
|
|
|
// #820: pre-seed user settings — install must merge around them and remove must restore them.
|
|
// #927: seed under whichever key this host's opencode generation uses, so the
|
|
// round-trip assertions hold on both 1.x ("plugin") and 2.x ("plugins") machines.
|
|
const ocKey = pickPluginKey(detectOpencodeMajor());
|
|
const ocFile = path.join(home, ".config/opencode/opencode.json");
|
|
fs.mkdirSync(path.dirname(ocFile), { recursive: true });
|
|
fs.writeFileSync(ocFile, JSON.stringify({ $schema: "https://opencode.ai/config.json", compaction: { auto: true, buffer: 100 }, [ocKey]: ["some-other-plugin"] }));
|
|
const ocPluginDir = path.join(home, ".config/opencode/plugins/billion-context");
|
|
const ocInstallMsg = pluginInstall("opencode");
|
|
assert.match(ocInstallMsg, /installed/);
|
|
// #926: default install adds NO mcp.bili (native plugin provides the
|
|
// tools); --with-mcp opts in and pins only via explicit BILI_MCP_PROXY.
|
|
assert.match(ocInstallMsg, /mcp\.bili not written/);
|
|
const ocWithMcp = pluginInstall("opencode", { withMcp: true });
|
|
assert.match(ocWithMcp, /mcp\.bili written \(BILI_MCP_PROXY=http:\/\/127\.0\.0\.1:8787\)/);
|
|
let oc = JSON.parse(fs.readFileSync(ocFile, "utf8")) as { mcp?: Record<string, { command: string[]; environment?: Record<string, string> }>; compaction?: Record<string, unknown>; $schema?: string } & Record<string, unknown>;
|
|
assert.equal(oc.mcp?.bili.command[1]!.endsWith(path.join("dist", "mcp.js")), true);
|
|
assert.equal(oc.mcp?.bili.environment?.BILI_MCP_PROXY, "http://127.0.0.1:8787");
|
|
assert.deepEqual(oc[ocKey], ["some-other-plugin", ocPluginDir]);
|
|
assert.match(fs.readFileSync(path.join(ocPluginDir, "index.js"), "utf8").replace(/\\+/g, "/"), /agent\/opencode-native\.js/);
|
|
assert.deepEqual(oc.compaction, { auto: false, buffer: 100 });
|
|
const ocAgain = pluginInstall("opencode", { withMcp: true });
|
|
assert.match(ocAgain, /mcp\.bili present/);
|
|
assert.match(ocAgain, new RegExp(`${ocKey} present`));
|
|
assert.match(pluginRemove("opencode"), /removed/);
|
|
oc = JSON.parse(fs.readFileSync(ocFile, "utf8")) as Record<string, unknown>;
|
|
assert.equal(oc.mcp, undefined);
|
|
// only the bili entry is dropped — the user's other plugin survives
|
|
assert.deepEqual(oc[ocKey], ["some-other-plugin"]);
|
|
assert.deepEqual(oc.compaction, { auto: true, buffer: 100 });
|
|
assert.equal(oc.$schema, "https://opencode.ai/config.json");
|
|
assert.equal(fs.existsSync(ocPluginDir), false);
|
|
|
|
// #964 native posture: the managed settings block is written FIRST
|
|
// (pure JSON, no CLI needed); the MCP face execs the claude CLI. With
|
|
// the stub CLAUDE above the exec fails — install throws, but the
|
|
// block IS in place, so remove has real work (and must not exec the
|
|
// CLI when the MCP face never registered).
|
|
assert.throws(() => pluginInstall("claude"), /claude: MCP registration failed .*managed settings block.*was written/);
|
|
assert.equal(claudeNativeInstalled(), true);
|
|
assert.match(pluginRemove("claude"), /managed block removed/);
|
|
assert.match(pluginRemove("claude"), /not installed/);
|
|
|
|
const rows = pluginStatusAll();
|
|
assert.equal(rows.length, 10);
|
|
assert.deepEqual(PLUGIN_AGENTS, ["pi", "omp", "claude", "codex", "opencode", "dsh", "kimi", "hermes", "zcode", "workbuddy"]);
|
|
});
|
|
rmrf(home);
|
|
});
|
|
|
|
test("plugin install opencode without a live proxy: MCP shell skipped, native plugin still installed (#820)", async () => {
|
|
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-oc-noproxy-"));
|
|
const ocFile = path.join(home, ".config/opencode/opencode.json");
|
|
try {
|
|
await withEnv({ OPENCODE_CONFIG: ocFile, BILI_MCP_PROXY: undefined, XDG_STATE_HOME: path.join(home, "state") }, async () => {
|
|
const ocKey = pickPluginKey(detectOpencodeMajor());
|
|
const msg = pluginInstall("opencode");
|
|
assert.match(msg, /installed/);
|
|
// #926: no mcp.bili by default — with or without a live proxy
|
|
assert.match(msg, /mcp\.bili not written/);
|
|
assert.doesNotMatch(msg, /no bili proxy origin found/);
|
|
const data = JSON.parse(fs.readFileSync(ocFile, "utf8")) as { mcp?: unknown; compaction?: Record<string, unknown> } & Record<string, unknown>;
|
|
assert.equal(data.mcp, undefined);
|
|
assert.deepEqual(data[ocKey], [path.join(home, ".config/opencode/plugins/billion-context")]);
|
|
assert.deepEqual(data.compaction, { auto: false });
|
|
assert.ok(fs.existsSync(path.join(home, ".config/opencode/plugins/billion-context/index.js")));
|
|
assert.match(pluginRemove("opencode"), /removed/);
|
|
const after = JSON.parse(fs.readFileSync(ocFile, "utf8")) as Record<string, unknown>;
|
|
assert.equal(after.mcp, undefined);
|
|
assert.equal(after[ocKey], undefined);
|
|
assert.equal(after.compaction, undefined);
|
|
});
|
|
} finally {
|
|
rmrf(home);
|
|
}
|
|
});
|
|
|
|
test("plugin install opencode replaces legacy opencode-acp entries — array and object shapes (#918)", async () => {
|
|
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-oc-acp-"));
|
|
const ocFile = path.join(home, ".config/opencode/opencode.json");
|
|
fs.mkdirSync(path.dirname(ocFile), { recursive: true });
|
|
try {
|
|
await withEnv({ OPENCODE_CONFIG: ocFile, BILI_MCP_PROXY: undefined, XDG_STATE_HOME: path.join(home, "state") }, async () => {
|
|
const ocKey = pickPluginKey(detectOpencodeMajor());
|
|
const otherKey = ocKey === "plugin" ? "plugins" : "plugin";
|
|
const dir = path.join(home, ".config/opencode/plugins/billion-context");
|
|
// array shape: bare name, npm: alias, path (incl. deep entry path), versioned
|
|
fs.writeFileSync(ocFile, JSON.stringify({
|
|
[ocKey]: ["opencode-acp", "npm:opencode-acp", "/opt/other-plugin", path.join(home, "ext/opencode-acp/index.js"), path.join(home, "ext2/opencode-acp/dist/index.js"), "opencode-acp@stable"],
|
|
}));
|
|
let msg = pluginInstall("opencode");
|
|
assert.match(msg, /replaced opencode-acp plugin entries/);
|
|
let data = JSON.parse(fs.readFileSync(ocFile, "utf8")) as Record<string, unknown>;
|
|
assert.deepEqual(data[ocKey], ["/opt/other-plugin", dir]);
|
|
assert.ok(fs.existsSync(`${ocFile}.bili-bak`));
|
|
pluginRemove("opencode");
|
|
|
|
// object shape: version-map form (#1002: preserved as a map now —
|
|
// our key joins it, foreign values never collapse to bare keys)
|
|
fs.writeFileSync(ocFile, JSON.stringify({ [ocKey]: { "opencode-acp": "stable", "other": "1.0" } }));
|
|
msg = pluginInstall("opencode");
|
|
assert.match(msg, /replaced opencode-acp plugin entries \(opencode-acp\)/);
|
|
data = JSON.parse(fs.readFileSync(ocFile, "utf8"));
|
|
// sibling map entries survive verbatim + our dir as a key
|
|
assert.deepEqual(data[ocKey], { other: "1.0", [dir]: true });
|
|
pluginRemove("opencode");
|
|
|
|
// #927: legacy entries under the OTHER spelling are stripped too
|
|
fs.writeFileSync(ocFile, JSON.stringify({ [otherKey]: ["npm:opencode-acp", "/opt/other-plugin"], [ocKey]: ["/opt/mine"] }));
|
|
msg = pluginInstall("opencode");
|
|
assert.match(msg, /replaced opencode-acp plugin entries \(npm:opencode-acp\)/);
|
|
data = JSON.parse(fs.readFileSync(ocFile, "utf8"));
|
|
assert.deepEqual(data[otherKey], ["/opt/other-plugin"]);
|
|
assert.deepEqual(data[ocKey], ["/opt/mine", dir]);
|
|
pluginRemove("opencode");
|
|
|
|
// no legacy entries -> no note, plugin untouched
|
|
fs.writeFileSync(ocFile, JSON.stringify({ [ocKey]: ["/opt/other-plugin"] }));
|
|
msg = pluginInstall("opencode");
|
|
assert.doesNotMatch(msg, /replaced opencode-acp/);
|
|
assert.equal(msg.includes("other-plugin"), false);
|
|
});
|
|
} finally {
|
|
rmrf(home);
|
|
}
|
|
});
|
|
|
|
test("plugin install/remove/status survive a non-object mcp in opencode.json (#809/N4)", async () => {
|
|
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-oc-badmcp-"));
|
|
const ocFile = path.join(home, ".config/opencode/opencode.json");
|
|
fs.mkdirSync(path.dirname(ocFile), { recursive: true });
|
|
try {
|
|
await withEnv({ OPENCODE_CONFIG: ocFile, BILI_MCP_PROXY: undefined, XDG_STATE_HOME: path.join(home, "state") }, async () => {
|
|
const ocKey = pickPluginKey(detectOpencodeMajor());
|
|
fs.writeFileSync(ocFile, JSON.stringify({ mcp: "totally-broken-string" }));
|
|
const msg = pluginInstall("opencode");
|
|
assert.match(msg, /installed/);
|
|
let data = JSON.parse(fs.readFileSync(ocFile, "utf8")) as Record<string, unknown>;
|
|
assert.deepEqual(data[ocKey], [path.join(home, ".config/opencode/plugins/billion-context")]);
|
|
assert.deepEqual(data.compaction, { auto: false });
|
|
assert.equal(pluginStatusAll().find((r) => r.agent === "opencode")?.status, "installed");
|
|
assert.doesNotThrow(() => pluginRemove("opencode"));
|
|
data = JSON.parse(fs.readFileSync(ocFile, "utf8")) as Record<string, unknown>;
|
|
assert.equal(data[ocKey], undefined);
|
|
assert.equal(data.compaction, undefined);
|
|
assert.ok(!fs.existsSync(path.join(home, ".config/opencode/plugins/billion-context/index.js")));
|
|
assert.equal(pluginStatusAll().find((r) => r.agent === "opencode")?.status, "not installed");
|
|
});
|
|
} finally {
|
|
rmrf(home);
|
|
}
|
|
});
|
|
|
|
test("omp plugin: scoped matching, existence check, overlay redirect (issue #392)", async () => {
|
|
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-plugin-omp-"));
|
|
const root = selfPackageRoot();
|
|
const ompDistFile = path.join(root, "dist", "agent", "omp-native.js");
|
|
const createdOmpDist = !fs.existsSync(ompDistFile);
|
|
if (createdOmpDist) {
|
|
fs.mkdirSync(path.dirname(ompDistFile), { recursive: true });
|
|
fs.writeFileSync(ompDistFile, "// test stub\n");
|
|
}
|
|
try {
|
|
const stale = "/does/not/exist/dist/agent/omp.js";
|
|
|
|
// (a) a stale in-block entry migrates to the native form on install
|
|
// (#957); a same-valued line OUTSIDE the extensions block is never touched
|
|
{
|
|
const agentDir = path.join(home, "a", ".omp", "agent");
|
|
fs.mkdirSync(agentDir, { recursive: true });
|
|
fs.writeFileSync(path.join(agentDir, "config.yml"),
|
|
`extensions:\n - ${stale}\nother:\n - ${stale}\nfirstRunComplete: true\n`);
|
|
await withEnv({ PI_CODING_AGENT_DIR: agentDir }, async () => {
|
|
assert.match(pluginInstall("omp"), /installed.*replaced/);
|
|
assert.equal(pluginStatusAll().find((r) => r.agent === "omp")?.status, "installed");
|
|
});
|
|
assert.match(fs.readFileSync(path.join(agentDir, "config.yml"), "utf8"),
|
|
/extensions:\n - .*dist[\\/]agent[\\/]omp-native\.js\nother:\n - \/does\/not\/exist\/dist\/agent\/omp\.js\nfirstRunComplete: true\n/);
|
|
}
|
|
|
|
// (b) remove only deletes in-block entries; the out-of-block line stays
|
|
{
|
|
const agentDir = path.join(home, "b", ".omp", "agent");
|
|
fs.mkdirSync(agentDir, { recursive: true });
|
|
fs.writeFileSync(path.join(agentDir, "config.yml"),
|
|
`extensions:\n - ${stale}\nother:\n - ${stale}\nfirstRunComplete: true\n`);
|
|
await withEnv({ PI_CODING_AGENT_DIR: agentDir }, async () => {
|
|
assert.match(pluginRemove("omp"), /removed/);
|
|
});
|
|
assert.equal(fs.readFileSync(path.join(agentDir, "config.yml"), "utf8"),
|
|
`extensions:\nother:\n - ${stale}\nfirstRunComplete: true\n`);
|
|
}
|
|
|
|
// (c) PI_CODING_AGENT_DIR pointing at a bili overlay redirects to the real home
|
|
{
|
|
const realHome = path.join(home, "c", ".omp", "agent");
|
|
const overlay = realHome + "-bili";
|
|
fs.mkdirSync(realHome, { recursive: true });
|
|
fs.mkdirSync(overlay, { recursive: true });
|
|
fs.writeFileSync(path.join(realHome, "config.yml"), "firstRunComplete: true\n");
|
|
fs.writeFileSync(path.join(overlay, "config.yml"), "extensions:\n - /stale/overlay/dist/agent/omp.js\n");
|
|
await withEnv({ PI_CODING_AGENT_DIR: overlay }, async () => {
|
|
assert.match(pluginInstall("omp"), /installed/);
|
|
});
|
|
assert.match(fs.readFileSync(path.join(realHome, "config.yml"), "utf8"),
|
|
/extensions:\n - .*dist[\\/]agent[\\/]omp-native\.js\n/);
|
|
assert.equal(fs.readFileSync(path.join(overlay, "config.yml"), "utf8"),
|
|
"extensions:\n - /stale/overlay/dist/agent/omp.js\n");
|
|
}
|
|
|
|
// (d) a stale entry (target file gone) reports "broken"
|
|
{
|
|
const agentDir = path.join(home, "d", ".omp", "agent");
|
|
fs.mkdirSync(agentDir, { recursive: true });
|
|
fs.writeFileSync(path.join(agentDir, "config.yml"), `extensions:\n - ${stale}\n`);
|
|
await withEnv({ PI_CODING_AGENT_DIR: agentDir }, async () => {
|
|
assert.equal(pluginStatusAll().find((r) => r.agent === "omp")?.status, "broken");
|
|
});
|
|
}
|
|
} finally {
|
|
if (createdOmpDist) fs.rmSync(ompDistFile, { force: true });
|
|
}
|
|
rmrf(home);
|
|
});
|
|
|
|
test("resolveProxyOrigin discovers the running proxy via the state file", async () => {
|
|
const state = fs.mkdtempSync(path.join(os.tmpdir(), "bili-state-"));
|
|
await withEnv({ XDG_STATE_HOME: state, BILI_MCP_PROXY: undefined }, () => {
|
|
assert.equal(resolveProxyOrigin(), "http://127.0.0.1:8787");
|
|
fs.mkdirSync(path.join(state, "billion-context"), { recursive: true });
|
|
fs.writeFileSync(path.join(state, "billion-context", "proxy-origin"), "http://127.0.0.1:8792\n");
|
|
assert.equal(resolveProxyOrigin(), "http://127.0.0.1:8792");
|
|
fs.writeFileSync(path.join(state, "billion-context", "proxy-origin"), "ftp://bad\ngarbage");
|
|
assert.equal(resolveProxyOrigin(), "http://127.0.0.1:8787");
|
|
});
|
|
await withEnv({ XDG_STATE_HOME: state, BILI_MCP_PROXY: "http://10.0.0.5:9000" }, () => {
|
|
assert.equal(resolveProxyOrigin(), "http://10.0.0.5:9000");
|
|
});
|
|
rmrf(state);
|
|
});
|
|
|
|
test("plugin install refuses to touch broken or non-object configs", async () => {
|
|
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-plugin-home-"));
|
|
const piAgentDir = path.join(home, ".pi/agent");
|
|
await withEnv(hintEnv(home, piAgentDir), async () => {
|
|
fs.mkdirSync(piAgentDir, { recursive: true });
|
|
fs.writeFileSync(path.join(piAgentDir, "settings.json"), "{ not json");
|
|
assert.throws(() => pluginInstall("pi"), /not valid JSON/);
|
|
assert.equal(fs.existsSync(path.join(piAgentDir, "settings.json.bili-bak")), false);
|
|
fs.writeFileSync(path.join(piAgentDir, "settings.json"), "[1,2]");
|
|
assert.throws(() => pluginInstall("pi"), /expected a JSON object/);
|
|
fs.writeFileSync(path.join(piAgentDir, "settings.json"), JSON.stringify({ packages: [`/opt/old/node_modules/billion-context`] }));
|
|
assert.match(pluginInstall("pi"), /installed/);
|
|
const after = JSON.parse(fs.readFileSync(path.join(piAgentDir, "settings.json"), "utf8")) as { packages: string[] };
|
|
assert.equal(after.packages.length, 1);
|
|
assert.ok(after.packages[0]!.endsWith(selfPackageRoot().slice(-10)) || after.packages[0] === selfPackageRoot());
|
|
const ocDir = path.join(home, ".config/opencode");
|
|
fs.mkdirSync(ocDir, { recursive: true });
|
|
fs.writeFileSync(path.join(ocDir, "opencode.json"), "nope{");
|
|
assert.throws(() => pluginInstall("opencode"), /not valid JSON/);
|
|
});
|
|
rmrf(home);
|
|
});
|
|
|
|
// #836 (found in #809 N4): a non-object `mcp` (e.g. bare string) made
|
|
// `"bili" in mcp` throw — crashing remove (stranding a half-install) and
|
|
// surfacing "error:" from status. All three opencode sites must degrade
|
|
// gracefully instead of throwing.
|
|
test("plugin opencode survives a non-object mcp (issue #836 / #809 N4)", async () => {
|
|
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-plugin-home-"));
|
|
const piAgentDir = path.join(home, ".pi/agent");
|
|
await withEnv(hintEnv(home, piAgentDir), async () => {
|
|
const ocDir = path.join(home, ".config/opencode");
|
|
fs.mkdirSync(ocDir, { recursive: true });
|
|
const ocFile = path.join(ocDir, "opencode.json");
|
|
const malformed = JSON.stringify({ mcp: "bogus-string", other: 1 });
|
|
fs.writeFileSync(ocFile, malformed);
|
|
|
|
assert.doesNotThrow(() => pluginRemove("opencode"));
|
|
assert.match(pluginRemove("opencode"), /not installed/);
|
|
assert.equal(pluginStatusAll().find((r) => r.agent === "opencode")!.status, "not installed");
|
|
assert.equal(fs.readFileSync(ocFile, "utf8"), malformed);
|
|
|
|
// New installer (#919/#927): a bogus mcp key skips ONLY the mcp shell
|
|
// (#926: only reachable via --with-mcp now) — the native plugin entry
|
|
// + compaction.auto still land, and sibling keys survive untouched.
|
|
assert.doesNotThrow(() => pluginInstall("opencode"));
|
|
assert.match(pluginInstall("opencode", { withMcp: true }), /skipped/i);
|
|
assert.match(pluginInstall("opencode"), /mcp\.bili not written/);
|
|
const data = JSON.parse(fs.readFileSync(ocFile, "utf8")) as Record<string, unknown>;
|
|
assert.equal(data.mcp, "bogus-string");
|
|
assert.equal(data.other, 1);
|
|
const ocKey = pickPluginKey(detectOpencodeMajor());
|
|
assert.deepEqual(data[ocKey], [path.join(ocDir, "plugins", "billion-context")]);
|
|
assert.deepEqual(data.compaction, { auto: false });
|
|
});
|
|
rmrf(home);
|
|
});
|
|
|
|
// #839 (found while reviewing #837): same bug class as #836 on the claude side
|
|
// — a non-object `mcpServers` in .claude.json made `"bili" in mcpServers` throw
|
|
// in claudeStatus(), crashing remove (which calls status first) and surfacing
|
|
// "error:" from status.
|
|
test("plugin claude survives a non-object mcpServers (issue #839)", async () => {
|
|
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-plugin-home-"));
|
|
const piAgentDir = path.join(home, ".pi/agent");
|
|
await withEnv(hintEnv(home, piAgentDir), async () => {
|
|
const cFile = path.join(home, ".claude.json");
|
|
const malformed = JSON.stringify({ mcpServers: "bogus-string", other: 1 });
|
|
fs.writeFileSync(cFile, malformed);
|
|
|
|
assert.doesNotThrow(() => pluginRemove("claude"));
|
|
assert.match(pluginRemove("claude"), /not installed/);
|
|
assert.equal(pluginStatusAll().find((r) => r.agent === "claude")!.status, "not installed");
|
|
assert.equal(fs.readFileSync(cFile, "utf8"), malformed);
|
|
});
|
|
rmrf(home);
|
|
});
|
|
|
|
test("plugin list survives a broken host config (per-row error, no crash)", async () => {
|
|
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-plugin-home-"));
|
|
const piAgentDir = path.join(home, ".pi/agent");
|
|
await withEnv(hintEnv(home, piAgentDir), async () => {
|
|
fs.writeFileSync(path.join(home, ".claude.json"), "{ broken json");
|
|
const rows = pluginStatusAll();
|
|
assert.equal(rows.length, 10);
|
|
// #964: claude status never throws — a broken .claude.json just means
|
|
// "MCP face unreadable" (false); the managed block reads settings.json
|
|
// separately, so the row degrades to not-installed instead of error.
|
|
const claude = rows.find((r) => r.agent === "claude")!;
|
|
assert.equal(claude.status, "not installed");
|
|
const pi = rows.find((r) => r.agent === "pi")!;
|
|
assert.equal(pi.status, "not installed");
|
|
});
|
|
rmrf(home);
|
|
});
|
|
|
|
test("mcp forwardTool times out against a hanging proxy", async () => {
|
|
const server = http.createServer(() => {});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const origin = `http://127.0.0.1:${(server.address() as { port: number }).port}`;
|
|
await withEnv({ BILI_MCP_PROXY: origin }, async () => {
|
|
await assert.rejects(() => mcpForwardTool("compress", {}, 200), /timed out after 200ms/);
|
|
});
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
});
|
|
|
|
test("registered tools declare loadMode essential so omp 17.x keeps them top-level", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
// omp mounts extension tools that omit loadMode under xd:// devices —
|
|
// invisible to the main turn's tools array. "essential" keeps them in.
|
|
for (const tool of pi.tools) {
|
|
assert.equal((tool as unknown as { loadMode?: string }).loadMode, "essential");
|
|
}
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("omp plugin identity-registers the conversation once tools are ready", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
ompPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy, "omp-sess-7"));
|
|
await waitForTools(pi, 2);
|
|
// omp never emits before_provider_headers, so the plugin must bind the
|
|
// conversation via the launcher identity register (#162 semantics).
|
|
const deadline = Date.now() + 15000;
|
|
while (proxy.registers.length === 0 && Date.now() < deadline) {
|
|
await new Promise((r) => setTimeout(r, 25));
|
|
}
|
|
assert.deepEqual(proxy.registers, [{ conversationId: "omp-sess-7", agent: "omp", identity: true }]);
|
|
// Re-driving per-request events must not re-POST (identityAt caches by sid).
|
|
await pi.events.get("before_provider_request")!({}, fakeCtx(proxy, "omp-sess-7"));
|
|
await flush();
|
|
assert.equal(proxy.registers.length, 1);
|
|
// A new session re-registers under its own id.
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy, "omp-sess-8"));
|
|
const deadline2 = Date.now() + 15000;
|
|
while (proxy.registers.length < 2 && Date.now() < deadline2) {
|
|
await new Promise((r) => setTimeout(r, 25));
|
|
}
|
|
assert.deepEqual(proxy.registers[1], { conversationId: "omp-sess-8", agent: "omp", identity: true });
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#1230: before_provider_request awaits identity registration — omp one-shot (-p) first dispatch claims plugin mode", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
ompPlugin(pi as never);
|
|
// The -p shape: NO session_start prewarm — the one and only request
|
|
// dispatches at boot. omp's runner awaits async handlers and sends the
|
|
// resolved payload, so by the time the handler RESOLVES the identity
|
|
// register must already have landed on the wire — the proxy binds the
|
|
// dispatching session into plugin mode instead of an anonymous pfa.
|
|
const out = await pi.events.get("before_provider_request")!({ type: "before_provider_request", payload: { model: "m", messages: [{ role: "user", content: "hi" }] } }, fakeCtx(proxy, "omp-sess-oneshot"));
|
|
assert.equal(pi.tools.length, 2, "tools registered before the request could leave");
|
|
assert.deepEqual(proxy.registers, [{ conversationId: "omp-sess-oneshot", agent: "omp", identity: true }], "identity register landed BEFORE the handler resolved");
|
|
assert.equal((out as Record<string, unknown>).prompt_cache_key, "omp-sess-oneshot", "payload still stamped with the omp session id");
|
|
// Subsequent fires stay cached (no re-register, no re-fetch).
|
|
const again = await pi.events.get("before_provider_request")!({ type: "before_provider_request", payload: { model: "m", messages: [{ role: "user", content: "hi" }] } }, fakeCtx(proxy, "omp-sess-oneshot"));
|
|
assert.deepEqual(proxy.registers, [{ conversationId: "omp-sess-oneshot", agent: "omp", identity: true }], "no duplicate register on the second fire");
|
|
assert.equal((again as Record<string, unknown>).prompt_cache_key, "omp-sess-oneshot");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("pi plugin does not identity-register (it stamps headers instead)", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
biliPlugin(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy));
|
|
await waitForTools(pi, 2);
|
|
await pi.events.get("before_provider_request")!({}, fakeCtx(proxy));
|
|
await flush();
|
|
assert.deepEqual(proxy.registers, []);
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("omp identity register failure throttles and retries later", async () => {
|
|
const proxy = await startFakeProxy({ failRegister: 500 });
|
|
try {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("omp", { retryIntervalMs: 500 })(pi as never);
|
|
await pi.events.get("session_start")!({}, fakeCtx(proxy, "omp-sess-9"));
|
|
await waitForTools(pi, 2);
|
|
const deadline = Date.now() + 15000;
|
|
while (proxy.registers.length < 1 && Date.now() < deadline) {
|
|
await new Promise((r) => setTimeout(r, 25));
|
|
}
|
|
assert.equal(proxy.registers.length, 1);
|
|
// Throttled: a burst of per-request events right after the failure must
|
|
// not hammer the endpoint (retryAt gates re-entry).
|
|
for (let i = 0; i < 5; i++) {
|
|
await pi.events.get("before_provider_request")!({}, fakeCtx(proxy, "omp-sess-9"));
|
|
await flush();
|
|
}
|
|
assert.equal(proxy.registers.length, 1, "throttled — no immediate retry");
|
|
// After the throttle window, a per-request event retries ONLY the
|
|
// register (re-fetches manifest, re-POSTs register; tools are NOT
|
|
// re-registered).
|
|
await new Promise((r) => setTimeout(r, 700));
|
|
await pi.events.get("before_provider_request")!({}, fakeCtx(proxy, "omp-sess-9"));
|
|
const deadline2 = Date.now() + 5000;
|
|
while (proxy.registers.length < 2 && Date.now() < deadline2) {
|
|
await new Promise((r) => setTimeout(r, 25));
|
|
}
|
|
assert.equal(proxy.registers.length, 2, "retried after the throttle window");
|
|
assert.equal(pi.registerCalls, 2, "tools registered once, not re-registered on retry");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("#1362: omp child sessions report parentConversationId in the identity register", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("omp")(pi as never);
|
|
// omp fork() records the parent's BARE SESSION ID in the header.
|
|
const headerCtx = { ...fakeCtx(proxy, "omp-sess-child"), sessionManager: { getSessionId: () => "omp-sess-child", getHeader: () => ({ type: "session", id: "omp-sess-child", parentSession: "omp-parent-bare-id" }) } };
|
|
await pi.events.get("session_start")!({}, headerCtx);
|
|
await waitForTools(pi, 2);
|
|
const deadline = Date.now() + 15000;
|
|
while (proxy.registers.length < 1 && Date.now() < deadline) {
|
|
await new Promise((r) => setTimeout(r, 25));
|
|
}
|
|
assert.deepEqual(proxy.registers, [{ conversationId: "omp-sess-child", agent: "omp", identity: true, parentConversationId: "omp-parent-bare-id" }], "bare-id parentSession reported verbatim");
|
|
|
|
// A plain omp session (no parentSession) keeps today's exact payload shape.
|
|
const pi2 = makeFakePi();
|
|
createBiliPlugin("omp")(pi2 as never);
|
|
await pi2.events.get("session_start")!({}, fakeCtx(proxy, "omp-sess-plain"));
|
|
await waitForTools(pi2, 2);
|
|
const deadline2 = Date.now() + 15000;
|
|
while (proxy.registers.length < 2 && Date.now() < deadline2) {
|
|
await new Promise((r) => setTimeout(r, 25));
|
|
}
|
|
assert.deepEqual(proxy.registers[1], { conversationId: "omp-sess-plain", agent: "omp", identity: true }, "no parentConversationId key for root sessions");
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
// #266: omp's chat-completions payloads carry NO conversation signal, so the
|
|
// plugin stamps prompt_cache_key with the omp session id. #1403: pck is a
|
|
// bili-internal identity signal, so it is ONLY stamped when the destination
|
|
// will actually reach the proxy (/bili/-rewritten URL, BILLION_CONTEXT_PROXY
|
|
// origin, or BILI_MITM_HOSTS whitelist) — a strict-schema upstream behind a
|
|
// blind tunnel would reject the foreign field. The
|
|
// before_provider_request return value REPLACES the whole outgoing payload
|
|
// (omp onPayload chain), so the matrix below drives the real handler and
|
|
// asserts exactly which payload shapes get stamped. fakeCtx(undefined) keeps
|
|
// registerTools a no-op (no proxy) so the test is pure.
|
|
test("omp before_provider_request stamps prompt_cache_key only for chat-completions payloads (injection matrix)", async () => {
|
|
const sid = "omp-uuid-abc";
|
|
const mk = (): FakePi => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("omp")(pi as never);
|
|
return pi;
|
|
};
|
|
// #1230: the handler is async (it awaits tool registration); fakeCtx
|
|
// (undefined) keeps registerTools a no-op, so awaiting stays pure. The
|
|
// ctx carries a /bili/-rewritten baseUrl so the destination counts as
|
|
// proxy-routed (#1403).
|
|
const routedCtx = (): Record<string, unknown> => ({
|
|
...fakeCtx(undefined, sid),
|
|
model: { contextWindow: 1000000, baseUrl: "http://127.0.0.1:8787/bili/https://api.example.com/v1" },
|
|
});
|
|
const handler = async (pi: FakePi, payload: unknown) =>
|
|
pi.events.get("before_provider_request")!({ type: "before_provider_request", payload }, routedCtx());
|
|
|
|
// chat payload (messages, no input, no max_tokens, no native pck) → stamped
|
|
{
|
|
const pi = mk();
|
|
const payload = { model: "glm-4", messages: [{ role: "user", content: "hi" }] };
|
|
const out = await handler(pi, payload) as Record<string, unknown>;
|
|
assert.equal(out.prompt_cache_key, sid, "chat payload stamped with the omp session id");
|
|
assert.deepEqual(out.messages, payload.messages, "rest of the payload preserved");
|
|
assert.equal((payload as Record<string, unknown>).prompt_cache_key, undefined, "original payload not mutated");
|
|
}
|
|
// real-world chat-completions payload carries max_tokens (omp's openai-compat
|
|
// providers use maxTokensField:"max_tokens") → stamped (#268)
|
|
{
|
|
const pi = mk();
|
|
const out = await handler(pi, { model: "glm-4", messages: [{ role: "user", content: "hi" }], max_tokens: 4096, temperature: 0.7 }) as Record<string, unknown>;
|
|
assert.equal(out.prompt_cache_key, sid, "chat-completions payload WITH max_tokens stamped");
|
|
assert.equal(out.max_tokens, 4096, "max_tokens preserved");
|
|
}
|
|
// native prompt_cache_key already present → not overridden
|
|
{
|
|
const pi = mk();
|
|
const out = await handler(pi, { messages: [{ role: "user", content: "hi" }], prompt_cache_key: "native-pck" });
|
|
assert.equal(out, undefined, "native pck is not overridden");
|
|
}
|
|
// responses payload (input array) → untouched
|
|
{
|
|
const pi = mk();
|
|
const out = await handler(pi, { input: [{ role: "user", content: "hi" }] });
|
|
assert.equal(out, undefined, "responses payload (input) untouched");
|
|
}
|
|
// anthropic wire shape (messages + max_tokens) → stamped too when the
|
|
// destination is proxy-visible: the plugin cannot tell the wires apart by
|
|
// shape, and the proxy records the mapping from the body pck on the
|
|
// anthropic path and strips the field before forwarding (#268/#1403)
|
|
{
|
|
const pi = mk();
|
|
const out = await handler(pi, { messages: [{ role: "user", content: "hi" }], max_tokens: 1024, system: "s" }) as Record<string, unknown>;
|
|
assert.equal(out.prompt_cache_key, sid, "anthropic wire shape stamped (proxy strips before forward)");
|
|
}
|
|
// no session id → untouched
|
|
{
|
|
const pi = mk();
|
|
const out = await pi.events.get("before_provider_request")!({ type: "before_provider_request", payload: { messages: [{ role: "user", content: "hi" }] } }, fakeCtx(undefined, ""));
|
|
assert.equal(out, undefined, "no session id → untouched");
|
|
}
|
|
// non-object payload → untouched
|
|
{
|
|
const pi = mk();
|
|
assert.equal(await handler(pi, "not an object"), undefined, "non-object payload untouched");
|
|
assert.equal(await handler(pi, null), undefined, "null payload untouched");
|
|
assert.equal(await handler(pi, [1, 2, 3]), undefined, "array payload untouched");
|
|
}
|
|
// no messages array → untouched
|
|
{
|
|
const pi = mk();
|
|
const out = await pi.events.get("before_provider_request")!({ type: "before_provider_request", payload: { model: "m" } }, fakeCtx(undefined, sid));
|
|
assert.equal(out, undefined, "no messages array → untouched");
|
|
}
|
|
|
|
// #1403: destination gating — pck only reaches the proxy when the traffic
|
|
// actually flows through it; stamping for blind-tunnel destinations just
|
|
// leaks a foreign top-level field into strict-schema upstreams.
|
|
{
|
|
const pi = mk();
|
|
const out = await pi.events.get("before_provider_request")!({ type: "before_provider_request", payload: { messages: [{ role: "user", content: "hi" }] } }, fakeCtx(undefined, sid));
|
|
assert.equal(out, undefined, "external host not routed through the proxy → not stamped (#1403)");
|
|
}
|
|
{
|
|
const prev = process.env.BILI_MITM_HOSTS;
|
|
process.env.BILI_MITM_HOSTS = "api.example.com";
|
|
try {
|
|
const pi = mk();
|
|
const out = await pi.events.get("before_provider_request")!({ type: "before_provider_request", payload: { messages: [{ role: "user", content: "hi" }] } }, fakeCtx(undefined, sid)) as Record<string, unknown>;
|
|
assert.equal(out.prompt_cache_key, sid, "MITM-whitelisted external host → stamped (#1403)");
|
|
} finally {
|
|
if (prev === undefined) delete process.env.BILI_MITM_HOSTS;
|
|
else process.env.BILI_MITM_HOSTS = prev;
|
|
}
|
|
}
|
|
{
|
|
const prev = process.env.BILLION_CONTEXT_PROXY;
|
|
process.env.BILLION_CONTEXT_PROXY = "http://127.0.0.1:8787";
|
|
try {
|
|
const pi = mk();
|
|
const ctx = { ...fakeCtx(undefined, sid), model: { contextWindow: 1000000, baseUrl: "http://127.0.0.1:8787/v1/messages" } };
|
|
const out = await pi.events.get("before_provider_request")!({ type: "before_provider_request", payload: { messages: [{ role: "user", content: "hi" }] } }, ctx) as Record<string, unknown>;
|
|
assert.equal(out.prompt_cache_key, sid, "BILLION_CONTEXT_PROXY-matched origin → stamped (#1403)");
|
|
} finally {
|
|
if (prev === undefined) delete process.env.BILLION_CONTEXT_PROXY;
|
|
else process.env.BILLION_CONTEXT_PROXY = prev;
|
|
}
|
|
}
|
|
});
|
|
|
|
test("pi agent never stamps prompt_cache_key (it stamps headers instead)", async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const out = await pi.events.get("before_provider_request")!({ type: "before_provider_request", payload: { messages: [{ role: "user", content: "hi" }] } }, fakeCtx(undefined, "pi-uuid"));
|
|
assert.equal(out, undefined, "pi agent never stamps the body");
|
|
});
|
|
|
|
async function waitForRuntimeInfoCount(proxy: FakeProxy, count: number, timeoutMs = 15000): Promise<void> {
|
|
const deadline = Date.now() + timeoutMs;
|
|
while (proxy.runtimeInfos.length < count) {
|
|
if (Date.now() > deadline) throw new Error(`timed out waiting for ${count} runtime-info reports; got ${proxy.runtimeInfos.length}`);
|
|
await new Promise((r) => setTimeout(r, 25));
|
|
}
|
|
}
|
|
|
|
test("#957: omp reports runtime-info via before_provider_request (omp has no header event)", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
const pi = makeFakePi();
|
|
ompPlugin(pi as never);
|
|
const baseModel = { baseUrl: `${proxy.origin}/bili/https://api.example.com/v1` };
|
|
const ctxA = { ...fakeCtx(proxy, "omp-rt-1"), model: { id: "omp-rt-model-a", contextWindow: 200000, maxTokens: 32768, ...baseModel } };
|
|
const ctxB = { ...fakeCtx(proxy, "omp-rt-1"), model: { id: "omp-rt-model-b", contextWindow: 128000, maxTokens: 16384, ...baseModel } };
|
|
await pi.events.get("session_start")!({}, ctxA);
|
|
// #1230: the request handler awaits tool registration, so by the time
|
|
// round 1's handler resolves the tools are ready and the report rides
|
|
// the FIRST request (previously round 1 left before toolsReady flipped
|
|
// and reported nothing — a race artifact, not a policy).
|
|
await pi.events.get("before_provider_request")!({}, ctxA);
|
|
// #1531: the handler AWAITs the report, so by the time it resolves
|
|
// (i.e. before the model request dispatches) the POST has landed —
|
|
// no polling needed, and the ordering is asserted directly.
|
|
assert.equal(proxy.runtimeInfos.length, 1, "report lands before the request dispatches (#1531)");
|
|
assert.deepEqual(proxy.runtimeInfos[0], {
|
|
agent: "omp",
|
|
model: "omp-rt-model-a",
|
|
contextWindow: 200000,
|
|
maxOutput: 32768,
|
|
baseURL: `${proxy.origin}/bili/https://api.example.com/v1`,
|
|
conversationId: "omp-rt-1",
|
|
source: "client-config",
|
|
});
|
|
// same model again → deduped, no second POST
|
|
await pi.events.get("before_provider_request")!({}, ctxA);
|
|
await flush();
|
|
assert.equal(proxy.runtimeInfos.length, 1, "deduped per model switch");
|
|
// model switch → exactly one more report with the new config
|
|
await pi.events.get("before_provider_request")!({}, ctxB);
|
|
await waitForRuntimeInfoCount(proxy, 2);
|
|
assert.deepEqual(proxy.runtimeInfos[1], {
|
|
agent: "omp",
|
|
model: "omp-rt-model-b",
|
|
contextWindow: 128000,
|
|
maxOutput: 16384,
|
|
baseURL: `${proxy.origin}/bili/https://api.example.com/v1`,
|
|
conversationId: "omp-rt-1",
|
|
source: "client-config",
|
|
});
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|
|
|
|
test("before_agent_start awaits tool registration so Turn 1 system prompt includes ACP tools without a Turn 2 codemode_catalog patch", async () => {
|
|
const proxy = await startFakeProxy();
|
|
try {
|
|
await withEnv({ BILLION_CONTEXT_PROXY: undefined }, async () => {
|
|
const pi = makeFakePi();
|
|
createBiliPlugin("pi")(pi as never);
|
|
const ctx = fakeCtx(proxy, "sess-before-agent-start");
|
|
assert.equal(pi.tools.length, 0, "no tools before before_agent_start when session_start was not awaited");
|
|
const beforeAgentStart = pi.events.get("before_agent_start");
|
|
assert.ok(beforeAgentStart, "before_agent_start handler registered");
|
|
await beforeAgentStart({}, ctx);
|
|
assert.equal(pi.tools.length, 2, "ACP tools registered before _prepareRun freezes Turn 1 tool loadout and codemode_catalog");
|
|
assert.deepEqual(pi.tools.map((t) => t.name).sort(), ["acp_status", "compress"]);
|
|
});
|
|
} finally {
|
|
await proxy.close();
|
|
}
|
|
});
|