Skip to content

A desktop coding agent with free access to frontier models.

TypeScript

fix: write check runs in a private folder

ogsamratc196d771c7f9
diff --git a/apps/server/src/folder-write-check.test.ts b/apps/server/src/folder-write-check.test.ts
index f69fdb87..e690647b 100644
--- a/apps/server/src/folder-write-check.test.ts
+++ b/apps/server/src/folder-write-check.test.ts
@@ -1,14 +1,17 @@
import { afterEach, describe, expect, test } from "bun:test";
import { chmodSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
+import { mkdtemp, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import os, { tmpdir } from "node:os";
+import path, { join } from "node:path";
import {
checkFolderWritable,
classifyFailure,
controlledFolderAccessOn,
folderWriteGate,
+ isolatedBunArgs,
probeInProcess,
+ probeWithEngine,
readOnlyPrompt,
resetFolderWriteGate,
type FolderProbeOutcome,
@@ -139,6 +142,54 @@ describe("checkFolderWritable", () => {
});
});
+describe("probeWithEngine", () => {
+ test("runs bun in a private folder: a bunfig.toml or .env in the temporary folder (or anywhere) is never read", async () => {
+ const shared = await mkdtemp(join(tmpdir(), "omnirush-shared-tmp-"));
+ const target = await mkdtemp(join(tmpdir(), "omnirush-probe-target-"));
+ const marker = join(shared, "marker");
+ await writeFile(join(shared, "bunfig.toml"), 'preload = ["./evil.ts"]\n');
+ await writeFile(join(shared, ".env"), "PROBE_PLANTED=yes\n");
+ await writeFile(join(shared, "evil.ts"), `import { appendFileSync } from "node:fs"; appendFileSync(${JSON.stringify(marker)}, "loaded " + (process.env.PROBE_PLANTED ?? "-") + "\\n");\n`);
+ const previous = process.env.TMPDIR;
+ try {
+ // The planted folder works: bun started there without the probe's options runs it.
+ const control = Bun.spawnSync([process.execPath, "-e", "0"], { cwd: shared, env: { ...process.env } });
+ expect(control.exitCode).toBe(0);
+ expect(await readFile(marker, "utf8")).toContain("loaded yes");
+ await rm(marker, { force: true });
+ // The probe, with the planted folder as the temporary folder: nothing of it is read.
+ process.env.TMPDIR = shared;
+ process.env.BUN_OPTIONS = `--preload=${join(shared, "evil.ts")}`;
+ const outcome = await probeWithEngine(target, process.execPath);
+ expect(outcome).toEqual({ ok: true });
+ expect(await readFile(marker, "utf8").catch(() => "")).toBe("");
+ // Its private folder is gone afterwards.
+ expect((await readdir(shared)).filter((name) => name.startsWith("probe-"))).toEqual([]);
+ // Under the app's user data folder when the desktop names one.
+ const userData = await mkdtemp(join(tmpdir(), "omnirush-user-data-"));
+ process.env.OMNIRUSH_DESKTOP_USER_DATA_DIR = userData;
+ try {
+ expect(await probeWithEngine(target, process.execPath)).toEqual({ ok: true });
+ expect(await readFile(marker, "utf8").catch(() => "")).toBe("");
+ expect(await readdir(join(userData, "write-check"))).toEqual([]);
+ expect((await stat(join(userData, "write-check"))).mode & 0o777).toBe(0o700);
+ } finally {
+ delete process.env.OMNIRUSH_DESKTOP_USER_DATA_DIR;
+ await rm(userData, { recursive: true, force: true });
+ }
+ } finally {
+ if (previous === undefined) delete process.env.TMPDIR; else process.env.TMPDIR = previous;
+ delete process.env.BUN_OPTIONS;
+ await rm(shared, { recursive: true, force: true });
+ await rm(target, { recursive: true, force: true });
+ }
+ });
+
+ test("names an empty bunfig of its own folder and no .env file", () => {
+ expect(isolatedBunArgs("/private/x")).toEqual(["--no-env-file", `--config=${join("/private/x", "bunfig.toml")}`]);
+ });
+});
+
describe("folderWriteGate", () => {
test("once per chat and folder after a pass; again at every prompt after a failure", async () => {
let probes = 0;
diff --git a/apps/server/src/folder-write-check.ts b/apps/server/src/folder-write-check.ts
index fc47827b..4a7d22bf 100644
--- a/apps/server/src/folder-write-check.ts
+++ b/apps/server/src/folder-write-check.ts
@@ -13,7 +13,7 @@
* Kept in step with the CLI (omnirush-cli src/folder-write-check.js).
*/
import { execFile, spawn } from "node:child_process";
-import { closeSync, fsyncSync, openSync, renameSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { chmodSync, closeSync, fsyncSync, mkdirSync, mkdtempSync, openSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
import os from "node:os";
import path from "node:path";
@@ -94,8 +94,43 @@ export function probeInProcess(dir: string): FolderProbeOutcome {
}
}
+/**
+ * The engine binary run as bun reads a bunfig.toml (its `preload` runs code)
+ * and a .env from its working folder. The probe runs in a fresh private
+ * folder of its own (under the app's user data folder, else the temporary
+ * folder; 0700), with an empty bunfig the app writes there named on the
+ * command line and no .env file, so no other folder (a shared temporary
+ * folder, a project) adds anything to it. The same options as the CLI's
+ * helper runtime.
+ */
+export function isolatedBunArgs(folder: string): string[] {
+ return ["--no-env-file", `--config=${path.join(folder, "bunfig.toml")}`];
+}
+
+function isolatedBunFolder(env: NodeJS.ProcessEnv = process.env): string | null {
+ try {
+ const userData = env.OMNIRUSH_DESKTOP_USER_DATA_DIR?.trim();
+ const parent = userData ? path.join(userData, "write-check") : os.tmpdir();
+ if (userData) mkdirSync(parent, { recursive: true, mode: 0o700 });
+ const folder = mkdtempSync(path.join(parent, "probe-"));
+ chmodSync(folder, 0o700);
+ writeFileSync(path.join(folder, "bunfig.toml"), "", { mode: 0o600 });
+ return folder;
+ } catch {
+ return null;
+ }
+}
+
/** The probe run by the engine binary; null when it could not run or said nothing usable. */
export function probeWithEngine(dir: string, engineBin: string, timeoutMs = 15_000): Promise<FolderProbeOutcome | null> {
+ const folder = isolatedBunFolder();
+ if (!folder) return Promise.resolve(null);
+ return probeIn(folder, dir, engineBin, timeoutMs).finally(() => {
+ try { rmSync(folder, { recursive: true, force: true }); } catch { /* best effort */ }
+ });
+}
+
+function probeIn(folder: string, dir: string, engineBin: string, timeoutMs: number): Promise<FolderProbeOutcome | null> {
return new Promise((resolve) => {
let out = "";
let done = false;
@@ -107,9 +142,12 @@ export function probeWithEngine(dir: string, engineBin: string, timeoutMs = 15_0
};
let child: ReturnType<typeof spawn>;
try {
- child = spawn(engineBin, ["-e", PROBE_SCRIPT], {
- cwd: os.tmpdir(),
- env: { ...process.env, BUN_BE_BUN: "1", OMNIRUSH_WRITE_CHECK_DIR: dir },
+ const env: NodeJS.ProcessEnv = { ...process.env, BUN_BE_BUN: "1", OMNIRUSH_WRITE_CHECK_DIR: dir };
+ // Extra command-line options bun would take from the environment.
+ delete env.BUN_OPTIONS;
+ child = spawn(engineBin, [...isolatedBunArgs(folder), "-e", PROBE_SCRIPT], {
+ cwd: folder,
+ env,
stdio: ["ignore", "pipe", "ignore"],
windowsHide: true,
});