@fased/fased 0.1.61 → 0.1.64

package/dist/gateway/server-methods/chat.js

@@ -30,7 +30,7 @@ import { parseMessageWithAttachments } from "../chat-attachments.js";
 import { injectTimestamp, timestampOptsFromConfig } from "./agent-timestamp.js";
 import { normalizeRpcAttachmentsToChatAttachments } from "./attachment-normalize.js";
 import { appendInjectedAssistantMessageToTranscript } from "./chat-transcript-inject.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/gateway/server-methods/chat.ts
@@ -328,7 +328,7 @@ function resolveTranscriptPath(params) {
 }
 function transcriptHasIdempotencyKey(transcriptPath, idempotencyKey) {
 	try {
-		const lines = fs.readFileSync(transcriptPath, "utf-8").split(/\r?\n/);
+		const lines = syncFs.readFileSync(transcriptPath, "utf-8").split(/\r?\n/);
 		for (const line of lines) {
 			if (!line.trim()) {
 				continue;
@@ -356,7 +356,7 @@ function appendAssistantTranscriptMessage(params) {
 			error: "transcript path not resolved"
 		};
 	}
-	if (!fs.existsSync(transcriptPath)) {
+	if (!syncFs.existsSync(transcriptPath)) {
 		if (!params.createIfMissing) {
 			return {
 				ok: false,

package/dist/gateway/server-methods/models.js

@@ -1,6 +1,5 @@
 import { defaultRuntime } from "../../runtime.js";
 import { resolveAgentDir, resolveDefaultAgentId, resolveSessionAgentId } from "../../agents/agent-scope.js";
-import { listProviderBrandManifests } from "../../providers/registry.js";
 import { DEFAULT_PROVIDER } from "../../agents/defaults.js";
 import { normalizeSecretInput } from "../../utils/normalize-secret-input.js";
 import { normalizeProviderId } from "../../agents/provider-id.js";
@@ -11,6 +10,7 @@ import { loadConfig, writeConfigFile } from "../../config/io.js";
 import "../../config/config.js";
 import { resolveProfileUnusableUntilForDisplay } from "../../agents/auth-profiles/usage.js";
 import "../../agents/auth-profiles.js";
+import { listProviderBrandManifests } from "../../providers/registry.js";
 import { ensureFasedModelsJson } from "../../agents/models-config.js";
 import { deriveModelMetadata } from "../../agents/model-metadata.js";
 import { ErrorCodes, errorShape } from "../protocol/schema/error-codes.js";

package/dist/gateway/server-methods/secrets.js

@@ -0,0 +1,40 @@
+import { logMutatingAdminRpcAudit } from "./mutating-admin-rpc-audit.js";
+import { ErrorCodes, errorShape } from "../protocol/schema/error-codes.js";
+import "../protocol/index.js";
+import { sanitizeGatewaySecretsRuntimeError } from "../server-secrets-runtime.js";
+
+//#region src/gateway/server-methods/secrets.ts
+function createSecretsHandlers(params) {
+	return { "secrets.reload": async ({ respond, client, context }) => {
+		try {
+			const result = await params.reloadSecrets();
+			logMutatingAdminRpcAudit({
+				context,
+				client,
+				method: "secrets.reload",
+				outcome: "succeeded",
+				details: { warningCount: result.warningCount }
+			});
+			respond(true, {
+				ok: true,
+				warningCount: result.warningCount
+			});
+		} catch (err) {
+			const safe = sanitizeGatewaySecretsRuntimeError(err);
+			logMutatingAdminRpcAudit({
+				context,
+				client,
+				method: "secrets.reload",
+				outcome: "failed",
+				details: { code: safe.code }
+			});
+			respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, safe.message, {
+				retryable: true,
+				details: { code: safe.code }
+			}));
+		}
+	} };
+}
+
+//#endregion
+export { createSecretsHandlers };

package/dist/gateway/server-methods/sessions.js

@@ -30,7 +30,7 @@ import { clearCheckpointBranchIsolationFields } from "../session-compaction-isol
 import { applySessionsPatchToStore } from "../sessions-patch.js";
 import { resolveSessionKeyFromResolveParams } from "../sessions-resolve.js";
 import { assertValidParams } from "./validation.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { SessionManager } from "@mariozechner/pi-coding-agent";
@@ -196,7 +196,7 @@ function resolveCheckpointSnapshotFile(params) {
 		return null;
 	}
 	try {
-		if (!fs.statSync(filePath).isFile()) {
+		if (!syncFs.statSync(filePath).isFile()) {
 			return null;
 		}
 	} catch {
@@ -543,7 +543,7 @@ const sessionsHandlers = {
 		}
 		const cleanupRestoredFile = () => {
 			try {
-				fs.rmSync(sessionFile, { force: true });
+				syncFs.rmSync(sessionFile, { force: true });
 			} catch {}
 		};
 		const cleanupError = await ensureSessionRuntimeCleanup({
@@ -1068,7 +1068,7 @@ const sessionsHandlers = {
 			}, undefined);
 			return;
 		}
-		const filePath = resolveSessionTranscriptCandidates(sessionId, storePath, entry?.sessionFile, target.agentId).find((candidate) => fs.existsSync(candidate));
+		const filePath = resolveSessionTranscriptCandidates(sessionId, storePath, entry?.sessionFile, target.agentId).find((candidate) => syncFs.existsSync(candidate));
 		if (!filePath) {
 			respond(true, {
 				ok: true,
@@ -1078,7 +1078,7 @@ const sessionsHandlers = {
 			}, undefined);
 			return;
 		}
-		const raw = fs.readFileSync(filePath, "utf-8");
+		const raw = syncFs.readFileSync(filePath, "utf-8");
 		const lines = raw.split(/\r?\n/).filter((l) => l.trim().length > 0);
 		if (lines.length <= maxLines) {
 			respond(true, {
@@ -1096,7 +1096,7 @@ const sessionsHandlers = {
 		const archived = archiveFileOnDisk(filePath, "bak");
 		const keptLines = lines.slice(-maxLines);
 		try {
-			fs.writeFileSync(filePath, `${keptLines.join("\n")}\n`, "utf-8");
+			syncFs.writeFileSync(filePath, `${keptLines.join("\n")}\n`, "utf-8");
 		} catch (error) {
 			if (preCompactionSnapshot) {
 				cleanupSessionCompactionSnapshot(preCompactionSnapshot);

package/dist/gateway/server-methods/usage.js

@@ -12,7 +12,7 @@ import { readCronRunLogEntriesPageAll } from "../../cron/run-log.js";
 import { loadCronStore, resolveCronStorePath } from "../../cron/store.js";
 import { discoverAllSessions, loadCostUsageSummary, loadSessionCostSummary, loadSessionUsageTimeSeries } from "../../infra/session-cost-usage.js";
 import { buildUsageAggregateTail } from "../../shared/usage-aggregates.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 
 //#region src/gateway/server-methods/usage.ts
 const COST_USAGE_CACHE_TTL_MS = 3e4;
@@ -662,7 +662,7 @@ const usageHandlers = {
 				return;
 			}
 			try {
-				const stats = fs.statSync(sessionFile);
+				const stats = syncFs.statSync(sessionFile);
 				if (stats.isFile()) {
 					mergedEntries.push({
 						key: resolvedStoreKey,

package/dist/gateway/server-methods.js

@@ -55,10 +55,9 @@ const CONTROL_PLANE_WRITE_METHODS = new Set([
 ]);
 const SAT_MINING_MUTATION_METHODS = new Set([
 	"sat.openCycle",
-	"sat.bootstrapRegistryReserve",
+	"sat.topUpRegistryReserve",
 	"sat.refillRegistryReserveFromTreasury",
 	"sat.runProtocolMaintenanceOnce",
-	"sat.setProtocolRecipients",
 	"sat.claimProtocolTreasury",
 	"sat.claimProtocolDistributorSat",
 	"sat.initMinerCapital",

package/dist/gateway/server-reload-handlers.js

@@ -19,76 +19,201 @@ function shouldInvalidateGatewayModelCatalog(changedPaths) {
 	return changedPaths.some((path) => path === "models" || path.startsWith("models.") || path === "agents.defaults.model" || path.startsWith("agents.defaults.model.") || path === "agents.defaults.models" || path.startsWith("agents.defaults.models."));
 }
 function createGatewayReloadHandlers(params) {
-	const applyHotReload = async (plan, nextConfig) => {
-		setGatewaySigusr1RestartPolicy({ allowExternal: isRestartEnabled(nextConfig) });
-		const state = params.getState();
-		const nextState = { ...state };
-		if (plan.reloadHooks) {
-			try {
-				nextState.hooksConfig = resolveHooksConfig(nextConfig);
-			} catch (err) {
-				params.logHooks.warn(`hooks config reload failed: ${String(err)}`);
-			}
-		}
-		if (plan.restartHeartbeat) {
-			nextState.heartbeatRunner.updateConfig(nextConfig);
-		}
-		resetDirectoryCache();
-		if (shouldInvalidateGatewayModelCatalog(plan.changedPaths)) {
-			markGatewayModelCatalogStaleForReload();
-		}
-		if (plan.restartCron) {
-			state.cronState.cron.stop();
-			nextState.cronState = buildGatewayCronService({
-				cfg: nextConfig,
-				deps: params.deps,
-				broadcast: params.broadcast
+	const createHotReloadTransaction = (plan) => {
+		const originalState = params.getState();
+		let workingState = { ...originalState };
+		let policyMutated = false;
+		let heartbeatMutated = false;
+		let cronMutated = false;
+		let browserMutated = false;
+		let gmailMutated = false;
+		let concurrencyMutated = false;
+		const channelsMutated = [];
+		let applyStarted = false;
+		let rollbackStarted = false;
+		const publishState = () => {
+			params.setState({ ...workingState });
+		};
+		const startGmailWatcherForReload = async (config, phase) => {
+			let failed = false;
+			await startGmailWatcherWithLogs({
+				cfg: config,
+				log: {
+					info: (message) => params.logHooks.info(message),
+					warn: () => params.logHooks.warn(`gmail watcher ${phase} did not start`),
+					error: () => {
+						failed = true;
+						params.logHooks.error(`gmail watcher ${phase} failed to start`);
+					}
+				},
+				onSkipped: () => params.logHooks.info(`skipping gmail watcher ${phase} (FASED_SKIP_GMAIL_WATCHER=1)`)
 			});
-			void nextState.cronState.cron.start().catch((err) => params.logCron.error(`failed to start: ${String(err)}`));
-		}
-		if (plan.restartBrowserControl) {
-			if (state.browserControl) {
-				await state.browserControl.stop().catch(() => {});
+			if (failed) {
+				throw new Error(`gmail watcher ${phase} failed`);
 			}
-			try {
-				nextState.browserControl = await startBrowserControlServerIfEnabled();
-			} catch (err) {
-				params.logBrowser.error(`server failed to start: ${String(err)}`);
+		};
+		const apply = async (nextConfig) => {
+			if (applyStarted) {
+				throw new Error("hot reload transaction already started");
 			}
-		}
-		if (plan.restartGmailWatcher) {
-			await stopGmailWatcher().catch(() => {});
-			await startGmailWatcherWithLogs({
-				cfg: nextConfig,
-				log: params.logHooks,
-				onSkipped: () => params.logHooks.info("skipping gmail watcher restart (FASED_SKIP_GMAIL_WATCHER=1)")
-			});
-		}
-		if (plan.restartChannels.size > 0) {
-			if (isTruthyEnvValue(process.env.FASED_SKIP_CHANNELS) || isTruthyEnvValue(process.env.FASED_SKIP_PROVIDERS)) {
-				params.logChannels.info("skipping channel reload (FASED_SKIP_CHANNELS=1 or FASED_SKIP_PROVIDERS=1)");
-			} else {
-				const restartChannel = async (name) => {
-					params.logChannels.info(`restarting ${name} channel`);
-					await params.stopChannel(name);
-					await params.startChannel(name);
-				};
-				for (const channel of plan.restartChannels) {
-					await restartChannel(channel);
+			applyStarted = true;
+			policyMutated = true;
+			setGatewaySigusr1RestartPolicy({ allowExternal: isRestartEnabled(nextConfig) });
+			if (plan.reloadHooks) {
+				workingState.hooksConfig = resolveHooksConfig(nextConfig);
+			}
+			if (plan.restartHeartbeat) {
+				heartbeatMutated = true;
+				workingState.heartbeatRunner.updateConfig(nextConfig);
+			}
+			resetDirectoryCache();
+			if (shouldInvalidateGatewayModelCatalog(plan.changedPaths)) {
+				markGatewayModelCatalogStaleForReload();
+			}
+			if (plan.restartCron) {
+				cronMutated = true;
+				workingState.cronState.cron.stop();
+				workingState.cronState = buildGatewayCronService({
+					cfg: nextConfig,
+					deps: params.deps,
+					broadcast: params.broadcast
+				});
+				publishState();
+				await workingState.cronState.cron.start();
+			}
+			if (plan.restartBrowserControl) {
+				browserMutated = true;
+				try {
+					await workingState.browserControl?.stop();
+				} finally {
+					workingState.browserControl = null;
+					publishState();
 				}
+				workingState.browserControl = await startBrowserControlServerIfEnabled();
+				publishState();
 			}
-		}
-		setCommandLaneConcurrency(CommandLane.Cron, nextConfig.cron?.maxConcurrentRuns ?? 1);
-		setCommandLaneConcurrency(CommandLane.Main, resolveAgentMaxConcurrent(nextConfig));
-		setCommandLaneConcurrency(CommandLane.Subagent, resolveSubagentMaxConcurrent(nextConfig));
-		if (plan.hotReasons.length > 0) {
-			params.logReload.info(`config hot reload applied (${plan.hotReasons.join(", ")})`);
-		} else if (plan.noopPaths.length > 0) {
-			params.logReload.info(`config change applied (dynamic reads: ${plan.noopPaths.join(", ")})`);
-		}
-		params.setState(nextState);
+			if (plan.restartGmailWatcher) {
+				gmailMutated = true;
+				await stopGmailWatcher();
+				await startGmailWatcherForReload(nextConfig, "apply");
+			}
+			if (plan.restartChannels.size > 0) {
+				if (isTruthyEnvValue(process.env.FASED_SKIP_CHANNELS) || isTruthyEnvValue(process.env.FASED_SKIP_PROVIDERS)) {
+					params.logChannels.info("skipping channel reload (FASED_SKIP_CHANNELS=1 or FASED_SKIP_PROVIDERS=1)");
+				} else {
+					for (const channel of plan.restartChannels) {
+						channelsMutated.push(channel);
+						params.logChannels.info(`restarting ${channel} channel`);
+						await params.stopChannel(channel);
+						await params.startChannel(channel);
+					}
+				}
+			}
+			concurrencyMutated = true;
+			setCommandLaneConcurrency(CommandLane.Cron, nextConfig.cron?.maxConcurrentRuns ?? 1);
+			setCommandLaneConcurrency(CommandLane.Main, resolveAgentMaxConcurrent(nextConfig));
+			setCommandLaneConcurrency(CommandLane.Subagent, resolveSubagentMaxConcurrent(nextConfig));
+			if (plan.hotReasons.length > 0) {
+				params.logReload.info(`config hot reload applied (${plan.hotReasons.join(", ")})`);
+			} else if (plan.noopPaths.length > 0) {
+				params.logReload.info(`config change applied (dynamic reads: ${plan.noopPaths.join(", ")})`);
+			}
+			publishState();
+		};
+		const rollback = async (previousConfig) => {
+			if (!applyStarted || rollbackStarted) {
+				return;
+			}
+			rollbackStarted = true;
+			const failures = [];
+			const capture = async (operation) => {
+				try {
+					await operation();
+					return true;
+				} catch (error) {
+					failures.push(error);
+					return false;
+				}
+			};
+			if (concurrencyMutated) {
+				await capture(() => {
+					setCommandLaneConcurrency(CommandLane.Cron, previousConfig.cron?.maxConcurrentRuns ?? 1);
+					setCommandLaneConcurrency(CommandLane.Main, resolveAgentMaxConcurrent(previousConfig));
+					setCommandLaneConcurrency(CommandLane.Subagent, resolveSubagentMaxConcurrent(previousConfig));
+				});
+			}
+			for (const channel of channelsMutated.toReversed()) {
+				const stopped = await capture(async () => await params.stopChannel(channel));
+				if (stopped) {
+					await capture(async () => await params.startChannel(channel));
+				}
+			}
+			if (gmailMutated) {
+				const stopped = await capture(async () => await stopGmailWatcher());
+				if (stopped) {
+					await capture(async () => await startGmailWatcherForReload(previousConfig, "rollback"));
+				}
+			}
+			if (browserMutated) {
+				const candidateBrowser = workingState.browserControl;
+				const candidateStopped = await capture(async () => await candidateBrowser?.stop());
+				workingState.browserControl = null;
+				publishState();
+				if (candidateStopped) {
+					let restoredBrowser = null;
+					const restored = await capture(async () => {
+						restoredBrowser = await startBrowserControlServerIfEnabled();
+					});
+					if (restored) {
+						workingState.browserControl = restoredBrowser;
+						publishState();
+					}
+				}
+			}
+			if (cronMutated) {
+				await capture(() => workingState.cronState.cron.stop());
+				workingState.cronState = originalState.cronState;
+				publishState();
+				await capture(async () => await originalState.cronState.cron.start());
+			}
+			if (heartbeatMutated) {
+				const restored = await capture(() => workingState.heartbeatRunner.updateConfig(previousConfig));
+				if (!restored) {
+					await capture(() => workingState.heartbeatRunner.stop());
+				}
+			}
+			workingState.hooksConfig = originalState.hooksConfig;
+			if (policyMutated) {
+				await capture(() => setGatewaySigusr1RestartPolicy({ allowExternal: isRestartEnabled(previousConfig) }));
+			}
+			resetDirectoryCache();
+			if (shouldInvalidateGatewayModelCatalog(plan.changedPaths)) {
+				markGatewayModelCatalogStaleForReload();
+			}
+			publishState();
+			if (failures.length > 0) {
+				throw new Error(`hot reload rollback incomplete (${failures.length} component failure(s))`);
+			}
+		};
+		return {
+			apply,
+			rollback
+		};
+	};
+	const applyHotReload = async (plan, nextConfig) => {
+		await createHotReloadTransaction(plan).apply(nextConfig);
 	};
 	let restartPending = false;
+	let restartDeferral = null;
+	const cancelPendingGatewayRestart = () => {
+		const cancelled = restartDeferral?.cancel() ?? false;
+		restartDeferral = null;
+		restartPending = false;
+		if (cancelled) {
+			params.logReload.info("cancelled deferred config restart before evaluating the latest revision");
+		}
+		return cancelled;
+	};
 	const requestGatewayRestart = (plan, nextConfig) => {
 		setGatewaySigusr1RestartPolicy({ allowExternal: isRestartEnabled(nextConfig) });
 		const reasons = plan.restartReasons.length ? plan.restartReasons.join(", ") : plan.changedPaths.join(", ");
@@ -123,30 +248,33 @@ function createGatewayReloadHandlers(params) {
 		const active = getActiveCounts();
 		if (active.totalActive > 0) {
 			if (restartPending) {
-				params.logReload.info(`config change requires gateway restart (${reasons}) — already waiting for operations to complete`);
-				return;
+				cancelPendingGatewayRestart();
 			}
 			restartPending = true;
 			const initialDetails = formatActiveDetails(active);
 			params.logReload.warn(`config change requires gateway restart (${reasons}) — deferring until ${initialDetails.join(", ")} complete`);
-			deferGatewayRestartUntilIdle({
+			const deferral = deferGatewayRestartUntilIdle({
 				getPendingCount: () => getActiveCounts().totalActive,
 				hooks: {
 					onReady: () => {
 						restartPending = false;
+						restartDeferral = null;
 						params.logReload.info("all operations and replies completed; restarting gateway now");
 					},
 					onTimeout: (_pending, elapsedMs) => {
 						const remaining = formatActiveDetails(getActiveCounts());
 						restartPending = false;
+						restartDeferral = null;
 						params.logReload.warn(`restart timeout after ${elapsedMs}ms with ${remaining.join(", ")} still active; restarting anyway`);
 					},
 					onCheckError: (err) => {
 						restartPending = false;
+						restartDeferral = null;
 						params.logReload.warn(`restart deferral check failed (${String(err)}); restarting gateway now`);
 					}
 				}
 			});
+			restartDeferral = deferral.isPending() ? deferral : null;
 		} else {
 			params.logReload.warn(`config change requires gateway restart (${reasons})`);
 			const emitted = emitGatewayRestart();
@@ -157,6 +285,8 @@ function createGatewayReloadHandlers(params) {
 	};
 	return {
 		applyHotReload,
+		cancelPendingGatewayRestart,
+		createHotReloadTransaction,
 		requestGatewayRestart
 	};
 }

package/dist/gateway/server-runtime-config.js

@@ -1,7 +1,7 @@
 import { isLoopbackHost, isTrustedProxyAddress, isValidIPv4, resolveGatewayBindHost } from "./net.js";
 import { resolveWalletRuntimeConfig } from "../wallet/wallet-runtime-config.js";
-import { resolveWalletApprovalAuthMode } from "../wallet/wallet-approval-auth.js";
 import { normalizeControlUiBasePath } from "./control-ui-shared.js";
+import { resolveWalletApprovalAuthMode } from "../wallet/wallet-approval-auth.js";
 import { resolveHooksConfig } from "./hooks.js";
 import { assertGatewayAuthConfigured, resolveGatewayAuth } from "./auth.js";