The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
// @vitest-environment node
import assert from "node:assert/strict";
import { mkdtempSync, readFileSync, existsSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { test, onTestFinished, vi } from "vitest";
import { spawn } from "node:child_process";
import { once } from "node:events";
import { Server, repoRoot } from "./server.ts";
// The executable fixture uses a POSIX shebang. Windows teardown uses taskkill.
const options = { skip: process.platform === "win32", timeout: 30_000 };
async function fixture(mode = "graceful") {
const home = mkdtempSync(join(tmpdir(), "openidea-server-close-"));
const previous = process.env.OPENIDEA_SERVER;
process.env.OPENIDEA_SERVER = join(repoRoot, "smoke", "fixtures", "server.cjs");
onTestFinished(async () => {
if (previous === undefined) delete process.env.OPENIDEA_SERVER;
else process.env.OPENIDEA_SERVER = previous;
if (existsSync(join(home, "pids.json"))) {
const pids = JSON.parse(readFileSync(join(home, "pids.json"), "utf8"));
for (const pid of Object.values(pids) as number[]) {
for (const target of [pid]) {
try {
process.kill(target, "SIGKILL");
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ESRCH") throw error;
}
}
}
// Reap/observe every owned process before removing its home, even on failure.
await vi.waitFor(
() => {
for (const pid of Object.values(pids) as number[]) assertGone(pid);
},
{ timeout: 3000 },
);
}
rmSync(home, { recursive: true, force: true });
});
return { home, start: () => Server.start(home, { SMOKE_SERVER_MODE: mode }) };
}
function assertGone(pid: number) {
assert.throws(() => process.kill(pid, 0), { code: "ESRCH" });
}
test("close waits for graceful EOF cleanup of a tool in its own group", options, async () => {
const { home, start } = await fixture();
const server = await start();
const pids = JSON.parse(readFileSync(join(home, "pids.json"), "utf8"));
assert.deepEqual(await Promise.all([server.invoke("first", {}), server.invoke("second", {})]), [{}, {}]);
await Promise.all([server.close(), server.close()]);
assert.equal(readFileSync(join(home, "shutdown"), "utf8"), "tool reaped");
assertGone(pids.server);
assertGone(pids.tool);
await server.close();
});
test("failed initialize still runs graceful cleanup and preserves the error", options, async () => {
const { home, start } = await fixture("reject");
await assert.rejects(start(), { message: "initialize failed" });
assert.equal(readFileSync(join(home, "shutdown"), "utf8"), "tool reaped");
});
test("hung EOF shutdown is bounded and kills independent tool groups", options, async () => {
const { home, start } = await fixture("hang");
const server = await start();
const pids = JSON.parse(readFileSync(join(home, "pids.json"), "utf8"));
const started = Date.now();
await server.close();
assert.ok(Date.now() - started >= 15_000);
assert.ok(Date.now() - started < 25_000);
assert.ok(existsSync(join(home, "eof")));
assertGone(pids.server);
assertGone(pids.tool);
});
test("signal exit after EOF also cleans up independent tool groups", options, async () => {
const { home, start } = await fixture("signal");
const server = await start();
const pids = JSON.parse(readFileSync(join(home, "pids.json"), "utf8"));
await server.close();
assertGone(pids.server);
assertGone(pids.tool);
});
test("spawn failure rejects without waiting for an exit event", options, async () => {
const { home } = await fixture();
process.env.OPENIDEA_SERVER = join(home, "missing-server");
await assert.rejects(Server.start(home), { code: "ENOENT" });
});
test("missing ps preserves forced cleanup of the server's inherited group", options, async () => {
const { home, start } = await fixture("hang-inherited");
const server = await start();
const pids = JSON.parse(readFileSync(join(home, "pids.json"), "utf8"));
const previous = process.env.PATH;
process.env.PATH = home;
try {
await server.close();
} finally {
if (previous === undefined) delete process.env.PATH;
else process.env.PATH = previous;
}
assertGone(pids.server);
assertGone(pids.tool);
});
test("fixture consumes multiple requests including coalesced frames", options, async () => {
const { home } = await fixture();
const child = spawn(process.env.OPENIDEA_SERVER!, [], {
env: { ...process.env, OPENIDEA_SERVER_HOME: home, SMOKE_SERVER_MODE: "graceful" },
detached: true,
});
const exited = once(child, "exit");
let output = "";
child.stdout.on("data", (chunk) => {
output += chunk.toString();
});
const frame = (id: number) => {
const body = JSON.stringify({ jsonrpc: "2.0", id, method: "initialize" });
return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
};
// A single write contains two frames and part of the third header.
const third = frame(3);
child.stdin.write(frame(1) + frame(2) + third.slice(0, 10));
await new Promise((resolve) => setTimeout(resolve, 50));
child.stdin.end(third.slice(10));
await exited;
const ids = [...output.matchAll(/"id":(\d+)/g)].map((match) => Number(match[1]));
assert.deepEqual(ids, [1, 2, 3]);
});
test("group-kill errors are reported after cleaning the remaining owned groups", options, async () => {
const { home, start } = await fixture("signal-multiple");
const server = await start();
const pids = JSON.parse(readFileSync(join(home, "pids.json"), "utf8"));
const kill = process.kill.bind(process);
const denied = Object.assign(new Error("group kill denied"), { code: "EPERM" });
const spy = vi.spyOn(process, "kill").mockImplementation((pid, signal) => {
if (pid === -pids.tool && signal === "SIGKILL") throw denied;
return kill(pid, signal);
});
try {
await assert.rejects(server.close(), denied);
assertGone(pids.second);
} finally {
spy.mockRestore();
}
});