Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
import { spawn, type ChildProcess } from "child_process";
import fs from "fs/promises";
import fsSync from "fs";
import path from "path";
import os from "os";
import { setToolStatus, getVersionManagerTool } from "@/lib/db/versionManager";
const DEFAULT_PORT = 8317;
const GRACEFUL_TIMEOUT_MS = 5000;
/**
* Builds the `spawn()` options for the cliproxyapi child process.
* `windowsHide: true` suppresses the transient conhost.exe/cmd console
* window Windows briefly flashes open for spawned child processes (#8131).
* Exported (rather than inlined) so a unit test can assert on it directly
* instead of mocking `node:child_process`.
*/
export function buildCliproxyapiSpawnOptions(): {
detached: boolean;
stdio: ["ignore", "pipe", "pipe"];
env: NodeJS.ProcessEnv;
windowsHide: boolean;
} {
return {
detached: false,
stdio: ["ignore", "pipe", "pipe"],
env: { ...process.env },
windowsHide: true,
};
}
function defaultConfigDir(): string {
return process.env.CLIPROXYAPI_CONFIG_DIR || path.join(os.homedir(), ".cli-proxy-api");
}
async function writeConfig(
configDir: string,
port: number,
overrides?: Record<string, unknown>
): Promise<string> {
await fs.mkdir(configDir, { recursive: true });
const configPath = path.join(configDir, "config.yaml");
const config = `port: ${port}
host: 127.0.0.1
log_level: warn
`;
await fs.writeFile(configPath, config);
return configPath;
}
export async function startProcess(
binaryPath: string,
port?: number,
configDir?: string
): Promise<{ pid: number; port: number }> {
const existing = await getVersionManagerTool("cliproxyapi");
if (existing?.pid) {
const alive = isProcessRunning(existing.pid);
if (alive) return { pid: existing.pid, port: existing.port };
}
const actualPort = port || DEFAULT_PORT;
const actualConfigDir = configDir || defaultConfigDir();
await writeConfig(actualConfigDir, actualPort);
const child = spawn(
binaryPath,
["-c", path.join(actualConfigDir, "config.yaml")],
buildCliproxyapiSpawnOptions()
);
child.stdout?.on("data", () => {});
child.stderr?.on("data", () => {});
child.on("error", async (err) => {
await setToolStatus("cliproxyapi", "error", undefined, err.message);
});
child.on("exit", async (code) => {
if (code !== 0 && code !== null) {
await setToolStatus("cliproxyapi", "stopped", undefined, `Process exited with code ${code}`);
}
});
const pid = child.pid;
await setToolStatus("cliproxyapi", "running", pid);
return { pid, port: actualPort };
}
export function isProcessRunning(pid: number): boolean {
try {
process.kill(pid, 0);
return true;
} catch {
return false;
}
}
export function stopProcess(pid: number): Promise<void> {
return new Promise((resolve) => {
if (!isProcessRunning(pid)) {
resolve();
return;
}
try {
process.kill(pid, "SIGTERM");
} catch {
resolve();
return;
}
const timer = setTimeout(() => {
try {
process.kill(pid, "SIGKILL");
} catch {}
clearInterval(check);
resolve();
}, GRACEFUL_TIMEOUT_MS);
const check = setInterval(() => {
if (!isProcessRunning(pid)) {
clearTimeout(timer);
clearInterval(check);
resolve();
}
}, 200);
});
}
export async function restartProcess(
binaryPath: string,
port?: number,
configDir?: string,
currentPid?: number | null
): Promise<{ pid: number; port: number }> {
if (currentPid) {
await stopProcess(currentPid);
await new Promise((r) => setTimeout(r, 500));
}
return startProcess(binaryPath, port, configDir);
}
export async function getProcessInfo(pid: number): Promise<{
pid: number;
alive: boolean;
memoryUsage?: number;
}> {
if (!isProcessRunning(pid)) {
return { pid, alive: false };
}
try {
// #11236: single runtime os.platform() read for the per-OS memory probes —
// a process.platform literal is constant-folded to the build machine's
// platform in the published artifact (same fold class as b43a212680 /
// #10244/#10293), so the darwin probe branch would be pruned on macOS.
const platform = os.platform();
if (platform === "linux" || platform === "android") {
const statusFile = `/proc/${pid}/status`;
const content = await fs.readFile(statusFile, "utf-8");
const match = content.match(/VmRSS:\s+(\d+)\s+kB/);
if (match) {
return { pid, alive: true, memoryUsage: parseInt(match[1], 10) * 1024 };
}
} else if (platform === "darwin") {
const { execFile } = await import("child_process");
const { promisify } = await import("util");
const execFileAsync = promisify(execFile);
const { stdout } = await execFileAsync("ps", ["-o", "rss=", "-p", String(pid)]);
const rssKb = parseInt(stdout.trim(), 10);
if (!isNaN(rssKb)) {
return { pid, alive: true, memoryUsage: rssKb * 1024 };
}
}
return { pid, alive: true };
} catch {
return { pid, alive: true };
}
}