paykitjs 0.0.1

package/dist/api/methods.js

@@ -0,0 +1,67 @@
+import { customerPortal, deleteCustomer, getCustomer, listCustomersMethod, upsertCustomer } from "../customer/customer.api.js";
+import { check, report } from "../entitlement/entitlement.api.js";
+import { subscribe } from "../subscription/subscription.api.js";
+import { advanceTestClock, getTestClock } from "../testing/testing.api.js";
+import { receiveWebhook } from "../webhook/webhook.api.js";
+import { createRouter } from "better-call";
+//#region src/api/methods.ts
+const baseMethods = {
+	subscribe,
+	customerPortal,
+	upsertCustomer,
+	getCustomer,
+	deleteCustomer,
+	listCustomers: listCustomersMethod,
+	check,
+	report,
+	handleWebhook: receiveWebhook
+};
+const testingMethods = {
+	getTestClock,
+	advanceTestClock
+};
+const methods = {
+	...baseMethods,
+	...testingMethods
+};
+pickMethods(baseMethods);
+pickMethods(methods);
+function pickMethods(source) {
+	return Object.fromEntries(Object.entries(source).filter(([, method]) => method.client === true));
+}
+function wrapMethods(source, ctx) {
+	return Object.fromEntries(Object.entries(source).map(([key, method]) => {
+		const fn = async (input) => {
+			return method(await ctx, input);
+		};
+		if (method.endpoint) Object.assign(fn, {
+			options: method.endpoint.options,
+			path: method.endpoint.path
+		});
+		return [key, fn];
+	}));
+}
+function getRouteEndpoints(source) {
+	return Object.fromEntries(Object.entries(source).flatMap(([key, method]) => method.endpoint ? [[key, method.endpoint]] : []));
+}
+function isTestingEnabled(options) {
+	return options.testing?.enabled === true;
+}
+function getApi(ctx, options) {
+	return wrapMethods(isTestingEnabled(options) ? methods : baseMethods, ctx);
+}
+function createPayKitRouter(ctx, options) {
+	const pluginEndpoints = Object.assign({}, ...(options.plugins ?? []).map((plugin) => plugin.endpoints ?? {}));
+	return createRouter({
+		...getRouteEndpoints(isTestingEnabled(options) ? methods : baseMethods),
+		...pluginEndpoints
+	}, {
+		basePath: options.basePath ?? "/paykit/api",
+		routerContext: ctx,
+		onError(error) {
+			ctx.logger.error({ err: error }, "API error");
+		}
+	});
+}
+//#endregion
+export { createPayKitRouter, getApi };

package/dist/cli/commands/check.js

