everything-dev 0.3.3 → 1.3.3

package/dist/plugin.cjs

@@ -0,0 +1,830 @@
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_fastkv = require('./fastkv.cjs');
+const require_network = require('./network.cjs');
+require('./sdk.cjs');
+const require_config = require('./config.cjs');
+const require_contract = require('./contract.cjs');
+const require_api_contract = require('./api-contract.cjs');
+const require_app = require('./app.cjs');
+const require_cli_init = require('./cli/init.cjs');
+const require_prompts = require('./cli/prompts.cjs');
+const require_dev_session = require('./dev-session.cjs');
+const require_near_cli = require('./near-cli.cjs');
+const require_shared = require('./shared.cjs');
+const require_run = require('./utils/run.cjs');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let effect = require("effect");
+let every_plugin = require("every-plugin");
+let every_plugin_zod = require("every-plugin/zod");
+
+//#region src/plugin.ts
+const DEFAULT_DEV_CONFIG = {
+	host: "local",
+	ui: "local",
+	api: "local",
+	ssr: false
+};
+const buildCommands = {
+	host: {
+		cmd: "bun",
+		args: ["run", "build"]
+	},
+	ui: {
+		cmd: "bun",
+		args: ["run", "build"]
+	},
+	api: {
+		cmd: "bun",
+		args: ["run", "build"]
+	}
+};
+const PUBLISH_FUNCTION_NAMES = ["__fastdata_kv"];
+function parseSourceMode(value, defaultValue) {
+	if (value === "local" || value === "remote") return value;
+	return defaultValue;
+}
+function buildAppConfig(options) {
+	return {
+		host: parseSourceMode(options.host, DEFAULT_DEV_CONFIG.host),
+		ui: parseSourceMode(options.ui, DEFAULT_DEV_CONFIG.ui),
+		api: parseSourceMode(options.api, DEFAULT_DEV_CONFIG.api),
+		proxy: options.proxy,
+		ssr: options.ssr ?? DEFAULT_DEV_CONFIG.ssr
+	};
+}
+function buildDescription(config) {
+	if (config.host === "local" && config.ui === "local" && config.api === "local" && !config.proxy) return "Full Local Development";
+	const parts = [];
+	parts.push(config.host === "remote" ? "Remote Host" : "Local Host");
+	if (config.ui === "remote") parts.push("Remote UI");
+	if (config.proxy) parts.push("Proxy API → Production");
+	else if (config.api === "remote") parts.push("Remote API");
+	return parts.join(" + ");
+}
+function buildConfigResult(bosConfig) {
+	const packages = bosConfig ? Object.keys(bosConfig.app) : [];
+	return {
+		config: bosConfig,
+		packages,
+		remotes: packages.filter((name) => name !== "host")
+	};
+}
+function resolveWorkspaceTarget(key, bosConfig, runtimeConfig, configDir) {
+	if (bosConfig?.app && key in bosConfig.app) return {
+		key,
+		kind: "app",
+		path: `${configDir}/${key}`
+	};
+	const pluginPath = (runtimeConfig?.plugins?.[key])?.localPath ?? require_config.resolveLocalDevelopmentPath(bosConfig?.plugins?.[key]?.development, configDir);
+	if (pluginPath) return {
+		key,
+		kind: "plugin",
+		path: pluginPath
+	};
+	return null;
+}
+function determineProcesses(config, localPackages, runtimeConfig) {
+	const processes = [];
+	if (config.ssr && config.ui === "local") processes.push("ui-ssr");
+	if (config.ui === "local") processes.push("ui");
+	if (config.api === "local" && !config.proxy) processes.push("api");
+	for (const pkg of localPackages) if (pkg.startsWith("plugin:")) {
+		const pluginId = pkg.slice(7);
+		if (runtimeConfig?.plugins?.[pluginId]?.source === "local") processes.push(pkg);
+	}
+	processes.push("host");
+	return processes;
+}
+function isValidProxyUrl(url) {
+	try {
+		const parsed = new URL(url);
+		return parsed.protocol === "http:" || parsed.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+function resolveProxyUrl(bosConfig) {
+	if (!bosConfig) return null;
+	const apiConfig = bosConfig.app.api;
+	if (!apiConfig) return null;
+	if (apiConfig.proxy && isValidProxyUrl(apiConfig.proxy)) return apiConfig.proxy;
+	if (apiConfig.production && isValidProxyUrl(apiConfig.production)) return apiConfig.production;
+	return null;
+}
+function sanitizePluginKey(value) {
+	return value.replace(/[^A-Za-z0-9/_-]/g, "-").replace(/\/+/g, "/").split("/").filter(Boolean).map((segment) => segment.replace(/[^A-Za-z0-9_-]/g, "-")).join("/").replace(/^\/+|\/+$/g, "");
+}
+function defaultPluginKey(source) {
+	const normalized = source.replace(/^local:/, "").replace(/\/$/, "");
+	if (source.startsWith("local:")) return sanitizePluginKey((0, node_path.basename)(normalized)) || "plugin";
+	try {
+		const url = new URL(source);
+		return sanitizePluginKey((0, node_path.basename)(url.pathname) || url.hostname) || "plugin";
+	} catch {
+		return sanitizePluginKey(source) || "plugin";
+	}
+}
+function pluginLocalPath(configDir, attachment) {
+	const source = attachment.development ?? attachment.production;
+	if (!source?.startsWith("local:")) return null;
+	return (0, node_path.join)(configDir, source.slice(6));
+}
+async function saveBosConfig(configDir, config) {
+	const filePath = (0, node_path.join)(configDir, "bos.config.json");
+	const next = `${JSON.stringify(config, null, 2)}\n`;
+	try {
+		if ((0, node_fs.readFileSync)(filePath, "utf8") === next) return;
+	} catch {}
+	(0, node_fs.writeFileSync)(filePath, next);
+}
+function listPluginAttachments(config) {
+	return Object.entries(config?.plugins ?? {}).map(([key, attachment]) => ({
+		key,
+		development: attachment.development,
+		production: attachment.production,
+		localPath: attachment.development?.startsWith("local:") ? attachment.development.slice(6) : void 0,
+		source: attachment.development?.startsWith("local:") ? "local" : "remote"
+	})).sort((a, b) => a.key.localeCompare(b.key));
+}
+async function refreshApiContractBridge(configDir) {
+	const refreshed = await require_config.loadConfig({
+		cwd: configDir,
+		env: "development"
+	});
+	if (!refreshed) return;
+	await require_api_contract.syncApiContractBridge({
+		configDir,
+		runtimeConfig: refreshed.runtime,
+		apiBaseUrl: refreshed.runtime.api.url
+	});
+}
+function extractPublishedUrl(output) {
+	const match = output.match(/https?:\/\/[^\s"'<>]+/g);
+	if (!match || match.length === 0) return null;
+	return match[match.length - 1] ?? null;
+}
+async function buildEnvVars(config, bosConfig) {
+	const env = {
+		HOST_SOURCE: config.host,
+		UI_SOURCE: config.ui,
+		API_SOURCE: config.api
+	};
+	if (config.host === "remote") {
+		const remoteUrl = bosConfig?.app.host.production;
+		if (remoteUrl) env.HOST_REMOTE_URL = remoteUrl;
+	}
+	if (config.ui === "remote") {
+		const remoteUrl = bosConfig?.app.ui.production;
+		if (remoteUrl) env.UI_REMOTE_URL = remoteUrl;
+	}
+	if (config.api === "remote") {
+		const remoteUrl = bosConfig?.app.api.production;
+		if (remoteUrl) env.API_REMOTE_URL = remoteUrl;
+	}
+	if (config.proxy && bosConfig) {
+		const proxyUrl = resolveProxyUrl(bosConfig);
+		if (proxyUrl) env.API_PROXY = proxyUrl;
+	}
+	return env;
+}
+async function buildEveryPluginQuietly(cwd) {
+	const packageDir = `${cwd}/packages/every-plugin`;
+	if (!await Bun.file(`${packageDir}/package.json`).exists()) return;
+	const distPath = `${cwd}/packages/every-plugin/dist/build/rspack/plugin.mjs`;
+	if (await Bun.file(distPath).exists()) return;
+	const result = await require_run.run("bun", [
+		"run",
+		"--cwd",
+		"packages/every-plugin",
+		"build"
+	], {
+		cwd,
+		capture: true
+	});
+	if (result.exitCode === 0) {
+		console.log("[build:ssr] build succeeded");
+		return;
+	}
+	if (result.stdout.trim()) process.stdout.write(result.stdout);
+	if (result.stderr.trim()) process.stderr.write(result.stderr);
+	throw new Error(`bun run --cwd packages/every-plugin build failed with exit code ${result.exitCode}`);
+}
+async function buildEverythingDevQuietly(cwd) {
+	const packageDir = `${cwd}/packages/everything-dev`;
+	if (!await Bun.file(`${packageDir}/package.json`).exists()) return;
+	const distPath = `${cwd}/packages/everything-dev/dist/index.mjs`;
+	if (await Bun.file(distPath).exists()) return;
+	const result = await require_run.run("bun", [
+		"run",
+		"--cwd",
+		"packages/everything-dev",
+		"build"
+	], {
+		cwd,
+		capture: true
+	});
+	if (result.exitCode === 0) {
+		console.log("[everything-dev] build succeeded");
+		return;
+	}
+	if (result.stdout.trim()) process.stdout.write(result.stdout);
+	if (result.stderr.trim()) process.stderr.write(result.stderr);
+	throw new Error(`bun run --cwd packages/everything-dev build failed with exit code ${result.exitCode}`);
+}
+async function fetchPublishedConfig(accountId, gatewayId) {
+	try {
+		return await require_fastkv.fetchBosConfigFromFastKv(`bos://${accountId}/${gatewayId}`);
+	} catch {
+		return null;
+	}
+}
+function selectWorkspaceTargets(packages, bosConfig) {
+	const allPackages = [...Object.keys(bosConfig?.app ?? {}), ...Object.keys(bosConfig?.plugins ?? {})];
+	if (packages === "all") return allPackages;
+	return packages.split(",").map((pkg) => pkg.trim()).filter((pkg) => allPackages.includes(pkg));
+}
+async function buildWorkspaceTargets(opts) {
+	const existing = [];
+	const skipped = [];
+	for (const target of opts.targets) {
+		const resolved = resolveWorkspaceTarget(target, opts.bosConfig, opts.runtimeConfig, opts.configDir);
+		if (!resolved) {
+			skipped.push(target);
+			continue;
+		}
+		if (await Bun.file(`${resolved.path}/package.json`).exists()) existing.push(resolved);
+		else skipped.push(target);
+	}
+	if (existing.length === 0) return {
+		built: [],
+		skipped
+	};
+	if ((await require_shared.syncAndGenerateSharedUi({
+		configDir: opts.configDir,
+		hostMode: "local",
+		bosConfig: opts.bosConfig ?? void 0
+	})).catalogChanged) await require_run.run("bun", ["install"], { cwd: opts.configDir });
+	if (existing.some((entry) => entry.key === "api")) await buildEveryPluginQuietly(opts.configDir);
+	await buildEverythingDevQuietly(opts.configDir);
+	const env = {
+		...process.env,
+		NODE_ENV: opts.deploy ? "production" : "development"
+	};
+	if (opts.deploy) env.DEPLOY = "true";
+	else delete env.DEPLOY;
+	const orderedExisting = opts.deploy ? [
+		...existing.filter((entry) => entry.kind === "app" && entry.key !== "host"),
+		...existing.filter((entry) => entry.kind === "plugin"),
+		...existing.filter((entry) => entry.kind === "app" && entry.key === "host")
+	] : existing;
+	const built = [];
+	for (const resolved of orderedExisting) {
+		const pkgJson = JSON.parse(await Bun.file(`${resolved.path}/package.json`).text());
+		const buildConfig = opts.deploy && pkgJson.scripts?.deploy ? {
+			cmd: "bun",
+			args: ["run", "deploy"]
+		} : buildCommands[resolved.key] ?? {
+			cmd: "bun",
+			args: ["run", "build"]
+		};
+		await require_run.run(buildConfig.cmd, buildConfig.args, {
+			cwd: resolved.path,
+			env
+		});
+		built.push(resolved.key);
+	}
+	return {
+		built,
+		skipped
+	};
+}
+var plugin_default = (0, every_plugin.createPlugin)({
+	variables: every_plugin_zod.z.object({ configPath: every_plugin_zod.z.string().optional() }),
+	secrets: every_plugin_zod.z.object({}),
+	contract: require_contract.bosContract,
+	initialize: (config) => effect.Effect.promise(async () => {
+		const configResult = await require_config.loadConfig({ path: config.variables.configPath });
+		return {
+			bosConfig: configResult?.config ?? null,
+			runtimeConfig: configResult?.runtime ?? null,
+			configDir: require_config.getProjectRoot()
+		};
+	}),
+	shutdown: () => effect.Effect.void,
+	createRouter: (deps, builder) => ({
+		config: builder.config.handler(async () => buildConfigResult(deps.bosConfig)),
+		pluginAdd: builder.pluginAdd.handler(async ({ input }) => {
+			if (!deps.bosConfig) return {
+				status: "error",
+				key: "",
+				error: "No bos.config.json found"
+			};
+			const key = sanitizePluginKey(input.as ?? defaultPluginKey(input.source));
+			const existing = deps.bosConfig.plugins?.[key];
+			const nextPlugins = { ...deps.bosConfig.plugins ?? {} };
+			nextPlugins[key] = input.source.startsWith("local:") ? {
+				...existing ?? {},
+				development: input.source,
+				production: input.production ?? existing?.production
+			} : {
+				...existing ?? {},
+				production: input.production ?? input.source
+			};
+			deps.bosConfig = {
+				...deps.bosConfig,
+				plugins: nextPlugins
+			};
+			await saveBosConfig(deps.configDir, deps.bosConfig);
+			await refreshApiContractBridge(deps.configDir);
+			return {
+				status: "added",
+				key,
+				development: deps.bosConfig.plugins?.[key]?.development,
+				production: deps.bosConfig.plugins?.[key]?.production
+			};
+		}),
+		pluginRemove: builder.pluginRemove.handler(async ({ input }) => {
+			if (!deps.bosConfig) return {
+				status: "error",
+				key: input.key,
+				error: "No bos.config.json found"
+			};
+			if (!deps.bosConfig.plugins?.[input.key]) return {
+				status: "error",
+				key: input.key,
+				error: `Plugin '${input.key}' is not configured`
+			};
+			const nextPlugins = { ...deps.bosConfig.plugins ?? {} };
+			delete nextPlugins[input.key];
+			deps.bosConfig = {
+				...deps.bosConfig,
+				plugins: Object.keys(nextPlugins).length > 0 ? nextPlugins : void 0
+			};
+			await saveBosConfig(deps.configDir, deps.bosConfig);
+			await refreshApiContractBridge(deps.configDir);
+			return {
+				status: "removed",
+				key: input.key
+			};
+		}),
+		pluginList: builder.pluginList.handler(async () => {
+			return {
+				status: "listed",
+				plugins: listPluginAttachments(deps.bosConfig)
+			};
+		}),
+		pluginPublish: builder.pluginPublish.handler(async ({ input }) => {
+			if (!deps.bosConfig) return {
+				status: "error",
+				key: input.key,
+				error: "No bos.config.json found"
+			};
+			const attachment = deps.bosConfig.plugins?.[input.key];
+			if (!attachment) return {
+				status: "error",
+				key: input.key,
+				error: `Plugin '${input.key}' is not configured`
+			};
+			const localPath = pluginLocalPath(deps.configDir, attachment);
+			if (!localPath) return {
+				status: "error",
+				key: input.key,
+				error: `Plugin '${input.key}' does not have a local development path`
+			};
+			const pkgPath = (0, node_path.join)(localPath, "package.json");
+			if (!await Bun.file(pkgPath).exists()) return {
+				status: "error",
+				key: input.key,
+				error: `Missing package.json at ${localPath}`
+			};
+			const script = (await Bun.file(pkgPath).json()).scripts?.deploy ? "deploy" : "build";
+			const { stdout, stderr, exitCode } = await require_run.run("bun", ["run", script], {
+				cwd: localPath,
+				capture: true
+			});
+			if (exitCode !== 0) {
+				if (stdout.trim()) process.stdout.write(stdout);
+				if (stderr.trim()) process.stderr.write(stderr);
+				return {
+					status: "error",
+					key: input.key,
+					error: `Publish failed with exit code ${exitCode}`
+				};
+			}
+			if (stdout.trim()) process.stdout.write(stdout);
+			if (stderr.trim()) process.stderr.write(stderr);
+			const publishedUrl = extractPublishedUrl(`${stdout}\n${stderr}`);
+			if (publishedUrl) {
+				deps.bosConfig = {
+					...deps.bosConfig,
+					plugins: {
+						...deps.bosConfig.plugins ?? {},
+						[input.key]: {
+							...deps.bosConfig.plugins?.[input.key] ?? {},
+							production: publishedUrl
+						}
+					}
+				};
+				await saveBosConfig(deps.configDir, deps.bosConfig);
+				await refreshApiContractBridge(deps.configDir);
+			}
+			return {
+				status: "published",
+				key: input.key,
+				path: localPath,
+				script,
+				production: publishedUrl ?? attachment.production
+			};
+		}),
+		dev: builder.dev.handler(async ({ input }) => {
+			const localPackages = require_app.detectLocalPackages(deps.bosConfig ?? void 0, deps.runtimeConfig ?? void 0);
+			const appConfig = buildAppConfig({
+				host: localPackages.includes("host") ? input.host : "remote",
+				ui: localPackages.includes("ui") ? input.ui : "remote",
+				api: localPackages.includes("api") ? input.api : "remote",
+				proxy: input.proxy,
+				ssr: input.ssr
+			});
+			if ((await require_shared.syncAndGenerateSharedUi({
+				configDir: deps.configDir,
+				hostMode: appConfig.host,
+				bosConfig: deps.bosConfig ?? void 0
+			})).catalogChanged) await require_run.run("bun", ["install"], { cwd: deps.configDir });
+			if (appConfig.api === "local" && !appConfig.proxy || localPackages.some((pkg) => pkg.startsWith("plugin:"))) await buildEveryPluginQuietly(deps.configDir);
+			await buildEverythingDevQuietly(deps.configDir);
+			const refreshed = await require_config.loadConfig({ cwd: deps.configDir });
+			deps.bosConfig = refreshed?.config ?? deps.bosConfig;
+			deps.runtimeConfig = refreshed?.runtime ?? deps.runtimeConfig;
+			if (!deps.bosConfig) return {
+				status: "error",
+				description: "No bos.config.json found",
+				processes: []
+			};
+			if (appConfig.proxy && !resolveProxyUrl(deps.bosConfig)) return {
+				status: "error",
+				description: "No valid proxy URL configured in bos.config.json",
+				processes: []
+			};
+			const processes = determineProcesses(appConfig, require_app.detectLocalPackages(deps.bosConfig ?? void 0, deps.runtimeConfig ?? void 0), deps.runtimeConfig);
+			const env = await buildEnvVars(appConfig, deps.bosConfig);
+			const hostPort = input.port ?? require_config.getHostDevelopmentPort(deps.bosConfig.app.host.development);
+			const runtimeConfig = await require_app.prepareDevelopmentRuntimeConfig(require_app.buildRuntimeConfig(deps.bosConfig, {
+				uiSource: appConfig.ui,
+				apiSource: appConfig.api,
+				hostUrl: `http://localhost:${hostPort}`,
+				proxy: env.API_PROXY,
+				env: "development",
+				plugins: deps.runtimeConfig?.plugins
+			}), {
+				hostPort,
+				ssr: appConfig.ssr
+			});
+			await require_api_contract.syncApiContractBridge({
+				configDir: deps.configDir,
+				runtimeConfig,
+				apiBaseUrl: runtimeConfig.api.url
+			});
+			const orchestrator = {
+				packages: processes,
+				env,
+				description: buildDescription(appConfig),
+				appConfig,
+				bosConfig: deps.bosConfig,
+				runtimeConfig,
+				port: require_config.parsePort(runtimeConfig.hostUrl),
+				interactive: input.interactive
+			};
+			require_dev_session.startApp(orchestrator);
+			return {
+				status: "started",
+				description: orchestrator.description,
+				processes
+			};
+		}),
+		start: builder.start.handler(async ({ input }) => {
+			let remoteConfig = null;
+			if (input.account && input.domain) {
+				remoteConfig = await fetchPublishedConfig(input.account, input.domain);
+				if (!remoteConfig) return {
+					status: "error",
+					url: ""
+				};
+			}
+			const config = remoteConfig || deps.bosConfig;
+			if (!config) return {
+				status: "error",
+				url: ""
+			};
+			const port = input.port ?? require_config.getHostDevelopmentPort(config.app.host.development);
+			const appConfig = {
+				host: "remote",
+				ui: "remote",
+				api: "remote"
+			};
+			const env = await buildEnvVars(appConfig, config);
+			const isStaging = input.env === "staging";
+			const runtimePlugins = remoteConfig ? await require_config.buildRuntimePluginsForConfig(config, deps.configDir, "production") : deps.runtimeConfig?.plugins;
+			const runtimeConfig = require_app.buildRuntimeConfig(config, {
+				uiSource: "remote",
+				apiSource: "remote",
+				hostUrl: `http://localhost:${port}`,
+				env: "production",
+				plugins: runtimePlugins
+			});
+			await require_api_contract.syncApiContractBridge({
+				configDir: deps.configDir,
+				runtimeConfig,
+				apiBaseUrl: runtimeConfig.api.url
+			});
+			const stagingEnvVars = isStaging ? { GATEWAY_DOMAIN: config.staging?.domain ?? config.domain ?? "" } : {};
+			require_dev_session.startApp({
+				packages: ["host"],
+				env: {
+					NODE_ENV: "production",
+					...env,
+					...stagingEnvVars
+				},
+				description: `${isStaging ? "Staging" : "Production"} Mode (${config.account})`,
+				appConfig,
+				bosConfig: config,
+				runtimeConfig,
+				port,
+				interactive: input.interactive,
+				noLogs: true
+			});
+			return {
+				status: "running",
+				url: `http://localhost:${port}`
+			};
+		}),
+		build: builder.build.handler(async ({ input }) => {
+			if (!deps.bosConfig) return {
+				status: "error",
+				built: [],
+				skipped: []
+			};
+			const targets = selectWorkspaceTargets(input.packages, deps.bosConfig);
+			if (targets.length === 0) return {
+				status: "error",
+				built: [],
+				skipped: []
+			};
+			const runtimeConfig = require_app.buildRuntimeConfig(deps.bosConfig, {
+				uiSource: deps.bosConfig.app.ui?.development ? "local" : "remote",
+				apiSource: deps.bosConfig.app.api?.development ? "local" : "remote",
+				hostUrl: require_config.resolveDevelopmentHostUrl(deps.bosConfig.app.host.development),
+				env: "development",
+				plugins: deps.runtimeConfig?.plugins
+			});
+			await require_api_contract.syncApiContractBridge({
+				configDir: deps.configDir,
+				runtimeConfig,
+				apiBaseUrl: runtimeConfig.api.url
+			});
+			const { built, skipped } = await buildWorkspaceTargets({
+				configDir: deps.configDir,
+				bosConfig: deps.bosConfig,
+				runtimeConfig,
+				targets,
+				deploy: input.deploy
+			});
+			if (built.length === 0) return {
+				status: "error",
+				built: [],
+				skipped
+			};
+			return {
+				status: "success",
+				built,
+				skipped,
+				deployed: input.deploy
+			};
+		}),
+		publish: builder.publish.handler(async ({ input }) => {
+			if (!deps.bosConfig) return {
+				status: "error",
+				registryUrl: "",
+				error: "No bos.config.json found"
+			};
+			const account = deps.bosConfig.account;
+			const gateway = deps.bosConfig.domain;
+			if (!gateway) return {
+				status: "error",
+				registryUrl: "",
+				error: "bos.config.json must define domain to publish"
+			};
+			const network = input.network ?? require_network.getNetworkIdForAccount(account);
+			const bosUrl = `bos://${account}/${gateway}`;
+			const registryUrl = require_fastkv.buildRegistryConfigUrlForNetwork(network, account, gateway);
+			const targets = selectWorkspaceTargets(input.packages, deps.bosConfig);
+			let publishConfig = deps.bosConfig;
+			let built;
+			let skipped;
+			if (input.dryRun) return {
+				status: "dry-run",
+				registryUrl,
+				built,
+				skipped
+			};
+			if (input.deploy) {
+				const result = await buildWorkspaceTargets({
+					configDir: deps.configDir,
+					bosConfig: deps.bosConfig,
+					runtimeConfig: deps.runtimeConfig,
+					targets,
+					deploy: true
+				});
+				built = result.built;
+				skipped = result.skipped;
+				const refreshed = await require_config.loadConfig({ cwd: deps.configDir });
+				if (refreshed?.config) {
+					deps.bosConfig = refreshed.config;
+					deps.runtimeConfig = refreshed.runtime;
+					publishConfig = refreshed.config;
+				}
+			}
+			const payload = JSON.stringify({ [`apps/${account}/${gateway}/bos.config.json`]: JSON.stringify(publishConfig) });
+			const argsBase64 = Buffer.from(payload).toString("base64");
+			const privateKey = input.privateKey || process.env.NEAR_PRIVATE_KEY || process.env.BOS_NEAR_PRIVATE_KEY;
+			try {
+				await effect.Effect.runPromise(require_near_cli.ensureNearCli);
+				let txHash;
+				try {
+					txHash = (await effect.Effect.runPromise(require_near_cli.executeTransaction({
+						account,
+						contract: require_fastkv.getRegistryNamespaceForNetwork(network),
+						method: "__fastdata_kv",
+						argsBase64,
+						network,
+						privateKey,
+						gas: "300Tgas",
+						deposit: "0NEAR"
+					}))).txHash;
+				} catch (error) {
+					txHash = extractTransactionHash(error);
+					if (!txHash) throw error;
+					const verifiedConfig = await require_fastkv.fetchBosConfigFromFastKv(bosUrl);
+					if (JSON.stringify(verifiedConfig) !== JSON.stringify(publishConfig)) throw error;
+				}
+				return {
+					status: "published",
+					registryUrl,
+					txHash,
+					built,
+					skipped
+				};
+			} catch (error) {
+				return {
+					status: "error",
+					registryUrl,
+					error: error instanceof Error ? error.message : "Unknown error",
+					built,
+					skipped
+				};
+			}
+		}),
+		keyPublish: builder.keyPublish.handler(async ({ input }) => {
+			if (!deps.bosConfig) return {
+				status: "error",
+				account: "",
+				network: "mainnet",
+				contract: "",
+				allowance: input.allowance,
+				functionNames: PUBLISH_FUNCTION_NAMES,
+				error: "No bos.config.json found"
+			};
+			const account = deps.bosConfig.account;
+			const network = require_network.getNetworkIdForAccount(account);
+			const contract = require_fastkv.getRegistryNamespaceForAccount(account);
+			try {
+				await effect.Effect.runPromise(require_near_cli.ensureNearCli);
+				const keyPair = await require_near_cli.addFunctionCallAccessKey({
+					account,
+					contract,
+					allowance: input.allowance,
+					functionNames: PUBLISH_FUNCTION_NAMES,
+					network
+				});
+				return {
+					status: "published",
+					account,
+					network,
+					contract,
+					allowance: input.allowance,
+					functionNames: PUBLISH_FUNCTION_NAMES,
+					publicKey: keyPair.publicKey,
+					privateKey: keyPair.privateKey
+				};
+			} catch (error) {
+				return {
+					status: "error",
+					account,
+					network,
+					contract,
+					allowance: input.allowance,
+					functionNames: PUBLISH_FUNCTION_NAMES,
+					error: error instanceof Error ? error.message : "Unknown error"
+				};
+			}
+		}),
+		init: builder.init.handler(async ({ input }) => {
+			try {
+				let account = input.account;
+				let gateway = input.gateway;
+				let destination = input.destination;
+				let name = input.name;
+				let domain = input.domain;
+				let withHost = input.withHost;
+				if (!account || !gateway) {
+					if (input.noInteractive) return {
+						status: "error",
+						destination: "",
+						parentAccount: account ?? "",
+						parentGateway: gateway ?? "",
+						name: input.name,
+						domain: input.domain,
+						extends: account && gateway ? `bos://${account}/${gateway}` : "",
+						filesCopied: 0,
+						error: "account and gateway are required (use --no-interactive to skip prompts and provide them as positional args)"
+					};
+					const prompted = await require_prompts.promptInitOptions({
+						account,
+						gateway,
+						destination,
+						name,
+						domain,
+						withHost
+					});
+					account = prompted.account;
+					gateway = prompted.gateway;
+					destination = prompted.destination;
+					name = prompted.name;
+					domain = prompted.domain;
+					withHost = prompted.withHost;
+				}
+				destination = destination || gateway;
+				const { sourceDir, cleanup } = await require_cli_init.resolveSourceDir({
+					account,
+					gateway,
+					source: input.source
+				});
+				try {
+					const patterns = await require_cli_init.readTemplatekeep(sourceDir);
+					if (patterns.length === 0) return {
+						status: "error",
+						destination,
+						parentAccount: account,
+						parentGateway: gateway,
+						name,
+						domain,
+						extends: `bos://${account}/${gateway}`,
+						filesCopied: 0,
+						error: "No .templatekeep found in template source"
+					};
+					const filesCopied = await require_cli_init.copyFilteredFiles(sourceDir, destination, patterns, { withHost });
+					await require_cli_init.personalizeConfig(destination, {
+						parentAccount: account,
+						parentGateway: gateway,
+						name: name || account,
+						domain: domain || gateway,
+						workspaceOpts: { sourceDir }
+					});
+					if (!input.noInstall) await require_cli_init.runBunInstall(destination);
+					return {
+						status: "initialized",
+						destination: (0, node_path.resolve)(destination),
+						parentAccount: account,
+						parentGateway: gateway,
+						name,
+						domain,
+						extends: `bos://${account}/${gateway}`,
+						filesCopied
+					};
+				} finally {
+					await cleanup();
+				}
+			} catch (error) {
+				return {
+					status: "error",
+					destination: input.destination ?? input.gateway ?? "",
+					parentAccount: input.account ?? "",
+					parentGateway: input.gateway ?? "",
+					name: input.name,
+					domain: input.domain,
+					extends: input.account && input.gateway ? `bos://${input.account}/${input.gateway}` : "",
+					filesCopied: 0,
+					error: error instanceof Error ? error.message : "Unknown error"
+				};
+			}
+		})
+	})
+});
+function extractTransactionHash(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return (message.match(/Transaction ID:\s*([A-Za-z0-9]+)/i) || message.match(/([A-HJ-NP-Za-km-z1-9]{43,44})/))?.[1];
+}
+
+//#endregion
+module.exports = plugin_default;
+//# sourceMappingURL=plugin.cjs.map