@fased/fased 0.1.54 → 0.1.56

package/dist/commands/onboard-auth.config-litellm.js

@@ -1,31 +1,31 @@
-import { LITELLM_BASE_URL, LITELLM_DEFAULT_MODEL_ID, LITELLM_DEFAULT_MODEL_REF, LITELLM_MODEL_CATALOG, buildLitellmModelDefinition as buildLitellmModelDefinition$1 } from "../providers/litellm-models.js";
-import { applyAgentDefaultModelPrimary, applyProviderConfigWithDefaultModel } from "./onboard-auth.config-shared.js";
+import { LITELLM_BASE_URL, LITELLM_DEFAULT_MODEL_ID } from "../providers/litellm-models.js";
 
 //#region src/commands/onboard-auth.config-litellm.ts
-function buildLitellmModelDefinition() {
-	return buildLitellmModelDefinition$1(LITELLM_MODEL_CATALOG[0]);
-}
 function applyLitellmProviderConfig(cfg) {
-	const models = { ...cfg.agents?.defaults?.models };
-	models[LITELLM_DEFAULT_MODEL_REF] = {
-		...models[LITELLM_DEFAULT_MODEL_REF],
-		alias: models[LITELLM_DEFAULT_MODEL_REF]?.alias ?? "LiteLLM proxy default"
-	};
-	const defaultModel = buildLitellmModelDefinition();
-	const existingProvider = cfg.models?.providers?.litellm;
+	const providers = { ...cfg.models?.providers };
+	const existingProvider = providers.litellm;
 	const resolvedBaseUrl = typeof existingProvider?.baseUrl === "string" ? existingProvider.baseUrl.trim() : "";
-	return applyProviderConfigWithDefaultModel(cfg, {
-		agentModels: models,
-		providerId: "litellm",
-		api: "openai-completions",
+	providers.litellm = {
+		...existingProvider,
+		...typeof existingProvider?.apiKey === "string" && existingProvider.apiKey.trim() ? { apiKey: existingProvider.apiKey.trim() } : {},
 		baseUrl: resolvedBaseUrl || LITELLM_BASE_URL,
-		defaultModel,
-		defaultModelId: LITELLM_DEFAULT_MODEL_ID
-	});
+		api: "openai-completions",
+		request: {
+			...existingProvider?.request,
+			allowPrivateNetwork: true
+		},
+		models: existingProvider?.models ?? []
+	};
+	return {
+		...cfg,
+		models: {
+			mode: cfg.models?.mode ?? "merge",
+			providers
+		}
+	};
 }
 function applyLitellmConfig(cfg) {
-	const next = applyLitellmProviderConfig(cfg);
-	return applyAgentDefaultModelPrimary(next, LITELLM_DEFAULT_MODEL_REF);
+	return applyLitellmProviderConfig(cfg);
 }
 
 //#endregion

package/dist/commands/onboard-auth.credentials.js

@@ -1,7 +1,6 @@
 import { resolveStateDir } from "../config/paths.js";
 import { CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF } from "../providers/cloudflare-ai-gateway-shared.js";
 import { HUGGINGFACE_DEFAULT_MODEL_REF } from "../providers/huggingface-models.js";
-import { LITELLM_DEFAULT_MODEL_REF } from "../providers/litellm-models.js";
 import { TOGETHER_DEFAULT_MODEL_REF } from "../providers/together-models.js";
 import { VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF } from "../providers/vercel-ai-gateway-models.js";
 import "../providers/registry.js";
@@ -12,7 +11,7 @@ import { upsertAuthProfile } from "../agents/auth-profiles/profiles.js";
 import "../agents/auth-profiles.js";
 import { PROVIDER_ENV_VARS } from "../secrets/provider-env-vars.js";
 import { MISTRAL_DEFAULT_MODEL_REF, XAI_DEFAULT_MODEL_REF } from "./onboard-auth.models.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/commands/onboard-auth.credentials.ts