@@ -0,0 +1,92 @@
+import { dryRunSyncProducts } from "../../product/product-sync.service.js";
+import { getPendingMigrationCount } from "../../database/index.js";
+import { createContext } from "../../core/context.js";
+import { formatPlanLine, formatPrice, getConnectionString, getStripeAccountInfo } from "../utils/format.js";
+import { getPayKitConfig } from "../utils/get-config.js";
+import { capture } from "../utils/telemetry.js";
+import { Pool } from "pg";
+import path from "node:path";
+import StripeSdk from "stripe";
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import picocolors from "picocolors";
+//#region src/cli/commands/check.ts
+async function checkAction(options) {
+	const cwd = path.resolve(options.cwd);
+	p.intro("paykit check");
+	let config;
+	try {
+		config = await getPayKitConfig({
+			configPath: options.config,
+			cwd
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		p.log.error(`Config\n  ${picocolors.red("✖")} ${message}`);
+		p.outro("Fix config issues before continuing");
+		process.exit(1);
+	}
+	const planCount = config.options.plans ? Object.values(config.options.plans).length : 0;
+	const hasProvider = Boolean(config.options.provider);
+	p.log.info(`Config\n  ${picocolors.green("✔")} ${picocolors.dim(config.path)}\n  ${picocolors.green("✔")} ${String(planCount)} product${planCount === 1 ? "" : "s"} defined\n  ${hasProvider ? picocolors.green("✔") : picocolors.red("✖")} ${hasProvider ? "Stripe provider configured" : "No provider configured"}`);
+	if (!hasProvider) {
+		p.outro("Fix config issues before continuing");
+		process.exit(1);
+	}
+	const database = typeof config.options.database === "string" ? new Pool({ connectionString: config.options.database }) : config.options.database;
+	const connStr = getConnectionString(database);
+	let pendingMigrations = 0;
+	try {
+		await database.query("SELECT 1");
+		pendingMigrations = await getPendingMigrationCount(database);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		p.log.error(`Database\n  ${picocolors.red("✖")} ${connStr}\n  ${message}`);
+		p.outro("Fix database issues before continuing");
+		await database.end();
+		process.exit(1);
+	}
+	const migrationStatus = pendingMigrations > 0 ? `${picocolors.red("✖")} Schema needs migration` : `${picocolors.green("✔")} Schema up to date`;
+	p.log.info(`Database\n  ${picocolors.green("✔")} ${connStr}\n  ${migrationStatus}`);
+	const stripeAccount = await getStripeAccountInfo(config.options.provider.secretKey);
+	let webhookStatus;
+	try {
+		const activeEndpoints = (await new StripeSdk(config.options.provider.secretKey).webhookEndpoints.list({ limit: 100 })).data.filter((ep) => ep.status === "enabled");
+		if (activeEndpoints.length > 0) webhookStatus = activeEndpoints.map((ep) => picocolors.dim(`- Webhook endpoint registered (${ep.url})`)).join("\n  ");
+		else webhookStatus = picocolors.dim("- No webhook endpoint (use Stripe CLI for local testing)");
+	} catch {
+		webhookStatus = `${picocolors.dim("?")} Could not check webhook status`;
+	}
+	p.log.info(`Stripe\n  ${picocolors.green("✔")} ${stripeAccount.displayName} (${stripeAccount.mode})\n  ${webhookStatus}`);
+	let hasIssues = pendingMigrations > 0;
+	if (pendingMigrations > 0) p.log.info(`Products\n  ${picocolors.dim("?")} Cannot check sync status until migrations are applied`);
+	else {
+		const ctx = await createContext(config.options);
+		const diffs = await dryRunSyncProducts(ctx);
+		if (diffs.length === 0) p.log.info(`Products\n  ${picocolors.dim("No products defined")}`);
+		else {
+			const allSynced = diffs.every((d) => d.action === "unchanged");
+			if (!allSynced) hasIssues = true;
+			const header = allSynced ? `${picocolors.green("✔")} All synced` : `${picocolors.red("✖")} Not synced (run ${picocolors.bold("paykitjs push")})`;
+			const planLines = diffs.map((diff) => {
+				const plan = ctx.plans.plans.find((pl) => pl.id === diff.id);
+				const price = plan ? formatPrice(plan.priceAmount ?? 0, plan.priceInterval) : "$0";
+				return formatPlanLine(diff.action, diff.id, price);
+			});
+			p.log.info(`Products\n  ${header}\n${planLines.join("\n")}`);
+		}
+	}
+	capture("cli_command", {
+		command: "check",
+		needsMigration: pendingMigrations > 0
+	});
+	await database.end();
+	if (hasIssues) {
+		p.outro(`Run ${picocolors.bold("paykitjs push")} to apply migrations and sync plans`);
+		process.exit(1);
+	}
+	p.outro("Everything looks good");
+}
+const checkCommand = new Command("check").description("Check PayKit configuration and sync status").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("--config <config>", "the path to the PayKit configuration file to load.").action(checkAction);
+//#endregion
+export { checkCommand };

package/dist/cli/commands/init.js

@@ -0,0 +1,264 @@
+import { capture } from "../utils/telemetry.js";
+import { templates } from "../templates/index.js";
+import { defaultConfigPath, defaultRoutePath, detectPackageManager, getInstallCommand, isPackageInstalled, resolveImportPath } from "../utils/detect.js";
+import fs from "node:fs";
+import path from "node:path";
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import picocolors from "picocolors";
+import { execSync } from "node:child_process";
+//#region src/cli/commands/init.ts
+function ensureDir(filePath) {
+	const dir = path.dirname(filePath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+function generateConfigFile() {
+	return `import { stripe } from "@paykitjs/stripe";
+import { createPayKit } from "paykitjs";
+import { Pool } from "pg";
+
+import * as plans from "./paykit.plans";
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+export const paykit = createPayKit({
+  database: pool,
+  provider: stripe({
+    secretKey: process.env.STRIPE_SECRET_KEY!,
+    webhookSecret: process.env.STRIPE_WEBHOOK_SECRET!,
+  }),
+  plans,
+});
+`;
+}
+function generateRouteHandler(configPath, routePath, cwd) {
+	const configFullPath = path.join(cwd, configPath);
+	return `import { paykitHandler } from "paykitjs/handlers/next";
+
+import { paykit } from "${resolveImportPath(path.join(cwd, routePath), configFullPath, cwd)}";
+
+export const { GET, POST } = paykitHandler(paykit);
+`;
+}
+function generateClientFile(configPath, clientPath, cwd) {
+	const configFullPath = path.join(cwd, configPath);
+	return `import { createPayKitClient } from "paykitjs/client";
+
+import type { paykit } from "${resolveImportPath(path.join(cwd, clientPath), configFullPath, cwd)}";
+
+export const paykitClient = createPayKitClient<typeof paykit>();
+`;
+}
+function getEnvVarsToAdd(cwd) {
+	const envPath = path.join(cwd, ".env");
+	const existing = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf-8") : "";
+	return [
+		{
+			key: "DATABASE_URL",
+			comment: "# PostgreSQL connection string"
+		},
+		{
+			key: "STRIPE_SECRET_KEY",
+			comment: "# Stripe secret key (sk_test_... or sk_live_...)"
+		},
+		{
+			key: "STRIPE_WEBHOOK_SECRET",
+			comment: "# Stripe webhook secret (whsec_...)"
+		}
+	].filter((v) => !existing.includes(`${v.key}=`));
+}
+function writeEnvVars(cwd, vars) {
+	const envPath = path.join(cwd, ".env");
+	let content = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf-8") : "";
+	for (const v of vars) {
+		if (content.length > 0 && !content.endsWith("\n")) content += "\n";
+		content += `${v.comment}\n${v.key}=\n`;
+	}
+	fs.writeFileSync(envPath, content);
+}
+async function initAction(options) {
+	const cwd = path.resolve(options.cwd);
+	p.intro("paykit init");
+	p.log.info("Welcome to PayKit! Let's set up billing.");
+	const provider = await p.select({
+		message: "Select a payment provider",
+		options: [
+			{
+				value: "stripe",
+				label: "Stripe"
+			},
+			{
+				value: "polar",
+				label: "Polar",
+				hint: "coming soon",
+				disabled: true
+			},
+			{
+				value: "creem",
+				label: "Creem",
+				hint: "coming soon",
+				disabled: true
+			}
+		]
+	});
+	if (p.isCancel(provider)) {
+		p.cancel("Aborted");
+		process.exit(0);
+	}
+	const configDefault = defaultConfigPath(cwd);
+	const configPath = await p.text({
+		message: "Where should we create the PayKit config?",
+		defaultValue: configDefault,
+		placeholder: configDefault
+	});
+	if (p.isCancel(configPath)) {
+		p.cancel("Aborted");
+		process.exit(0);
+	}
+	const framework = await p.select({
+		message: "Framework",
+		options: [{
+			value: "nextjs",
+			label: "Next.js (App Router)"
+		}, {
+			value: "other",
+			label: "Other",
+			hint: "not yet supported"
+		}]
+	});
+	if (p.isCancel(framework)) {
+		p.cancel("Aborted");
+		process.exit(0);
+	}
+	let routePath = null;
+	if (framework === "nextjs") {
+		const routeDefault = defaultRoutePath(cwd);
+		const result = await p.text({
+			message: "Route handler path",
+			defaultValue: routeDefault,
+			placeholder: routeDefault
+		});
+		if (p.isCancel(result)) {
+			p.cancel("Aborted");
+			process.exit(0);
+		}
+		routePath = result;
+	}
+	const generateClient = await p.confirm({ message: "Generate a PayKit client?" });
+	if (p.isCancel(generateClient)) {
+		p.cancel("Aborted");
+		process.exit(0);
+	}
+	let clientPath = null;
+	if (generateClient) {
+		const clientDefault = "src/lib/paykit-client.ts";
+		const result = await p.text({
+			message: "Client file path",
+			defaultValue: clientDefault,
+			placeholder: clientDefault
+		});
+		if (p.isCancel(result)) {
+			p.cancel("Aborted");
+			process.exit(0);
+		}
+		clientPath = result;
+	}
+	const templateId = await p.select({
+		message: "Select a pricing template",
+		options: templates.map((t) => ({
+			value: t.id,
+			label: t.name,
+			hint: t.hint
+		}))
+	});
+	if (p.isCancel(templateId)) {
+		p.cancel("Aborted");
+		process.exit(0);
+	}
+	const toInstall = ["paykitjs", "@paykitjs/stripe"].filter((pkg) => !isPackageInstalled(cwd, pkg));
+	if (toInstall.length > 0) {
+		const installCmd = getInstallCommand(detectPackageManager(cwd), toInstall);
+		const spinner = p.spinner();
+		spinner.start(`Installing ${toInstall.join(", ")}`);
+		try {
+			execSync(installCmd, {
+				cwd,
+				stdio: "pipe",
+				env: {
+					...process.env,
+					NODE_ENV: ""
+				}
+			});
+			spinner.stop(`Installed ${toInstall.join(", ")}`);
+		} catch {
+			spinner.stop("Could not install automatically");
+			p.log.step(`Add to your package.json manually:\n  ${picocolors.dim(installCmd)}`);
+		}
+	} else p.log.step("Dependencies already installed");
+	const files = [];
+	const skipped = [];
+	const configFullPath = path.join(cwd, configPath);
+	if (fs.existsSync(configFullPath)) skipped.push(configPath);
+	else files.push({
+		path: configPath,
+		content: generateConfigFile()
+	});
+	const template = templates.find((t) => t.id === templateId);
+	if (template) {
+		const plansPath = configPath.replace(/paykit\.ts$/, "paykit.plans.ts");
+		const plansFullPath = path.join(cwd, plansPath);
+		if (fs.existsSync(plansFullPath)) skipped.push(plansPath);
+		else files.push({
+			path: plansPath,
+			content: template.content
+		});
+	}
+	if (routePath) {
+		const routeFullPath = path.join(cwd, routePath);
+		if (fs.existsSync(routeFullPath)) skipped.push(routePath);
+		else files.push({
+			path: routePath,
+			content: generateRouteHandler(configPath, routePath, cwd)
+		});
+	}
+	if (clientPath) {
+		const clientFullPath = path.join(cwd, clientPath);
+		if (fs.existsSync(clientFullPath)) skipped.push(clientPath);
+		else files.push({
+			path: clientPath,
+			content: generateClientFile(configPath, clientPath, cwd)
+		});
+	}
+	for (const file of files) {
+		const fullPath = path.join(cwd, file.path);
+		ensureDir(fullPath);
+		fs.writeFileSync(fullPath, file.content);
+	}
+	if (files.length > 0) {
+		const fileList = files.map((f) => `  ${picocolors.dim(f.path)}`).join("\n");
+		p.log.success(`Created ${String(files.length)} file${files.length === 1 ? "" : "s"}:\n${fileList}`);
+	}
+	if (skipped.length > 0) {
+		const skipList = skipped.map((f) => `  ${picocolors.dim(f)}`).join("\n");
+		p.log.step(`Skipped (already exist):\n${skipList}`);
+	}
+	const envVars = getEnvVarsToAdd(cwd);
+	if (envVars.length > 0) {
+		writeEnvVars(cwd, envVars);
+		const varList = envVars.map((v) => `  ${picocolors.dim(`${v.key}=`)}`).join("\n");
+		p.log.success(`Added to .env:\n${varList}`);
+	} else p.log.step("Environment variables already configured");
+	if (framework === "other") p.note("See the docs for manual route handler setup:\nhttps://paykitjs.com/docs/setup", "Manual Setup");
+	capture("cli_command", {
+		command: "init",
+		provider,
+		framework,
+		template: templateId,
+		filesCreated: files.length
+	});
+	p.note(`Fill in the variables in .env, then run:\n  ${picocolors.bold("paykitjs push")}\n\nFor local webhooks:\n  ${picocolors.dim("stripe listen --forward-to localhost:3000/api/paykit")}`, "Almost there!");
+	p.outro("Done");
+}
+const initCommand = new Command("init").description("Initialize PayKit in your project").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).action(initAction);
+//#endregion
+export { initCommand };

package/dist/cli/commands/push.js

@@ -0,0 +1,73 @@
+import { dryRunSyncProducts, syncProducts } from "../../product/product-sync.service.js";
+import { getPendingMigrationCount, migrateDatabase } from "../../database/index.js";
+import { createContext } from "../../core/context.js";
+import { formatPlanLine, formatPrice, getConnectionString, getStripeAccountInfo } from "../utils/format.js";
+import { getPayKitConfig } from "../utils/get-config.js";
+import { capture } from "../utils/telemetry.js";
+import { Pool } from "pg";
+import path from "node:path";
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import picocolors from "picocolors";
+//#region src/cli/commands/push.ts
+async function pushAction(options) {
+	const cwd = path.resolve(options.cwd);
+	p.intro("paykit push");
+	const config = await getPayKitConfig({
+		configPath: options.config,
+		cwd
+	});
+	const database = typeof config.options.database === "string" ? new Pool({ connectionString: config.options.database }) : config.options.database;
+	try {
+		const connStr = getConnectionString(database);
+		const stripeAccount = await getStripeAccountInfo(config.options.provider.secretKey);
+		p.log.info(`Connected\n  Database ${picocolors.dim("·")} ${connStr}\n  Stripe   ${picocolors.dim("·")} ${stripeAccount.displayName} (${stripeAccount.mode})`);
+		const pendingMigrations = await getPendingMigrationCount(database);
+		if (pendingMigrations > 0) {
+			await migrateDatabase(database);
+			p.log.success(`Schema ${picocolors.dim("·")} migrated`);
+		} else p.log.step(`Schema ${picocolors.dim("·")} up to date`);
+		const ctx = await createContext(config.options);
+		const planDiffs = await dryRunSyncProducts(ctx);
+		const hasPlanChanges = planDiffs.some((d) => d.action !== "unchanged");
+		if (planDiffs.length > 0) {
+			const planLines = planDiffs.map((diff) => {
+				const plan = ctx.plans.plans.find((pl) => pl.id === diff.id);
+				const price = plan ? formatPrice(plan.priceAmount ?? 0, plan.priceInterval) : "$0";
+				return formatPlanLine(diff.action, diff.id, price);
+			});
+			p.log.step(`Plan changes\n${planLines.join("\n")}`);
+		}
+		if (!hasPlanChanges && pendingMigrations === 0) {
+			p.outro("Nothing to do");
+			return;
+		}
+		if (hasPlanChanges && !options.yes) {
+			const shouldContinue = await p.confirm({ message: "Sync plans?" });
+			if (p.isCancel(shouldContinue) || !shouldContinue) {
+				p.cancel("Aborted");
+				process.exit(0);
+			}
+		}
+		const results = await syncProducts(ctx);
+		const syncedCount = results.filter((r) => r.action !== "unchanged").length;
+		if (syncedCount > 0) p.log.success("Plans synced");
+		capture("cli_command", {
+			command: "push",
+			migrated: pendingMigrations > 0,
+			planCount: results.length,
+			plansSynced: syncedCount
+		});
+		p.outro(`Done ${picocolors.dim("·")} ${String(results.length)} plan${results.length === 1 ? "" : "s"} synced`);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		p.log.error(message);
+		p.cancel("Push failed");
+		process.exit(1);
+	} finally {
+		await database.end();
+	}
+}
+const pushCommand = new Command("push").description("Apply migrations and sync plans to database and payment provider").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("--config <config>", "the path to the PayKit configuration file to load.").option("-y, --yes", "skip confirmation prompt").action(pushAction);
+//#endregion
+export { pushCommand };

package/dist/cli/commands/telemetry.js

@@ -0,0 +1,16 @@
+import { setEnabled } from "../utils/telemetry.js";
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+//#region src/cli/commands/telemetry.ts
+const telemetryCommand = new Command("telemetry").description("Manage anonymous telemetry").addCommand(new Command("enable").description("Enable anonymous telemetry").action(() => {
+	setEnabled(true);
+	p.log.success("Telemetry enabled");
+})).addCommand(new Command("disable").description("Disable anonymous telemetry").action(() => {
+	setEnabled(false);
+	p.log.success("Telemetry disabled");
+})).addCommand(new Command("status").description("Check telemetry status").action(() => {
+	if (process.env.PAYKIT_TELEMETRY_DISABLED === "1" || process.env.DO_NOT_TRACK === "1") p.log.info("Telemetry is disabled (via environment variable)");
+	else p.log.info("Run `paykitjs telemetry disable` to opt out");
+}));
+//#endregion
+export { telemetryCommand };

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/cli/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { captureError, flush } from "./utils/telemetry.js";
+import { checkCommand } from "./commands/check.js";
+import { initCommand } from "./commands/init.js";
+import { pushCommand } from "./commands/push.js";
+import { telemetryCommand } from "./commands/telemetry.js";
+import { Command } from "commander";
+//#region src/cli/index.ts
+const program = new Command().name("paykitjs").description("CLI for PayKit").addCommand(checkCommand).addCommand(initCommand).addCommand(pushCommand).addCommand(telemetryCommand);
+try {
+	await program.parseAsync(process.argv);
+} catch (error) {
+	captureError(process.argv[2] ?? "unknown", error);
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(`\n  error: ${message}\n`);
+	await flush();
+	process.exit(1);
+}
+await flush();
+//#endregion
+export {};

package/dist/cli/templates/index.js

@@ -0,0 +1,64 @@
+//#region src/cli/templates/index.ts
+const templates = [
+	{
+		id: "saas-starter",
+		name: "SaaS Starter",
+		hint: "free + pro monthly",
+		content: `import { plan } from "paykitjs";
+
+export const free = plan({
+  id: "free",
+  name: "Free",
+  group: "base",
+  default: true,
+});
+
+export const pro = plan({
+  id: "pro",
+  name: "Pro",
+  group: "base",
+  price: { amount: 29, interval: "month" },
+});
+`
+	},
+	{
+		id: "usage-based",
+		name: "Usage Based",
+		hint: "metered with limits",
+		content: `import { feature, plan } from "paykitjs";
+
+const messages = feature({ id: "messages", type: "metered" });
+
+export const free = plan({
+  id: "free",
+  name: "Free",
+  group: "base",
+  default: true,
+  includes: [messages({ limit: 100, reset: "month" })],
+});
+
+export const pro = plan({
+  id: "pro",
+  name: "Pro",
+  group: "base",
+  price: { amount: 29, interval: "month" },
+  includes: [messages({ limit: 5000, reset: "month" })],
+});
+`
+	},
+	{
+		id: "empty",
+		name: "Empty",
+		hint: "start from scratch",
+		content: `import { plan } from "paykitjs";
+
+// export const myPlan = plan({
+//   id: "my-plan",
+//   name: "My Plan",
+//   price: { amount: 29, interval: "month" },
+// });
+`
+	}
+];
+//#endregion
+export { templates };

package/dist/cli/utils/detect.js

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/cli/utils/detect.ts
+function detectPackageManager(cwd) {
+	const userAgent = process.env.npm_config_user_agent ?? "";
+	if (userAgent.startsWith("pnpm")) return "pnpm";
+	if (userAgent.startsWith("yarn")) return "yarn";
+	if (userAgent.startsWith("bun")) return "bun";
+	let dir = cwd;
+	while (true) {
+		if (fs.existsSync(path.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+		if (fs.existsSync(path.join(dir, "yarn.lock"))) return "yarn";
+		if (fs.existsSync(path.join(dir, "bun.lockb")) || fs.existsSync(path.join(dir, "bun.lock"))) return "bun";
+		if (fs.existsSync(path.join(dir, "package-lock.json"))) return "npm";
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return "npm";
+}
+function getInstallCommand(pm, packages) {
+	return `${pm === "npm" ? "npm install" : `${pm} add`} ${packages.join(" ")}`;
+}
+function isPackageInstalled(cwd, name) {
+	const pkgPath = path.join(cwd, "package.json");
+	if (!fs.existsSync(pkgPath)) return false;
+	try {
+		const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+		return Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
+	} catch {
+		return false;
+	}
+}
+function hasTsconfigPathAlias(cwd) {
+	const tsconfigPath = path.join(cwd, "tsconfig.json");
+	if (!fs.existsSync(tsconfigPath)) return false;
+	try {
+		const stripped = fs.readFileSync(tsconfigPath, "utf-8").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+		const tsconfig = JSON.parse(stripped);
+		return Boolean(tsconfig.compilerOptions?.paths?.["@/*"]);
+	} catch {
+		return false;
+	}
+}
+function resolveImportPath(fromFile, toFile, cwd) {
+	if (hasTsconfigPathAlias(cwd)) {
+		const srcRelative = path.relative(path.join(cwd, "src"), toFile);
+		if (!srcRelative.startsWith("..")) return "@/" + srcRelative.replace(/\.tsx?$/, "");
+	}
+	const fromDir = path.dirname(fromFile);
+	let relative = path.relative(fromDir, toFile).replace(/\.tsx?$/, "");
+	if (!relative.startsWith(".")) relative = "./" + relative;
+	return relative;
+}
+function defaultConfigPath(cwd) {
+	if (fs.existsSync(path.join(cwd, "src", "server"))) return "src/server/paykit.ts";
+	if (fs.existsSync(path.join(cwd, "src", "lib"))) return "src/lib/paykit.ts";
+	if (fs.existsSync(path.join(cwd, "src"))) return "src/paykit.ts";
+	return "paykit.ts";
+}
+function defaultRoutePath(cwd) {
+	if (fs.existsSync(path.join(cwd, "src", "app"))) return "src/app/paykit/api/[...slug]/route.ts";
+	if (fs.existsSync(path.join(cwd, "app"))) return "app/paykit/api/[...slug]/route.ts";
+	return "src/app/paykit/api/[...slug]/route.ts";
+}
+//#endregion
+export { defaultConfigPath, defaultRoutePath, detectPackageManager, getInstallCommand, isPackageInstalled, resolveImportPath };