Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
17 changes: 17 additions & 0 deletions CLIENTS.md
Original file line number Diff line number Diff line change
Expand Up @@ -348,6 +348,23 @@ client through bili, either resend the full input/output history or set
now logs a `warn` (#1954). Full chaining support is tracked as #1973. See the
[official migration guide](https://developers.openai.com/api/docs/guides/migrate-to-responses).

### Run mode: `bili codex` pins embedded (#1867)

Since ~0.156 Codex can attach to (or auto-start) a machine-wide shared
background server whose model traffic uses the environment that was present
**when the daemon started**, not when a session starts. The launcher's proxy is
session-scoped (its port dies with the process), so a long-lived daemon cannot
route through it safely: if codex starts first without bili's env, later
`bili codex` sessions silently attach to it and bypass compression entirely;
if bili starts first, the surviving daemon keeps pointing at a dead port. The
launcher therefore passes `--no-daemon` explicitly — after probing
`codex --help` for the flag (older binaries launch unchanged) and only when the
user has not already pinned a mode (`--no-daemon` or `--remote`). Result:
deterministic embedded runs, no per-launch fallback warning, no silent bypass.
The #321 budget `-c` args are kept verbatim (embedded mode honors them
identically). If you want the shared background server, run native `codex`
directly — no compression, but tools still work via `bili plugin install codex`.

## Gemini family (Gemini CLI / iFlow CLI / Qwen Code)

Three launchers for the gemini-cli architecture family (#1043 tier 1). Two of
Expand Down
51 changes: 50 additions & 1 deletion src/launcher.ts
Original file line number Diff line number Diff line change
Expand Up @@ -34,7 +34,7 @@ import os from "node:os";
import path from "node:path";
import { createRequire } from "node:module";
import { pathToFileURL } from "node:url";
import { execFileSync, spawn, type StdioOptions } from "node:child_process";
import { execFileSync, spawn, spawnSync, type StdioOptions } from "node:child_process";
import { DEFAULT_MITM_DOMAINS } from "./mitm.js";
import {
claimStartingMarker,
Expand Down Expand Up @@ -2956,6 +2956,48 @@ export function opencodeMajorVersion(command: string): number {
return major;
}

/** #1867: true when the user already pinned codex's run mode themselves — an
* explicit `--no-daemon` (embedded) or `--remote [url]` (remote app server).
* In either case bili must not add its own `--no-daemon`: the first would be a
* duplicate, and codex hard-errors on --no-daemon combined with --remote. */
export function codexRunModePinned(args: readonly string[]): boolean {
return args.some((a) => a === "--no-daemon" || a === "--remote" || a.startsWith("--remote="));
}

const codexNoDaemonCache = new Map<string, boolean>();

/** #1867: whether a Codex CLI binary accepts `--no-daemon`, probed from its
* `--help` output (cached per resolved command). The probe spawns the binary
* exactly the way runClient will (planClientSpawn) with a short timeout; any
* failure defaults to false — injecting a flag the binary does not know would
* break the launch, while skipping it only restores the pre-probe behavior.
* Mirrors the opencodeMajorVersion() precedent. spawnSync (not execFileSync):
* its options accept windowsVerbatimArguments, which the #679 cmd.exe wrap needs. */
export function codexSupportsNoDaemon(
command: string,
prefixArgs: readonly string[],
platform: NodeJS.Platform = process.platform,
): boolean {
const key = JSON.stringify([command, ...prefixArgs]);
const hit = codexNoDaemonCache.get(key);
if (hit !== undefined) return hit;
let supported = false;
try {
const plan = planClientSpawn(command, [...prefixArgs, "--help"], process.env, platform);
const res = spawnSync(plan.command, plan.args, {
timeout: 5000,
stdio: ["ignore", "pipe", "ignore"],
windowsVerbatimArguments: plan.windowsVerbatimArguments,
windowsHide: true,
});
// line-anchored exact-flag match: clap lists each option on its own
// indented line; \b would fail anyway since '-' is not a word char
if (res.status === 0 && !res.error) supported = /(?:^|\n)[ \t]*--no-daemon[ \t]*(?:\r?\n|$)/.test(res.stdout.toString("utf8"));
} catch {}
codexNoDaemonCache.set(key, supported);
return supported;
}

/**
* opencode counterpart of preparePiHttpRewrite: write a full copy of the user's
* (JSONC-tolerant, merged) config with the discovered providers' baseURL
Expand Down Expand Up @@ -4641,6 +4683,13 @@ export async function runLaunch(params: RunLaunchParams, deps: LauncherDeps = {}
} else {
env = buildCodexEnv(origin, codexCaPath, stripInheritedProxy(process.env));
clientArgs = buildCodexArgs(origin, routes.httpRewrites, routes.httpsRewrites, clientArgs);
if (!codexRunModePinned(params.clientArgs)) {
const { command: codexBin, prefixArgs: codexPrefix } = resolveClientCommand(base, process.env);
if (codexSupportsNoDaemon(codexBin, codexPrefix, deps.platform ?? process.platform)) {
clientArgs = ["--no-daemon", ...clientArgs];
console.error("bili: codex pinned to embedded mode (--no-daemon) — the launcher proxy is session-scoped; a shared background server would outlive it and bypass compression.");
}
}
const budgetArgs = await resolveCodexBudgetArgs({
model: config.codex?.model,
clientWindow: config.codex?.contextWindow,
Expand Down
250 changes: 250 additions & 0 deletions tests/launcher.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -85,6 +85,9 @@ import {
stopProxyGuarded,
resolveLauncherWindow,
resolveCodexBudgetArgs,
codexRunModePinned,
codexSupportsNoDaemon,
buildWindowsCommandLine,
resolveClaudeBudgetEnv,
resolveQoderBudgetEnv,
buildQoderEnv,
Expand Down Expand Up @@ -1054,6 +1057,29 @@ function makeFakeChild(pid: number): SpawnChild {
};
}

// #679/#1867 test seam: inverse of planClientSpawn's comspec wrapping — splits
// the single `comspec /d /s /c "<line>"` arg back into tokens (quote-aware;
// quoteWinToken only quotes whitespace-bearing tokens, so this round-trips it).
function splitWindowsCommandLine(line: string): string[] {
const tokens: string[] = [];
let cur = "";
let quoted = false;
for (const ch of line) {
if (ch === '"') {
quoted = !quoted;
continue;
}
if (!quoted && /\s/.test(ch)) {
if (cur !== "") tokens.push(cur);
cur = "";
continue;
}
cur += ch;
}
if (cur !== "") tokens.push(cur);
return tokens;
}

test("ensureProxyRunning: spawns a fresh proxy when no live instance is recorded", async () => {
let spawnCalls = 0;
const spawnImpl: SpawnFn = () => {
Expand Down Expand Up @@ -4200,6 +4226,230 @@ test("runLaunch codex: budget args injected for MITM mode (built-in table window
}
});

test("codexRunModePinned: detects user-pinned run mode (#1867)", () => {
assert.equal(codexRunModePinned([]), false);
assert.equal(codexRunModePinned(["-c", "model_context_window=400000"]), false);
assert.equal(codexRunModePinned(["resume", "abc"]), false);
assert.equal(codexRunModePinned(["--no-daemon"]), true);
assert.equal(codexRunModePinned(["--remote", "ws://127.0.0.1:9"]), true);
assert.equal(codexRunModePinned(["--remote=ws://127.0.0.1:9"]), true);
});

test("splitWindowsCommandLine: round-trips buildWindowsCommandLine quoting (#679/#1867)", () => {
// helper contract: the inner line, i.e. the comspec arg minus its outer quote pair
assert.deepEqual(
splitWindowsCommandLine(buildWindowsCommandLine("C:\\temp\\fake-codex.cmd", ["--no-daemon", "-c", "model_context_window=400000"]).slice(1, -1)),
["C:\\temp\\fake-codex.cmd", "--no-daemon", "-c", "model_context_window=400000"],
);
assert.deepEqual(
splitWindowsCommandLine(buildWindowsCommandLine("C:\\Users\\Some User\\temp\\fake-codex.cmd", ["--remote", "ws://127.0.0.1:9"]).slice(1, -1)),
["C:\\Users\\Some User\\temp\\fake-codex.cmd", "--remote", "ws://127.0.0.1:9"],
);
});

test("codexSupportsNoDaemon: probes --help output, fails soft (#1867)", () => {
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-codex-nodaemon-"));
const isWin = process.platform === "win32";
const helpWithFlag = isWin
? "@echo Options:\r\n@echo --no-daemon\r\n@echo Run without the shared background server\r\n"
: "#!/bin/sh\necho \"Options:\"\necho \" --no-daemon\"\necho \" Run without the shared background server\"\n";
const helpWithoutFlag = isWin
? "@echo Options:\r\n@echo --profile <NAME>\r\n"
: "#!/bin/sh\necho \"Options:\"\necho \" --profile <NAME>\"\n";
const mk = (name: string, body: string): string => {
const p = path.join(dir, name + (isWin ? ".cmd" : ""));
fs.writeFileSync(p, body);
if (!isWin) fs.chmodSync(p, 0o755);
return p;
};
try {
assert.equal(codexSupportsNoDaemon(mk("new-codex", helpWithFlag), []), true);
assert.equal(codexSupportsNoDaemon(mk("old-codex", helpWithoutFlag), []), false);
assert.equal(codexSupportsNoDaemon(mk("dead-codex", isWin ? "@exit /b 3\r\n" : "#!/bin/sh\nexit 3\n"), []), false);
assert.equal(codexSupportsNoDaemon(path.join(dir, "missing-codex" + (isWin ? ".cmd" : "")), []), false);
// cached per command path
const again = mk("new-codex-2", helpWithFlag);
assert.equal(codexSupportsNoDaemon(again, []), true);
fs.writeFileSync(again, helpWithoutFlag);
if (!isWin) fs.chmodSync(again, 0o755);
assert.equal(codexSupportsNoDaemon(again, []), true);
} finally {
rmrf(dir);
}
});

test("runLaunch codex: --no-daemon pinned when supported, escape hatches honored (#1867)", async () => {
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-codex-nodaemon-run-"));
const prevHome = process.env.HOME;
const prevUserProfile = process.env.USERPROFILE;
const prevClientBin = process.env.BILI_CLIENT_BIN;
const prevAnthropicModel = process.env.ANTHROPIC_MODEL;
const prevAutoCompact = process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW;
process.env.HOME = home;
if (prevUserProfile !== undefined) process.env.USERPROFILE = home;
delete process.env.ANTHROPIC_MODEL;
delete process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW;
const isWin = process.platform === "win32";
const fakeCodex = path.join(home, isWin ? "fake-codex.cmd" : "fake-codex");
fs.writeFileSync(fakeCodex, isWin ? "@echo Options:\r\n@echo --no-daemon\r\n@echo Run without the shared background server\r\n" : "#!/bin/sh\necho \"Options:\"\necho \" --no-daemon\"\necho \" Run without the shared background server\"\n");
if (!isWin) fs.chmodSync(fakeCodex, 0o755);
process.env.BILI_CLIENT_BIN = fakeCodex;
const codexHome = path.join(home, ".codex");
fs.mkdirSync(codexHome, { recursive: true });
fs.writeFileSync(path.join(codexHome, "config.toml"), 'model = "gpt-5.5"\n');

const clientArgsSeen: string[][] = [];
const fakeBase = path.basename(fakeCodex);
const spawnImpl: SpawnFn = (cmd, args) => {
// #679: runClient plans the spawn before calling us — on win32 a .cmd
// fake arrives as `comspec /d /s /c "<line>"`, so the client path sits
// inside one arg instead of being cmd itself.
const wrappedLine = cmd !== fakeCodex
? args.find((a): a is string => typeof a === "string" && a.includes(fakeBase))
: undefined;
if (cmd !== fakeCodex && wrappedLine === undefined) return makeFakeChild(42422);
const clientArgs = wrappedLine === undefined
? [...args]
: splitWindowsCommandLine(wrappedLine.slice(1, -1)).slice(1);
clientArgsSeen.push(clientArgs);
const child = makeFakeChild(0);
const orig = child.on!.bind(child);
(child as { on: SpawnChild["on"] }).on = (event, listener) => {
orig(event, listener);
if (event === "exit") setTimeout(() => listener(0, null), 0);
return child;
};
return child;
};
const fetchImpl = async () => ({ ok: true });
const prevExit = process.exit;
process.exit = (() => undefined) as typeof process.exit;
const launch = (clientArgs: string[]) =>
runLaunch(
{ client: "codex", clientArgs, overrides: {} },
{ fetchImpl, fetchHealthInfo: async () => ({ ok: true, pid: lastFakeChildPid }), spawnImpl, sleep: () => Promise.resolve() },
);

try {
// fresh launch → #321 budget args AND explicit embedded pin
await launch([]);
assert.equal(clientArgsSeen.length, 1);
let args = clientArgsSeen[0];
assert.ok(args.includes("--no-daemon"), JSON.stringify(args));
assert.ok(args.includes("model_context_window=400000") && args.includes("model_auto_compact_token_limit=400000"), JSON.stringify(args));

// user self-aligned window (no budget injection) → still pinned: without this
// the session would silently attach to an external daemon and bypass bili
fs.writeFileSync(path.join(codexHome, "config.toml"), 'model = "gpt-5.5"\nmodel_context_window = 1000000\n');
clientArgsSeen.length = 0;
await launch([]);
args = clientArgsSeen[0];
assert.ok(args.includes("--no-daemon"), JSON.stringify(args));
assert.ok(!args.some((a) => a.startsWith("model_context_window=")), JSON.stringify(args));

// unresolvable model (no budget injection) → still pinned
fs.writeFileSync(path.join(codexHome, "config.toml"), 'model = "totally-unknown-model"\n');
clientArgsSeen.length = 0;
await launch([]);
args = clientArgsSeen[0];
assert.ok(args.includes("--no-daemon"), JSON.stringify(args));

// user already passed --no-daemon → not duplicated
clientArgsSeen.length = 0;
await launch(["--no-daemon"]);
args = clientArgsSeen[0];
assert.equal(args.filter((a) => a === "--no-daemon").length, 1, JSON.stringify(args));

// user passed --remote → no injection (codex hard-errors the combo)
clientArgsSeen.length = 0;
await launch(["--remote", "ws://127.0.0.1:9"]);
args = clientArgsSeen[0];
assert.ok(!args.includes("--no-daemon"), JSON.stringify(args));
assert.ok(args.includes("--remote"), JSON.stringify(args));
} finally {
process.exit = prevExit;
process.env.HOME = prevHome;
if (prevUserProfile === undefined) delete process.env.USERPROFILE;
else process.env.USERPROFILE = prevUserProfile;
if (prevClientBin === undefined) delete process.env.BILI_CLIENT_BIN;
else process.env.BILI_CLIENT_BIN = prevClientBin;
if (prevAnthropicModel === undefined) delete process.env.ANTHROPIC_MODEL;
else process.env.ANTHROPIC_MODEL = prevAnthropicModel;
if (prevAutoCompact === undefined) delete process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW;
else process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW = prevAutoCompact;
rmrf(home);
}
});

test("runLaunch codex: old binary without --no-daemon launches unchanged (#1867)", async () => {
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-codex-nodaemon-old-"));
const prevHome = process.env.HOME;
const prevUserProfile = process.env.USERPROFILE;
const prevClientBin = process.env.BILI_CLIENT_BIN;
const prevAnthropicModel = process.env.ANTHROPIC_MODEL;
const prevAutoCompact = process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW;
process.env.HOME = home;
if (prevUserProfile !== undefined) process.env.USERPROFILE = home;
delete process.env.ANTHROPIC_MODEL;
delete process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW;
const isWin = process.platform === "win32";
const fakeCodex = path.join(home, isWin ? "old-codex.cmd" : "old-codex");
fs.writeFileSync(fakeCodex, isWin ? "@echo Options:\r\n@echo --profile <NAME>\r\n" : "#!/bin/sh\necho \"Options:\"\necho \" --profile <NAME>\"\n");
if (!isWin) fs.chmodSync(fakeCodex, 0o755);
process.env.BILI_CLIENT_BIN = fakeCodex;
const codexHome = path.join(home, ".codex");
fs.mkdirSync(codexHome, { recursive: true });
fs.writeFileSync(path.join(codexHome, "config.toml"), "");

const clientArgsSeen: string[][] = [];
const fakeBase = path.basename(fakeCodex);
const spawnImpl: SpawnFn = (cmd, args) => {
// #679: runClient plans the spawn before calling us — on win32 a .cmd
// fake arrives as `comspec /d /s /c "<line>"`, so the client path sits
// inside one arg instead of being cmd itself.
const wrappedLine = cmd !== fakeCodex
? args.find((a): a is string => typeof a === "string" && a.includes(fakeBase))
: undefined;
if (cmd !== fakeCodex && wrappedLine === undefined) return makeFakeChild(42422);
const clientArgs = wrappedLine === undefined
? [...args]
: splitWindowsCommandLine(wrappedLine.slice(1, -1)).slice(1);
clientArgsSeen.push(clientArgs);
const child = makeFakeChild(0);
const orig = child.on!.bind(child);
(child as { on: SpawnChild["on"] }).on = (event, listener) => {
orig(event, listener);
if (event === "exit") setTimeout(() => listener(0, null), 0);
return child;
};
return child;
};
const fetchImpl = async () => ({ ok: true });
const prevExit = process.exit;
process.exit = (() => undefined) as typeof process.exit;

try {
await runLaunch(
{ client: "codex", clientArgs: [], overrides: {} },
{ fetchImpl, fetchHealthInfo: async () => ({ ok: true, pid: lastFakeChildPid }), spawnImpl, sleep: () => Promise.resolve() },
);
assert.equal(clientArgsSeen.length, 1);
assert.ok(!clientArgsSeen[0].includes("--no-daemon"), JSON.stringify(clientArgsSeen[0]));
} finally {
process.exit = prevExit;
process.env.HOME = prevHome;
if (prevUserProfile === undefined) delete process.env.USERPROFILE;
else process.env.USERPROFILE = prevUserProfile;
if (prevClientBin === undefined) delete process.env.BILI_CLIENT_BIN;
else process.env.BILI_CLIENT_BIN = prevClientBin;
if (prevAnthropicModel === undefined) delete process.env.ANTHROPIC_MODEL;
else process.env.ANTHROPIC_MODEL = prevAnthropicModel;
if (prevAutoCompact === undefined) delete process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW;
else process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW = prevAutoCompact;
rmrf(home);
}
});

test("runLaunch claude: CLAUDE_CODE_AUTO_COMPACT_WINDOW injected (built-in table window)", async () => {
const home = fs.mkdtempSync(path.join(os.tmpdir(), "bili-claude-budget-"));
const prevHome = process.env.HOME;
Expand Down
Loading