@@ -75,7 +74,7 @@ function buildApiKeyCredential(provider, input, metadata, options) {
 /** Resolve real path, returning null if the target doesn't exist. */
 function safeRealpathSync(dir) {
 	try {
-		return fs.realpathSync(path.resolve(dir));
+		return syncFs.realpathSync(path.resolve(dir));
 	} catch {
 		return null;
 	}
@@ -88,7 +87,7 @@ function resolveSiblingAgentDirs(primaryAgentDir) {
 	const agentsRoot = looksLikeStandardLayout ? candidateAgentsRoot : path.join(resolveStateDir(), "agents");
 	const entries = (() => {
 		try {
-			return fs.readdirSync(agentsRoot, { withFileTypes: true });
+			return syncFs.readdirSync(agentsRoot, { withFileTypes: true });
 		} catch {
 			return [];
 		}

package/dist/commands/onboard-auth.js

@@ -1,6 +1,5 @@
 import { CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF } from "../providers/cloudflare-ai-gateway-shared.js";
 import { HUGGINGFACE_DEFAULT_MODEL_REF } from "../providers/huggingface-models.js";
-import { LITELLM_DEFAULT_MODEL_REF } from "../providers/litellm-models.js";
 import { SYNTHETIC_DEFAULT_MODEL_ID, SYNTHETIC_DEFAULT_MODEL_REF } from "../providers/synthetic-models.js";
 import { TOGETHER_DEFAULT_MODEL_REF } from "../providers/together-models.js";
 import { VENICE_DEFAULT_MODEL_ID, VENICE_DEFAULT_MODEL_REF } from "../providers/venice-models.js";

package/dist/commands/onboarding/plugin-install.js

@@ -7,7 +7,7 @@ import { createPluginLoaderLogger } from "../../plugins/logger.js";
 import { resolveChannelPluginExpectedPluginIds } from "../../channels/plugins/catalog.js";
 import { buildNpmResolutionInstallFields } from "../../plugins/installs.js";
 import { finalizeInstalledPluginConfig } from "../../plugins/lifecycle.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/commands/onboarding/plugin-install.ts
@@ -29,7 +29,7 @@ function resolveLocalPath(entry, workspaceDir) {
 		candidates.add(path.resolve(packageRoot, raw));
 	}
 	for (const candidate of candidates) {
-		if (fs.existsSync(candidate)) {
+		if (syncFs.existsSync(candidate)) {
 			return candidate;
 		}
 	}

package/dist/commands/openai-codex-model-default.js

@@ -1,5 +1,28 @@
+import { DEFAULT_PROVIDER } from "../agents/defaults.js";
+import { ensureAuthProfileStore } from "../agents/auth-profiles/store.js";
+import "../agents/auth-profiles.js";
+import { resolveAuthenticatedModelCatalog } from "../agents/authenticated-model-catalog.js";
+import { loadModelCatalog } from "../agents/model-catalog.js";
+
 //#region src/commands/openai-codex-model-default.ts
-const OPENAI_CODEX_DEFAULT_MODEL = "openai-codex/gpt-5.6-sol";
+const OPENAI_CODEX_DEFAULT_MODEL = "openai-codex/gpt-5.5";
+async function discoverOpenAICodexDefaultModel(params) {
+	const catalog = await loadModelCatalog({
+		config: params.config,
+		useCache: false,
+		includeMetadata: true
+	});
+	const store = ensureAuthProfileStore(params.agentDir, { allowKeychainPrompt: false });
+	const authenticated = await resolveAuthenticatedModelCatalog({
+		cfg: params.config,
+		store,
+		catalog,
+		defaultProvider: DEFAULT_PROVIDER,
+		agentDir: params.agentDir
+	});
+	const model = authenticated.usableCatalog.filter((entry) => entry.provider === "openai-codex").toSorted((left, right) => (left.metadata?.recommendationRank ?? Number.MAX_SAFE_INTEGER) - (right.metadata?.recommendationRank ?? Number.MAX_SAFE_INTEGER) || left.name.localeCompare(right.name))[0];
+	return model ? `${model.provider}/${model.id}` : undefined;
+}
 function shouldSetOpenAICodexModel(model) {
 	const trimmed = model?.trim();
 	if (!trimmed) {
@@ -23,7 +46,7 @@ function resolvePrimaryModel(model) {
 	}
 	return undefined;
 }
-function applyOpenAICodexModelDefault(cfg) {
+function applyOpenAICodexModelDefault(cfg, model = OPENAI_CODEX_DEFAULT_MODEL) {
 	const current = resolvePrimaryModel(cfg.agents?.defaults?.model);
 	if (!shouldSetOpenAICodexModel(current)) {
 		return {
@@ -40,8 +63,8 @@ function applyOpenAICodexModelDefault(cfg) {
 					...cfg.agents?.defaults,
 					model: cfg.agents?.defaults?.model && typeof cfg.agents.defaults.model === "object" ? {
 						...cfg.agents.defaults.model,
-						primary: OPENAI_CODEX_DEFAULT_MODEL
-					} : { primary: OPENAI_CODEX_DEFAULT_MODEL }
+						primary: model
+					} : { primary: model }
 				}
 			}
 		},
@@ -50,4 +73,4 @@ function applyOpenAICodexModelDefault(cfg) {
 }
 
 //#endregion
-export { OPENAI_CODEX_DEFAULT_MODEL, applyOpenAICodexModelDefault };
+export { OPENAI_CODEX_DEFAULT_MODEL, applyOpenAICodexModelDefault, discoverOpenAICodexDefaultModel };

package/dist/commands/sessions-cleanup.js

@@ -7,7 +7,7 @@ import { capEntryCount, loadSessionStore, pruneStaleEntries, resolveMaintenanceC
 import "../config/sessions.js";
 import { resolveSessionStoreTargets } from "./session-store-targets.js";
 import { SESSION_AGE_PAD, SESSION_KEY_PAD, SESSION_MODEL_PAD, formatSessionAgeCell, formatSessionFlagsCell, formatSessionKeyCell, formatSessionModelCell, resolveSessionDisplayDefaults, resolveSessionDisplayModel, toSessionDisplayRows } from "./sessions-table.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 
 //#region src/commands/sessions-cleanup.ts
 const ACTION_PAD = 12;
@@ -65,7 +65,7 @@ function pruneMissingTranscriptEntries(params) {
 			continue;
 		}
 		const transcriptPath = resolveSessionFilePath(entry.sessionId, entry, sessionPathOpts);
-		if (!fs.existsSync(transcriptPath)) {
+		if (!syncFs.existsSync(transcriptPath)) {
 			delete params.store[key];
 			removed += 1;
 			params.onPruned?.(key);

package/dist/commands/signal-install.js

@@ -5,7 +5,7 @@ import { resolveBrewExecutable } from "../infra/brew.js";
 import { createWriteStream } 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";
 import { pipeline } from "node:stream/promises";
 import { request } from "node:https";
 
@@ -79,7 +79,7 @@ async function findSignalCliBinary(root) {
 		if (depth > 3) {
 			return;
 		}
-		const entries = await fs$1.readdir(dir, { withFileTypes: true }).catch(() => []);
+		const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
 		for (const entry of entries) {
 			const full = path.join(dir, entry.name);
 			if (entry.isDirectory()) {
@@ -103,7 +103,7 @@ async function resolveBrewSignalCliPath(brewExe) {
 			const prefix = result.stdout.trim();
 			const candidate = path.join(prefix, "bin", "signal-cli");
 			try {
-				await fs$1.access(candidate);
+				await fs.access(candidate);
 				return candidate;
 			} catch {
 				return findSignalCliBinary(prefix);
@@ -172,12 +172,12 @@ async function installSignalCliFromRelease(runtime) {
 			error: "No compatible release asset found for this platform."
 		};
 	}
-	const tmpDir = await fs$1.mkdtemp(path.join(os.tmpdir(), "fased-signal-"));
+	const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "fased-signal-"));
 	const archivePath = path.join(tmpDir, asset.name);
 	runtime.log(`Downloading signal-cli ${version} (${asset.name})…`);
 	await downloadToFile(asset.browser_download_url, archivePath);
 	const installRoot = path.join(CONFIG_DIR, "tools", "signal-cli", version);
-	await fs$1.mkdir(installRoot, { recursive: true });
+	await fs.mkdir(installRoot, { recursive: true });
 	if (!looksLikeArchive(asset.name.toLowerCase())) {
 		return {
 			ok: false,
@@ -200,7 +200,7 @@ async function installSignalCliFromRelease(runtime) {
 			error: `signal-cli binary not found after extracting ${asset.name}`
 		};
 	}
-	await fs$1.chmod(cliPath, 493).catch(() => {});
+	await fs.chmod(cliPath, 493).catch(() => {});
 	return {
 		ok: true,
 		cliPath,

package/dist/commands/status-all/channels.js

@@ -4,7 +4,7 @@ import { formatTimeAgo } from "../../infra/format-time/format-relative.js";
 import { resolveChannelDefaultAccountId } from "../../channels/plugins/helpers.js";
 import { buildChannelAccountSnapshot, formatChannelAllowFrom } from "../../channels/account-summary.js";
 import "./format.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 
 //#region src/commands/status-all/channels.ts
 const asRecord = (value) => value && typeof value === "object" ? value : {};
@@ -27,7 +27,7 @@ function existsSyncMaybe(p) {
 		return null;
 	}
 	try {
-		return fs.existsSync(path);
+		return syncFs.existsSync(path);
 	} catch {
 		return null;
 	}

package/dist/commands/wallet.js

@@ -15,7 +15,7 @@ import { startLocalSocketSignerBroker } from "../wallet/local-socket-signer-brok
 import { listWalletInboundEvents, pollWalletInboundEvents, reconcileWalletInboundEvents } from "../wallet/wallet-inbound-events.js";
 import { buildWalletCanaryReport, runWalletProviderCanaryReport } from "../wallet/wallet-canary.js";
 import { resolveSignerdBinaryPath, restartLocalSocketSigner } from "../wizard/onboarding.wallet.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 import { createCipheriv, createDecipheriv, createPrivateKey, createPublicKey, randomBytes, scryptSync } from "node:crypto";
 import { createInterface } from "node:readline/promises";
@@ -676,12 +676,12 @@ function resolveKeystorePassphrase(optionsPassphrase, env) {
 		return optionsPassphrase.trim();
 	}
 	const file = String(env.FASED_WALLET_PASSPHRASE_FILE ?? "").trim();
-	if (file && fs.existsSync(file)) {
-		return fs.readFileSync(file, "utf8").trim();
+	if (file && syncFs.existsSync(file)) {
+		return syncFs.readFileSync(file, "utf8").trim();
 	}
 	const managedFile = path.join(resolveLocalSignerMaterialRootDir(env), "passphrase");
-	if (fs.existsSync(managedFile)) {
-		return fs.readFileSync(managedFile, "utf8").trim();
+	if (syncFs.existsSync(managedFile)) {
+		return syncFs.readFileSync(managedFile, "utf8").trim();
 	}
 	return String(env.FASED_WALLET_PASSPHRASE ?? "").trim();
 }
@@ -697,7 +697,7 @@ function resolveLocalSignerPassphraseSource(env) {
 	const candidates = [configuredFile ? path.resolve(configuredFile) : "", path.join(resolveLocalSignerMaterialRootDir(env), "passphrase")].filter(Boolean);
 	for (const candidate of candidates) {
 		try {
-			const value = fs.readFileSync(candidate, "utf8").trim();
+			const value = syncFs.readFileSync(candidate, "utf8").trim();
 			if (value) {
 				return {
 					kind: "file",
@@ -775,16 +775,16 @@ function ensureLocalSignerPassphraseFileForCustodyDisable(params) {
 	};
 }
 function writePassphraseFile(filePath, passphrase) {
-	fs.mkdirSync(path.dirname(filePath), {
+	syncFs.mkdirSync(path.dirname(filePath), {
 		recursive: true,
 		mode: 448
 	});
-	fs.writeFileSync(filePath, `${passphrase}\n`, {
+	syncFs.writeFileSync(filePath, `${passphrase}\n`, {
 		encoding: "utf8",
 		mode: 384
 	});
 	try {
-		fs.chmodSync(filePath, 384);
+		syncFs.chmodSync(filePath, 384);
 	} catch {}
 }
 function walletIdsMatchForEnvSuffix(left, right) {
@@ -824,7 +824,7 @@ function collectLocalSignerKeystoreTargets(cfg, env) {
 			return;
 		}
 		const resolved = path.resolve(candidate);
-		if (!fs.existsSync(resolved)) {
+		if (!syncFs.existsSync(resolved)) {
 			return;
 		}
 		const existing = targets.get(resolved);
@@ -851,8 +851,8 @@ function collectLocalSignerKeystoreTargets(cfg, env) {
 			addTarget("solana", value, key.slice("FASED_WALLET_SOLANA_KEYSTORE_PATH__".length).toLowerCase());
 		}
 	}
-	if (fs.existsSync(materialRoot)) {
-		for (const entry of fs.readdirSync(materialRoot, { withFileTypes: true })) {
+	if (syncFs.existsSync(materialRoot)) {
+		for (const entry of syncFs.readdirSync(materialRoot, { withFileTypes: true })) {
 			if (!entry.isFile()) {
 				continue;
 			}
@@ -872,7 +872,7 @@ function collectLocalSignerKeystoreTargets(cfg, env) {
 	return [...targets.values()].toSorted((left, right) => left.label.localeCompare(right.label));
 }
 async function reencryptLocalSignerKeystore(params) {
-	const raw = fs.readFileSync(params.target.path, "utf8");
+	const raw = syncFs.readFileSync(params.target.path, "utf8");
 	const detected = detectEmbeddedKeystoreType(raw);
 	if (detected === "solana-envelope") {
 		const envelope = parseSolanaKeystoreEnvelope(raw);
@@ -885,7 +885,7 @@ async function reencryptLocalSignerKeystore(params) {
 			passphrase: params.newPassphrase,
 			publicKey: envelope.publicKey
 		});
-		fs.writeFileSync(params.target.path, `${JSON.stringify(nextEnvelope, null, 2)}\n`, {
+		syncFs.writeFileSync(params.target.path, `${JSON.stringify(nextEnvelope, null, 2)}\n`, {
 			encoding: "utf8",
 			mode: 384
 		});
@@ -906,13 +906,13 @@ function removeLocalSignerPassphraseFileIfManaged(env) {
 	const resolved = path.resolve(configured);
 	const materialRoot = resolveLocalSignerMaterialRootDir(env);
 	const withinMaterialRoot = resolved === materialRoot || resolved.startsWith(`${materialRoot}${path.sep}`);
-	if (!withinMaterialRoot || !fs.existsSync(resolved)) {
+	if (!withinMaterialRoot || !syncFs.existsSync(resolved)) {
 		return {
 			removed: false,
 			path: resolved
 		};
 	}
-	fs.rmSync(resolved, { force: true });
+	syncFs.rmSync(resolved, { force: true });
 	return {
 		removed: true,
 		path: resolved
@@ -950,11 +950,11 @@ function writeLocalSignerEnvFile(cfg, env) {
 		"",
 		`"${signerBinPath}" --socket "\${FASED_WALLET_LOCAL_SIGNER_BACKEND_SOCKET:-$FASED_WALLET_LOCAL_SIGNER_SOCKET}"`
 	];
-	fs.mkdirSync(path.dirname(signerEnvPath), {
+	syncFs.mkdirSync(path.dirname(signerEnvPath), {
 		recursive: true,
 		mode: 448
 	});
-	fs.writeFileSync(signerEnvPath, `${signerEnvLines.join("\n")}\n`, {
+	syncFs.writeFileSync(signerEnvPath, `${signerEnvLines.join("\n")}\n`, {
 		encoding: "utf8",
 		mode: 384
 	});
@@ -1052,11 +1052,11 @@ async function configureLocalSignerMode(runtime, options, env) {
 		"",
 		`"${signerBinPath}" --socket "\${FASED_WALLET_LOCAL_SIGNER_BACKEND_SOCKET:-$FASED_WALLET_LOCAL_SIGNER_SOCKET}"`
 	];
-	fs.mkdirSync(path.dirname(signerEnvPath), {
+	syncFs.mkdirSync(path.dirname(signerEnvPath), {
 		recursive: true,
 		mode: 448
 	});
-	fs.writeFileSync(signerEnvPath, `${signerEnvLines.join("\n")}\n`, {
+	syncFs.writeFileSync(signerEnvPath, `${signerEnvLines.join("\n")}\n`, {
 		encoding: "utf8",
 		mode: 384
 	});
@@ -1500,10 +1500,10 @@ async function walletKeystoreInitCommand(runtime = defaultRuntime, options = {})
 	}
 	const chain = options.chain ?? "solana";
 	const outPath = resolveEmbeddedKeystorePathForChain(env, chain, options.out, options.walletId);
-	if (fs.existsSync(outPath) && !options.force) {
+	if (syncFs.existsSync(outPath) && !options.force) {
 		throw new Error(`Keystore already exists: ${outPath}`);
 	}
-	fs.mkdirSync(path.dirname(outPath), {
+	syncFs.mkdirSync(path.dirname(outPath), {
 		recursive: true,
 		mode: 448
 	});
@@ -1518,14 +1518,14 @@ async function walletKeystoreInitCommand(runtime = defaultRuntime, options = {})
 		passphrase,
 		publicKey
 	});
-	fs.writeFileSync(outPath, `${JSON.stringify(envelope, null, 2)}\n`, {
+	syncFs.writeFileSync(outPath, `${JSON.stringify(envelope, null, 2)}\n`, {
 		encoding: "utf8",
 		mode: 384
 	});
 	addressOut = publicKey;
 	privateKeyOut = Buffer.from(secretKey).toString("base64");
 	try {
-		fs.chmodSync(outPath, 384);
+		syncFs.chmodSync(outPath, 384);
 	} catch {}
 	const cfg = options.skipProviderConfig ? ensureWalletMaterialConfig(loadConfig(), {
 		keystorePath: outPath,
@@ -1600,10 +1600,10 @@ async function walletKeystoreImportCommand(runtime = defaultRuntime, options = {
 		throw new Error("Missing private key. Pass --private-key or set FASED_WALLET_PRIVATE_KEY.");
 	}
 	const outPath = resolveEmbeddedKeystorePathForChain(env, chain, options.out, options.walletId);
-	if (fs.existsSync(outPath) && !options.force) {
+	if (syncFs.existsSync(outPath) && !options.force) {
 		throw new Error(`Keystore already exists: ${outPath}`);
 	}
-	fs.mkdirSync(path.dirname(outPath), {
+	syncFs.mkdirSync(path.dirname(outPath), {
 		recursive: true,
 		mode: 448
 	});
@@ -1615,13 +1615,13 @@ async function walletKeystoreImportCommand(runtime = defaultRuntime, options = {
 		passphrase,
 		publicKey
 	});
-	fs.writeFileSync(outPath, `${JSON.stringify(envelope, null, 2)}\n`, {
+	syncFs.writeFileSync(outPath, `${JSON.stringify(envelope, null, 2)}\n`, {
 		encoding: "utf8",
 		mode: 384
 	});
 	addressOut = publicKey;
 	try {
-		fs.chmodSync(outPath, 384);
+		syncFs.chmodSync(outPath, 384);
 	} catch {}
 	const cfg = options.skipProviderConfig ? ensureWalletMaterialConfig(loadConfig(), {
 		keystorePath: outPath,
@@ -1683,7 +1683,7 @@ async function walletKeystoreStatusCommand(runtime = defaultRuntime, options = {
 	const cfg = loadConfig();
 	const chain = options.chain ?? "solana";
 	const keystorePath = resolveEmbeddedKeystorePathForChain(env, chain, cfg.wallet?.keystore?.path, options.walletId);
-	const exists = fs.existsSync(keystorePath);
+	const exists = syncFs.existsSync(keystorePath);
 	const providerId = cfg.wallet?.provider?.id;
 	let address;
 	let unlocked = false;
@@ -1691,7 +1691,7 @@ async function walletKeystoreStatusCommand(runtime = defaultRuntime, options = {
 	let detectedType = "missing";
 	if (exists) {
 		const passphrase = resolveKeystorePassphrase(undefined, env);
-		const raw = fs.readFileSync(keystorePath, "utf8");
+		const raw = syncFs.readFileSync(keystorePath, "utf8");
 		detectedType = detectEmbeddedKeystoreType(raw);
 		if (passphrase) {
 			try {
@@ -1756,14 +1756,14 @@ async function walletKeystoreValidateCommand(runtime = defaultRuntime, options =
 	};
 	let raw = "";
 	let detectedType = "missing";
-	if (!fs.existsSync(keystorePath)) {
+	if (!syncFs.existsSync(keystorePath)) {
 		result.checks.push({
 			id: "keystore.exists",
 			ok: false,
 			message: `missing: ${keystorePath}`
 		});
 	} else {
-		raw = fs.readFileSync(keystorePath, "utf8");
+		raw = syncFs.readFileSync(keystorePath, "utf8");
 		detectedType = detectEmbeddedKeystoreType(raw);
 		result.checks.push({
 			id: "keystore.exists",
@@ -1865,7 +1865,7 @@ async function walletKeystoreValidateCommand(runtime = defaultRuntime, options =
 async function walletKeystorePassphraseInitCommand(runtime = defaultRuntime, options = {}) {
 	const env = process.env ?? process.env;
 	const outPath = resolvePassphraseFilePath(env, options.out);
-	if (fs.existsSync(outPath) && !options.force) {
+	if (syncFs.existsSync(outPath) && !options.force) {
 		throw new Error(`Passphrase file already exists: ${outPath} (use --force to overwrite)`);
 	}
 	const bytes = typeof options.length === "number" && Number.isFinite(options.length) && options.length >= 16 ? Math.floor(options.length) : 24;
@@ -1887,15 +1887,15 @@ async function walletKeystorePassphraseRotateCommand(runtime = defaultRuntime, o
 	const cfg = loadConfig();
 	const keystorePath = resolveEmbeddedKeystorePath(env, cfg.wallet?.keystore?.path);
 	const passphraseFile = resolvePassphraseFilePath(env, options.file);
-	if (!fs.existsSync(keystorePath)) {
+	if (!syncFs.existsSync(keystorePath)) {
 		throw new Error(`Keystore missing: ${keystorePath}`);
 	}
-	const oldPassphrase = (options.oldPassphrase ?? (fs.existsSync(passphraseFile) ? fs.readFileSync(passphraseFile, "utf8") : "")).trim() || String(env.FASED_WALLET_PASSPHRASE ?? "").trim();
+	const oldPassphrase = (options.oldPassphrase ?? (syncFs.existsSync(passphraseFile) ? syncFs.readFileSync(passphraseFile, "utf8") : "")).trim() || String(env.FASED_WALLET_PASSPHRASE ?? "").trim();
 	if (!oldPassphrase) {
 		throw new Error("Missing old passphrase. Provide --old-passphrase or configure passphrase file/env.");
 	}
 	const newPassphrase = (options.newPassphrase ?? "").trim() || randomBytes(24).toString("base64url");
-	const raw = fs.readFileSync(keystorePath, "utf8");
+	const raw = syncFs.readFileSync(keystorePath, "utf8");
 	const detected = detectEmbeddedKeystoreType(raw);
 	if (detected === "solana-envelope") {
 		const envelope = parseSolanaKeystoreEnvelope(raw);
@@ -1908,7 +1908,7 @@ async function walletKeystorePassphraseRotateCommand(runtime = defaultRuntime, o
 			passphrase: newPassphrase,
 			publicKey: envelope.publicKey
 		});
-		fs.writeFileSync(keystorePath, `${JSON.stringify(nextEnvelope, null, 2)}\n`, {
+		syncFs.writeFileSync(keystorePath, `${JSON.stringify(nextEnvelope, null, 2)}\n`, {
 			encoding: "utf8",
 			mode: 384
 		});
@@ -1933,10 +1933,10 @@ async function walletKeystoreExportCommand(runtime = defaultRuntime, options = {
 	const env = process.env ?? process.env;
 	const cfg = loadConfig();
 	const keystorePath = resolveEmbeddedKeystorePath(env, cfg.wallet?.keystore?.path);
-	if (!fs.existsSync(keystorePath)) {
+	if (!syncFs.existsSync(keystorePath)) {
 		throw new Error(`Keystore missing: ${keystorePath}`);
 	}
-	const raw = fs.readFileSync(keystorePath, "utf8");
+	const raw = syncFs.readFileSync(keystorePath, "utf8");
 	const detected = detectEmbeddedKeystoreType(raw);
 	const outPath = options.out?.trim() ? path.resolve(options.out.trim()) : undefined;
 	const payload = {
@@ -1949,11 +1949,11 @@ async function walletKeystoreExportCommand(runtime = defaultRuntime, options = {
 		payload.keystore = raw;
 	}
 	if (outPath) {
-		fs.mkdirSync(path.dirname(outPath), {
+		syncFs.mkdirSync(path.dirname(outPath), {
 			recursive: true,
 			mode: 448
 		});
-		fs.writeFileSync(outPath, raw, {
+		syncFs.writeFileSync(outPath, raw, {
 			encoding: "utf8",
 			mode: 384
 		});
@@ -2139,7 +2139,7 @@ async function collectWalletSignerDoctorReport(env = process.env, options = {})
 	const isNotFoundError = (err) => err?.code === "ENOENT";
 	if (isLocalSigner) {
 		try {
-			const st = fs.statSync(socketPath);
+			const st = syncFs.statSync(socketPath);
 			push("socket.exists", st.isSocket?.() ?? true, socketPath);
 			try {
 				const mode = st.mode & 511;
@@ -2149,7 +2149,7 @@ async function collectWalletSignerDoctorReport(env = process.env, options = {})
 			push("socket.exists", localSignerSetupPending && isNotFoundError(err), localSignerSetupPending && isNotFoundError(err) ? "Configure" : String(err));
 		}
 		try {
-			const pidRaw = fs.readFileSync(pidPath, "utf8").trim();
+			const pidRaw = syncFs.readFileSync(pidPath, "utf8").trim();
 			const pid = Number.parseInt(pidRaw, 10);
 			if (Number.isFinite(pid) && pid > 1) {
 				try {
@@ -2165,7 +2165,7 @@ async function collectWalletSignerDoctorReport(env = process.env, options = {})
 			push("pid.alive", localSignerSetupPending && isNotFoundError(err), localSignerSetupPending && isNotFoundError(err) ? "Configure" : String(err));
 		}
 		try {
-			const st = fs.statSync(auditPath);
+			const st = syncFs.statSync(auditPath);
 			push("audit.exists", true, `bytes=${st.size}`);
 		} catch (err) {
 			push("audit.exists", localSignerSetupPending && isNotFoundError(err), localSignerSetupPending && isNotFoundError(err) ? "Configure" : String(err));
@@ -2193,14 +2193,14 @@ async function collectWalletSignerDoctorReport(env = process.env, options = {})
 			return "";
 		}
 		try {
-			return fs.readFileSync(p, "utf8").trim();
+			return syncFs.readFileSync(p, "utf8").trim();
 		} catch {
 			return "";
 		}
 	})();
 	const inspectKeystore = (label, keystorePath) => {
 		try {
-			const raw = fs.readFileSync(keystorePath, "utf8");
+			const raw = syncFs.readFileSync(keystorePath, "utf8");
 			const kind = detectEmbeddedKeystoreType(raw);
 			if (kind === "unknown") {
 				push(`keystore.file.${label}`, false, `${keystorePath} type=unknown (expected fased-solana-keypair envelope)`);
@@ -2257,7 +2257,7 @@ async function collectWalletSignerDoctorReport(env = process.env, options = {})
 			return true;
 		}
 		const defaultPath = resolveEmbeddedKeystorePathForChain(effectiveEnv, "solana");
-		if (fs.existsSync(defaultPath)) {
+		if (syncFs.existsSync(defaultPath)) {
 			return true;
 		}
 		if (providerDefaultWallet?.addresses?.solana) {

package/dist/config/cache-utils.js

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import syncFs from "node:fs";
 
 //#region src/config/cache-utils.ts
 function resolveCacheTtlMs(params) {
@@ -16,7 +16,7 @@ function isCacheEnabled(ttlMs) {
 }
 function getFileMtimeMs(filePath) {
 	try {
-		return fs.statSync(filePath).mtimeMs;
+		return syncFs.statSync(filePath).mtimeMs;
 	} catch {
 		return undefined;
 	}

package/dist/config/includes.js

@@ -4,7 +4,7 @@ import { isBlockedObjectKey } from "../infra/prototype-keys.js";
 import { canUseBoundaryFileOpen, openBoundaryFileSync } from "../infra/boundary-file-read.js";
 import { isPathInside } from "../security/scan-paths.js";
 import "./prototype-keys.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 import JSON5 from "json5";
 
@@ -130,7 +130,7 @@ var IncludeProcessor = class IncludeProcessor {
 			throw new ConfigIncludeError(`Include path escapes config directory: ${includePath} (root: ${this.rootDir})`, includePath);
 		}
 		try {
-			const real = fs.realpathSync(normalized);
+			const real = syncFs.realpathSync(normalized);
 			if (!isPathInside(this.rootRealDir, real)) {
 				throw new ConfigIncludeError(`Include path resolves outside config directory (symlink): ${includePath} (root: ${this.rootDir})`, includePath);
 			}
@@ -184,13 +184,13 @@ var IncludeProcessor = class IncludeProcessor {
 };
 function safeRealpath(target) {
 	try {
-		return fs.realpathSync(target);
+		return syncFs.realpathSync(target);
 	} catch {
 		return target;
 	}
 }
 function readConfigIncludeFileWithGuards(params) {
-	const ioFs = params.ioFs ?? fs;
+	const ioFs = params.ioFs ?? syncFs;
 	const maxBytes = params.maxBytes ?? MAX_INCLUDE_FILE_BYTES;
 	if (!canUseBoundaryFileOpen(ioFs)) {
 		return ioFs.readFileSync(params.resolvedPath, "utf-8");
@@ -217,7 +217,7 @@ function readConfigIncludeFileWithGuards(params) {
 	}
 }
 const defaultResolver = {
-	readFile: (p) => fs.readFileSync(p, "utf-8"),
+	readFile: (p) => syncFs.readFileSync(p, "utf-8"),
 	readFileWithGuards: ({ includePath, resolvedPath, rootRealDir }) => readConfigIncludeFileWithGuards({
 		includePath,
 		resolvedPath,