@fased/fased 0.1.60 → 0.1.62

package/dist/gateway/session-utils.js

@@ -19,7 +19,7 @@ import { loadSessionStore } from "../config/sessions/store.js";
 import "../config/sessions.js";
 import { lookupContextTokens } from "../agents/context.js";
 import { listSessionCompactionCheckpoints } from "./session-compaction-checkpoints.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/gateway/session-utils.ts
@@ -41,7 +41,7 @@ function isCombinedSessionStoreCacheFresh(entry) {
 }
 function readSessionStoreSignature(storePath) {
 	try {
-		const stat = fs.statSync(storePath);
+		const stat = syncFs.statSync(storePath);
 		return {
 			storePath,
 			exists: true,
@@ -94,7 +94,7 @@ function clearCombinedSessionStoreCacheForTest() {
 }
 function tryResolveExistingPath(value) {
 	try {
-		return fs.realpathSync(value);
+		return syncFs.realpathSync(value);
 	} catch {
 		return null;
 	}
@@ -132,11 +132,11 @@ function resolveIdentityAvatarUrl(cfg, agentId, avatar) {
 			return undefined;
 		}
 		try {
-			const buffer = fs.readFileSync(opened.fd);
+			const buffer = syncFs.readFileSync(opened.fd);
 			const mime = resolveAvatarMime(resolvedCandidate);
 			return `data:${mime};base64,${buffer.toString("base64")}`;
 		} finally {
-			fs.closeSync(opened.fd);
+			syncFs.closeSync(opened.fd);
 		}
 	} catch {
 		return undefined;
@@ -304,7 +304,7 @@ function listExistingAgentIdsFromDisk() {
 	const root = resolveStateDir();
 	const agentsDir = path.join(root, "agents");
 	try {
-		const entries = fs.readdirSync(agentsDir, { withFileTypes: true });
+		const entries = syncFs.readdirSync(agentsDir, { withFileTypes: true });
 		return entries.filter((entry) => entry.isDirectory()).map((entry) => normalizeAgentId(entry.name)).filter(Boolean);
 	} catch {
 		return [];

package/dist/hooks/bundled-dir.js

@@ -1,5 +1,5 @@
 import { fileURLToPath } from "node:url";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/hooks/bundled-dir.ts
@@ -11,14 +11,14 @@ function resolveBundledHooksDir() {
 	try {
 		const execDir = path.dirname(process.execPath);
 		const sibling = path.join(execDir, "hooks", "bundled");
-		if (fs.existsSync(sibling)) {
+		if (syncFs.existsSync(sibling)) {
 			return sibling;
 		}
 	} catch {}
 	try {
 		const moduleDir = path.dirname(fileURLToPath(import.meta.url));
 		const distBundled = path.join(moduleDir, "bundled");
-		if (fs.existsSync(distBundled)) {
+		if (syncFs.existsSync(distBundled)) {
 			return distBundled;
 		}
 	} catch {}
@@ -26,7 +26,7 @@ function resolveBundledHooksDir() {
 		const moduleDir = path.dirname(fileURLToPath(import.meta.url));
 		const root = path.resolve(moduleDir, "..", "..");
 		const srcBundled = path.join(root, "src", "hooks", "bundled");
-		if (fs.existsSync(srcBundled)) {
+		if (syncFs.existsSync(srcBundled)) {
 			return srcBundled;
 		}
 	} catch {}

package/dist/hooks/gmail-setup-utils.js

@@ -3,7 +3,7 @@ import { runCommandWithTimeout } from "../process/exec.js";
 import { hasBinary } from "../shared/config-eval.js";
 import "../agents/skills.js";
 import { normalizeServePath } from "./gmail.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/hooks/gmail-setup-utils.ts
@@ -71,7 +71,7 @@ function findExecutablesOnPath(bins) {
 				continue;
 			}
 			try {
-				fs.accessSync(candidate, fs.constants.X_OK);
+				syncFs.accessSync(candidate, syncFs.constants.X_OK);
 				matches.push(candidate);
 				seen.add(candidate);
 			} catch {}
@@ -100,7 +100,7 @@ function ensureGcloudOnPath() {
 	];
 	for (const candidate of candidates) {
 		try {
-			fs.accessSync(candidate, fs.constants.X_OK);
+			syncFs.accessSync(candidate, syncFs.constants.X_OK);
 			ensurePathIncludes(path.dirname(candidate), "append");
 			return true;
 		} catch {}
@@ -126,7 +126,7 @@ async function resolvePythonExecutablePath() {
 			continue;
 		}
 		try {
-			fs.accessSync(resolved, fs.constants.X_OK);
+			syncFs.accessSync(resolved, syncFs.constants.X_OK);
 			cachedPythonPath = resolved;
 			return resolved;
 		} catch {}
@@ -303,11 +303,11 @@ async function ensureTailscaleEndpoint(params) {
 async function resolveProjectIdFromGogCredentials() {
 	const candidates = gogCredentialsPaths();
 	for (const candidate of candidates) {
-		if (!fs.existsSync(candidate)) {
+		if (!syncFs.existsSync(candidate)) {
 			continue;
 		}
 		try {
-			const raw = fs.readFileSync(candidate, "utf-8");
+			const raw = syncFs.readFileSync(candidate, "utf-8");
 			const parsed = JSON.parse(raw);
 			const clientId = extractGogClientId(parsed);
 			const projectNumber = extractProjectNumber(clientId);

package/dist/hooks/import-url.js

@@ -1,5 +1,5 @@
 import { pathToFileURL } from "node:url";
-import fs from "node:fs";
+import syncFs from "node:fs";
 
 //#region src/hooks/import-url.ts
 /**
@@ -24,7 +24,7 @@ function buildImportUrl(handlerPath, source) {
 		return base;
 	}
 	try {
-		const { mtimeMs, size } = fs.statSync(handlerPath);
+		const { mtimeMs, size } = syncFs.statSync(handlerPath);
 		return `${base}?t=${mtimeMs}&s=${size}`;
 	} catch {
 		return `${base}?t=${Date.now()}`;

package/dist/hooks/loader.js

@@ -5,7 +5,7 @@ import { resolveHookConfig, shouldIncludeHook } from "./config.js";
 import { resolveFunctionModuleExport } from "./module-loader.js";
 import { loadWorkspaceHookEntries } from "./workspace.js";
 import { buildImportUrl } from "./import-url.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/hooks/loader.ts
@@ -67,7 +67,7 @@ async function loadInternalHooks(cfg, workspaceDir, opts) {
 					continue;
 				}
 				const safeHandlerPath = opened.path;
-				fs.closeSync(opened.fd);
+				syncFs.closeSync(opened.fd);
 				const importUrl = buildImportUrl(safeHandlerPath, entry.hook.source);
 				const mod = await import(importUrl);
 				const exportName = entry.metadata?.export ?? "default";
@@ -127,7 +127,7 @@ async function loadInternalHooks(cfg, workspaceDir, opts) {
 				continue;
 			}
 			const safeModulePath = opened.path;
-			fs.closeSync(opened.fd);
+			syncFs.closeSync(opened.fd);
 			const importUrl = buildImportUrl(safeModulePath, "fased-workspace");
 			const mod = await import(importUrl);
 			const exportName = handlerConfig.export ?? "default";
@@ -150,7 +150,7 @@ async function loadInternalHooks(cfg, workspaceDir, opts) {
 }
 function safeRealpathOrResolve(value) {
 	try {
-		return fs.realpathSync(value);
+		return syncFs.realpathSync(value);
 	} catch {
 		return path.resolve(value);
 	}

package/dist/hooks/workspace.js

@@ -6,7 +6,7 @@ import { isPathInsideWithRealpath } from "../security/scan-paths.js";
 import { parseFrontmatter, resolveFasedAgentMetadata, resolveHookInvocationPolicy } from "./frontmatter.js";
 import { shouldIncludeHook } from "./config.js";
 import { resolveBundledHooksDir } from "./bundled-dir.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/hooks/workspace.ts
@@ -106,15 +106,15 @@ function loadHookFromDir(params) {
 */
 function loadHooksFromDir(params) {
 	const { dir, source, pluginId } = params;
-	if (!fs.existsSync(dir)) {
+	if (!syncFs.existsSync(dir)) {
 		return [];
 	}
-	const stat = fs.statSync(dir);
+	const stat = syncFs.statSync(dir);
 	if (!stat.isDirectory()) {
 		return [];
 	}
 	const hooks = [];
-	const entries = fs.readdirSync(dir, { withFileTypes: true });
+	const entries = syncFs.readdirSync(dir, { withFileTypes: true });
 	for (const entry of entries) {
 		if (!entry.isDirectory()) {
 			continue;
@@ -263,11 +263,11 @@ function readBoundaryFileUtf8(params) {
 		return null;
 	}
 	try {
-		return fs.readFileSync(opened.fd, "utf-8");
+		return syncFs.readFileSync(opened.fd, "utf-8");
 	} catch {
 		return null;
 	} finally {
-		fs.closeSync(opened.fd);
+		syncFs.closeSync(opened.fd);
 	}
 }
 function resolveBoundaryFilePath(params) {
@@ -280,7 +280,7 @@ function resolveBoundaryFilePath(params) {
 		return null;
 	}
 	const safePath = opened.path;
-	fs.closeSync(opened.fd);
+	syncFs.closeSync(opened.fd);
 	return safePath;
 }
 

package/dist/infra/archive.js

@@ -2,7 +2,7 @@ import { isNotFoundPathError, isPathInside, isSymlinkOpenError } from "./path-gu
 import { resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath } from "./archive-path.js";
 import { constants } from "node:fs";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import JSZip from "jszip";
@@ -48,12 +48,12 @@ function resolveArchiveKind(filePath) {
 async function resolvePackedRootDir(extractDir) {
 	const direct = path.join(extractDir, "package");
 	try {
-		const stat = await fs$1.stat(direct);
+		const stat = await fs.stat(direct);
 		if (stat.isDirectory()) {
 			return direct;
 		}
 	} catch {}
-	const entries = await fs$1.readdir(extractDir, { withFileTypes: true });
+	const entries = await fs.readdir(extractDir, { withFileTypes: true });
 	const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
 	if (dirs.length !== 1) {
 		throw new Error(`unexpected archive layout (dirs: ${dirs.join(", ")})`);
@@ -142,14 +142,14 @@ function symlinkTraversalError(originalPath) {
 	return new ArchiveSecurityError("destination-symlink-traversal", `${ERROR_ARCHIVE_ENTRY_TRAVERSES_SYMLINK}: ${originalPath}`);
 }
 async function assertDestinationDirReady(destDir) {
-	const stat = await fs$1.lstat(destDir);
+	const stat = await fs.lstat(destDir);
 	if (stat.isSymbolicLink()) {
 		throw new ArchiveSecurityError("destination-symlink", "archive destination is a symlink");
 	}
 	if (!stat.isDirectory()) {
 		throw new ArchiveSecurityError("destination-not-directory", "archive destination is not a directory");
 	}
-	return await fs$1.realpath(destDir);
+	return await fs.realpath(destDir);
 }
 async function assertNoSymlinkTraversal(params) {
 	const parts = params.relPath.split("/").filter(Boolean);
@@ -158,7 +158,7 @@ async function assertNoSymlinkTraversal(params) {
 		current = path.join(current, part);
 		let stat;
 		try {
-			stat = await fs$1.lstat(current);
+			stat = await fs.lstat(current);
 		} catch (err) {
 			if (isNotFoundPathError(err)) {
 				continue;
@@ -173,7 +173,7 @@ async function assertNoSymlinkTraversal(params) {
 async function assertResolvedInsideDestination(params) {
 	let resolved;
 	try {
-		resolved = await fs$1.realpath(params.targetPath);
+		resolved = await fs.realpath(params.targetPath);
 	} catch (err) {
 		if (isNotFoundPathError(err)) {
 			return;
@@ -186,7 +186,7 @@ async function assertResolvedInsideDestination(params) {
 }
 async function openZipOutputFile(outPath, originalPath) {
 	try {
-		return await fs$1.open(outPath, OPEN_WRITE_FLAGS, 438);
+		return await fs.open(outPath, OPEN_WRITE_FLAGS, 438);
 	} catch (err) {
 		if (isSymlinkOpenError(err)) {
 			throw symlinkTraversalError(originalPath);
@@ -197,7 +197,7 @@ async function openZipOutputFile(outPath, originalPath) {
 async function cleanupPartialRegularFile(filePath) {
 	let stat;
 	try {
-		stat = await fs$1.lstat(filePath);
+		stat = await fs.lstat(filePath);
 	} catch (err) {
 		if (isNotFoundPathError(err)) {
 			return;
@@ -205,7 +205,7 @@ async function cleanupPartialRegularFile(filePath) {
 		throw err;
 	}
 	if (stat.isFile()) {
-		await fs$1.unlink(filePath).catch(() => undefined);
+		await fs.unlink(filePath).catch(() => undefined);
 	}
 }
 async function readZipEntryStream(entry) {
@@ -238,7 +238,7 @@ async function prepareZipOutputPath(params) {
 		originalPath: params.originalPath
 	});
 	if (params.isDirectory) {
-		await fs$1.mkdir(params.outPath, { recursive: true });
+		await fs.mkdir(params.outPath, { recursive: true });
 		await assertResolvedInsideDestination({
 			destinationRealDir: params.destinationRealDir,
 			targetPath: params.outPath,
@@ -247,7 +247,7 @@ async function prepareZipOutputPath(params) {
 		return;
 	}
 	const parentDir = path.dirname(params.outPath);
-	await fs$1.mkdir(parentDir, { recursive: true });
+	await fs.mkdir(parentDir, { recursive: true });
 	await assertResolvedInsideDestination({
 		destinationRealDir: params.destinationRealDir,
 		targetPath: parentDir,
@@ -268,18 +268,18 @@ async function writeZipFileEntry(params) {
 	if (typeof params.entry.unixPermissions === "number") {
 		const mode = params.entry.unixPermissions & 511;
 		if (mode !== 0) {
-			await fs$1.chmod(params.outPath, mode).catch(() => undefined);
+			await fs.chmod(params.outPath, mode).catch(() => undefined);
 		}
 	}
 }
 async function extractZip(params) {
 	const limits = resolveExtractLimits(params.limits);
 	const destinationRealDir = await assertDestinationDirReady(params.destDir);
-	const stat = await fs$1.stat(params.archivePath);
+	const stat = await fs.stat(params.archivePath);
 	if (stat.size > limits.maxArchiveBytes) {
 		throw new Error(ERROR_ARCHIVE_SIZE_EXCEEDS_LIMIT);
 	}
-	const buffer = await fs$1.readFile(params.archivePath);
+	const buffer = await fs.readFile(params.archivePath);
 	const zip = await JSZip.loadAsync(buffer);
 	const entries = Object.values(zip.files);
 	const strip = Math.max(0, Math.floor(params.stripComponents ?? 0));
@@ -378,14 +378,14 @@ async function extractArchive(params) {
 }
 async function fileExists(filePath) {
 	try {
-		await fs$1.stat(filePath);
+		await fs.stat(filePath);
 		return true;
 	} catch {
 		return false;
 	}
 }
 async function readJsonFile(filePath) {
-	const raw = await fs$1.readFile(filePath, "utf-8");
+	const raw = await fs.readFile(filePath, "utf-8");
 	return JSON.parse(raw);
 }
 

package/dist/infra/boundary-file-read.js

@@ -1,6 +1,6 @@
 import { resolveBoundaryPath, resolveBoundaryPathSync } from "./boundary-path.js";
 import { openVerifiedFileSync } from "./safe-open-sync.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/infra/boundary-file-read.ts
@@ -8,7 +8,7 @@ function canUseBoundaryFileOpen(ioFs) {
 	return typeof ioFs.openSync === "function" && typeof ioFs.closeSync === "function" && typeof ioFs.fstatSync === "function" && typeof ioFs.lstatSync === "function" && typeof ioFs.realpathSync === "function" && typeof ioFs.readFileSync === "function" && typeof ioFs.constants === "object" && ioFs.constants !== null;
 }
 function openBoundaryFileSync(params) {
-	const ioFs = params.ioFs ?? fs;
+	const ioFs = params.ioFs ?? syncFs;
 	const absolutePath = path.resolve(params.absolutePath);
 	let resolvedPath;
 	let rootRealPath;

package/dist/infra/boundary-path.js

@@ -1,8 +1,8 @@
 import { isNotFoundPathError, isPathInside } from "./path-guards.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 
 //#region src/infra/boundary-path.ts
 const BOUNDARY_PATH_ALIAS_POLICIES = {
@@ -114,7 +114,7 @@ async function resolveBoundaryPathLexicalAsync(params) {
 		lexicalCursor = path.join(lexicalCursor, segment);
 		let stat;
 		try {
-			stat = await fs$1.lstat(lexicalCursor);
+			stat = await fs.lstat(lexicalCursor);
 		} catch (error) {
 			if (isNotFoundPathError(error)) {
 				const missingSuffix = segments.slice(idx);
@@ -189,7 +189,7 @@ function resolveBoundaryPathLexicalSync(params) {
 		lexicalCursor = path.join(lexicalCursor, segment);
 		let stat;
 		try {
-			stat = fs.lstatSync(lexicalCursor);
+			stat = syncFs.lstatSync(lexicalCursor);
 		} catch (error) {
 			if (isNotFoundPathError(error)) {
 				const missingSuffix = segments.slice(idx);
@@ -294,7 +294,7 @@ async function resolvePathViaExistingAncestor(targetPath) {
 		return normalized;
 	}
 	try {
-		const resolvedAncestor = path.resolve(await fs$1.realpath(cursor));
+		const resolvedAncestor = path.resolve(await fs.realpath(cursor));
 		if (missingSuffix.length === 0) {
 			return resolvedAncestor;
 		}
@@ -307,7 +307,7 @@ function resolvePathViaExistingAncestorSync(targetPath) {
 	const normalized = path.resolve(targetPath);
 	let cursor = normalized;
 	const missingSuffix = [];
-	while (!isFilesystemRoot(cursor) && !fs.existsSync(cursor)) {
+	while (!isFilesystemRoot(cursor) && !syncFs.existsSync(cursor)) {
 		missingSuffix.unshift(path.basename(cursor));
 		const parent = path.dirname(cursor);
 		if (parent === cursor) {
@@ -315,11 +315,11 @@ function resolvePathViaExistingAncestorSync(targetPath) {
 		}
 		cursor = parent;
 	}
-	if (!fs.existsSync(cursor)) {
+	if (!syncFs.existsSync(cursor)) {
 		return normalized;
 	}
 	try {
-		const resolvedAncestor = path.resolve(fs.realpathSync(cursor));
+		const resolvedAncestor = path.resolve(syncFs.realpathSync(cursor));
 		if (missingSuffix.length === 0) {
 			return resolvedAncestor;
 		}
@@ -330,7 +330,7 @@ function resolvePathViaExistingAncestorSync(targetPath) {
 }
 async function getPathKind(absolutePath, preserveFinalSymlink) {
 	try {
-		const stat = preserveFinalSymlink ? await fs$1.lstat(absolutePath) : await fs$1.stat(absolutePath);
+		const stat = preserveFinalSymlink ? await fs.lstat(absolutePath) : await fs.stat(absolutePath);
 		return {
 			exists: true,
 			kind: toResolvedKind(stat)
@@ -347,7 +347,7 @@ async function getPathKind(absolutePath, preserveFinalSymlink) {
 }
 function getPathKindSync(absolutePath, preserveFinalSymlink) {
 	try {
-		const stat = preserveFinalSymlink ? fs.lstatSync(absolutePath) : fs.statSync(absolutePath);
+		const stat = preserveFinalSymlink ? syncFs.lstatSync(absolutePath) : syncFs.statSync(absolutePath);
 		return {
 			exists: true,
 			kind: toResolvedKind(stat)
@@ -408,7 +408,7 @@ function isFilesystemRoot(candidate) {
 }
 async function pathExists(targetPath) {
 	try {
-		await fs$1.lstat(targetPath);
+		await fs.lstat(targetPath);
 		return true;
 	} catch (error) {
 		if (isNotFoundPathError(error)) {
@@ -419,24 +419,24 @@ async function pathExists(targetPath) {
 }
 async function resolveSymlinkHopPath(symlinkPath) {
 	try {
-		return path.resolve(await fs$1.realpath(symlinkPath));
+		return path.resolve(await fs.realpath(symlinkPath));
 	} catch (error) {
 		if (!isNotFoundPathError(error)) {
 			throw error;
 		}
-		const linkTarget = await fs$1.readlink(symlinkPath);
+		const linkTarget = await fs.readlink(symlinkPath);
 		const linkAbsolute = path.resolve(path.dirname(symlinkPath), linkTarget);
 		return resolvePathViaExistingAncestor(linkAbsolute);
 	}
 }
 function resolveSymlinkHopPathSync(symlinkPath) {
 	try {
-		return path.resolve(fs.realpathSync(symlinkPath));
+		return path.resolve(syncFs.realpathSync(symlinkPath));
 	} catch (error) {
 		if (!isNotFoundPathError(error)) {
 			throw error;
 		}
-		const linkTarget = fs.readlinkSync(symlinkPath);
+		const linkTarget = syncFs.readlinkSync(symlinkPath);
 		const linkAbsolute = path.resolve(path.dirname(symlinkPath), linkTarget);
 		return resolvePathViaExistingAncestorSync(linkAbsolute);
 	}

package/dist/infra/brew.js

@@ -1,11 +1,11 @@
-import fs from "node:fs";
+import syncFs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
 //#region src/infra/brew.ts
 function isExecutable(filePath) {
 	try {
-		fs.accessSync(filePath, fs.constants.X_OK);
+		syncFs.accessSync(filePath, syncFs.constants.X_OK);
 		return true;
 	} catch {
 		return false;

package/dist/infra/control-ui-assets.js

@@ -2,7 +2,7 @@ import { defaultRuntime } from "../runtime.js";
 import { runCommandWithTimeout } from "../process/exec.js";
 import { resolveFasedAgentPackageRoot, resolveFasedAgentPackageRootSync } from "./fased-root.js";
 import { fileURLToPath } from "node:url";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/infra/control-ui-assets.ts
@@ -21,7 +21,7 @@ async function resolveControlUiDistIndexHealth(opts = {}) {
 	});
 	return {
 		indexPath,
-		exists: Boolean(indexPath && fs.existsSync(indexPath))
+		exists: Boolean(indexPath && syncFs.existsSync(indexPath))
 	};
 }
 function resolveControlUiRepoRoot(argv1 = process.argv[1]) {
@@ -33,13 +33,13 @@ function resolveControlUiRepoRoot(argv1 = process.argv[1]) {
 	const srcIndex = parts.lastIndexOf("src");
 	if (srcIndex !== -1) {
 		const root = parts.slice(0, srcIndex).join(path.sep);
-		if (fs.existsSync(path.join(root, "ui", "vite.config.ts"))) {
+		if (syncFs.existsSync(path.join(root, "ui", "vite.config.ts"))) {
 			return root;
 		}
 	}
 	let dir = path.dirname(normalized);
 	for (let i = 0; i < 8; i++) {
-		if (fs.existsSync(path.join(dir, "package.json")) && fs.existsSync(path.join(dir, "ui", "vite.config.ts"))) {
+		if (syncFs.existsSync(path.join(dir, "package.json")) && syncFs.existsSync(path.join(dir, "ui", "vite.config.ts"))) {
 			return dir;
 		}
 		const parent = path.dirname(dir);
@@ -72,12 +72,12 @@ async function resolveControlUiDistIndexPath(argv1OrOpts) {
 	for (let i = 0; i < 8; i++) {
 		const pkgJsonPath = path.join(dir, "package.json");
 		const indexPath = path.join(dir, "dist", "control-ui", "index.html");
-		if (fs.existsSync(pkgJsonPath)) {
+		if (syncFs.existsSync(pkgJsonPath)) {
 			try {
-				const raw = fs.readFileSync(pkgJsonPath, "utf-8");
+				const raw = syncFs.readFileSync(pkgJsonPath, "utf-8");
 				const parsed = JSON.parse(raw);
 				if (parsed.name === "fased") {
-					return fs.existsSync(indexPath) ? indexPath : null;
+					return syncFs.existsSync(indexPath) ? indexPath : null;
 				}
 				return null;
 			} catch {
@@ -101,13 +101,13 @@ function addCandidate(candidates, value) {
 function resolveControlUiRootOverrideSync(rootOverride) {
 	const resolved = path.resolve(rootOverride);
 	try {
-		const stats = fs.statSync(resolved);
+		const stats = syncFs.statSync(resolved);
 		if (stats.isFile()) {
 			return path.basename(resolved) === "index.html" ? path.dirname(resolved) : null;
 		}
 		if (stats.isDirectory()) {
 			const indexPath = path.join(resolved, "index.html");
-			return fs.existsSync(indexPath) ? resolved : null;
+			return syncFs.existsSync(indexPath) ? resolved : null;
 		}
 	} catch {
 		return null;
@@ -123,7 +123,7 @@ function resolveControlUiRootSync(opts = {}) {
 	const execDir = (() => {
 		try {
 			const execPath = opts.execPath ?? process.execPath;
-			return path.dirname(fs.realpathSync(execPath));
+			return path.dirname(syncFs.realpathSync(execPath));
 		} catch {
 			return null;
 		}
@@ -149,7 +149,7 @@ function resolveControlUiRootSync(opts = {}) {
 	addCandidate(candidates, path.join(cwd, "dist", "control-ui"));
 	for (const dir of candidates) {
 		const indexPath = path.join(dir, "index.html");
-		if (fs.existsSync(indexPath)) {
+		if (syncFs.existsSync(indexPath)) {
 			return dir;
 		}
 	}
@@ -185,14 +185,14 @@ async function ensureControlUiAssetsBuilt(runtime = defaultRuntime, opts) {
 		};
 	}
 	const indexPath = resolveControlUiDistIndexPathForRoot(repoRoot);
-	if (fs.existsSync(indexPath)) {
+	if (syncFs.existsSync(indexPath)) {
 		return {
 			ok: true,
 			built: false
 		};
 	}
 	const uiScript = path.join(repoRoot, "scripts", "ui.js");
-	if (!fs.existsSync(uiScript)) {
+	if (!syncFs.existsSync(uiScript)) {
 		return {
 			ok: false,
 			built: false,
@@ -215,7 +215,7 @@ async function ensureControlUiAssetsBuilt(runtime = defaultRuntime, opts) {
 			message: `Control UI build failed: ${summarizeCommandOutput(build.stderr) ?? `exit ${build.code}`}`
 		};
 	}
-	if (!fs.existsSync(indexPath)) {
+	if (!syncFs.existsSync(indexPath)) {
 		return {
 			ok: false,
 			built: true,

package/dist/infra/device-auth-store.js

@@ -1,6 +1,6 @@
 import { resolveStateDir } from "../config/paths.js";
 import { normalizeDeviceAuthRole, normalizeDeviceAuthScopes } from "../shared/device-auth.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/infra/device-auth-store.ts
@@ -10,10 +10,10 @@ function resolveDeviceAuthPath(env = process.env) {
 }
 function readStore(filePath) {
 	try {
-		if (!fs.existsSync(filePath)) {
+		if (!syncFs.existsSync(filePath)) {
 			return null;
 		}
-		const raw = fs.readFileSync(filePath, "utf8");
+		const raw = syncFs.readFileSync(filePath, "utf8");
 		const parsed = JSON.parse(raw);
 		if (parsed?.version !== 1 || typeof parsed.deviceId !== "string") {
 			return null;
@@ -27,10 +27,10 @@ function readStore(filePath) {
 	}
 }
 function writeStore(filePath, store) {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	fs.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}\n`, { mode: 384 });
+	syncFs.mkdirSync(path.dirname(filePath), { recursive: true });
+	syncFs.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}\n`, { mode: 384 });
 	try {
-		fs.chmodSync(filePath, 384);
+		syncFs.chmodSync(filePath, 384);
 	} catch {}
 }
 function loadDeviceAuthToken(params) {
@@ -88,11 +88,11 @@ function clearDeviceAuthToken(params) {
 }
 function clearDeviceAuthStore(env = process.env) {
 	const filePath = resolveDeviceAuthPath(env);
-	if (!fs.existsSync(filePath)) {
+	if (!syncFs.existsSync(filePath)) {
 		return false;
 	}
 	try {
-		fs.unlinkSync(filePath);
+		syncFs.unlinkSync(filePath);
 		return true;
 	} catch {
 		return false;