paykitjs 0.0.1-alpha.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/init.js

@@ -0,0 +1,264 @@
+import { templates } from "../templates/index.js";
+import { defaultConfigPath, defaultRoutePath, detectPackageManager, getInstallCommand, isPackageInstalled, resolveImportPath } from "../utils/detect.js";
+import { capture } from "../utils/telemetry.js";
+import picocolors from "picocolors";
+import fs from "node:fs";
+import path from "node:path";
+import { Command } from "commander";
+import { execSync } from "node:child_process";
+import * as p from "@clack/prompts";
+//#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,71 @@
+import { checkStripe, createPool, formatProductDiffs, loadCliDeps, loadProductDiffs } from "../utils/shared.js";
+import picocolors from "picocolors";
+import path from "node:path";
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+//#region src/cli/commands/push.ts
+async function pushAction(options) {
+	const cwd = path.resolve(options.cwd);
+	const s = p.spinner();
+	s.start("Connecting");
+	const deps = await loadCliDeps();
+	deps.capture("cli_command", { command: "push" });
+	const config = await deps.getPayKitConfig({
+		configPath: options.config,
+		cwd
+	});
+	const database = createPool(deps, config.options.database);
+	try {
+		const connStr = deps.getConnectionString(database);
+		const [stripeResult, pendingMigrations] = await Promise.all([checkStripe(deps, config.options.provider.secretKey), deps.getPendingMigrationCount(database)]);
+		if (!stripeResult.account.ok) {
+			s.stop("");
+			p.log.error(`Stripe\n  ${picocolors.red("✖")} ${stripeResult.account.message}`);
+			p.cancel("Push failed");
+			process.exit(1);
+		}
+		if (pendingMigrations > 0) {
+			s.message("Applying migrations");
+			await deps.migrateDatabase(database);
+		}
+		s.message("Checking products");
+		const { ctx, diffs } = await loadProductDiffs(config, deps);
+		const hasChanges = diffs.some((d) => d.action !== "unchanged");
+		s.stop("");
+		const migrationStatus = pendingMigrations > 0 ? `${picocolors.green("✔")} Migrated (${String(pendingMigrations)} applied)` : `${picocolors.green("✔")} Schema up to date`;
+		p.log.info(`Database\n  ${picocolors.green("✔")} ${connStr}\n  ${migrationStatus}`);
+		p.log.info(`Stripe\n  ${picocolors.green("✔")} ${stripeResult.account.displayName} (${stripeResult.account.mode})`);
+		if (diffs.length > 0) {
+			const planLines = formatProductDiffs(diffs, ctx.plans.plans, deps);
+			p.log.info(`Products\n${planLines.join("\n")}`);
+		}
+		if (!hasChanges && pendingMigrations === 0) {
+			p.outro("Nothing to do");
+			return;
+		}
+		if (pendingMigrations > 0 && !hasChanges) {
+			p.outro("Done");
+			return;
+		}
+		const changeCount = diffs.filter((d) => d.action !== "unchanged").length;
+		if (!options.yes) {
+			const shouldContinue = await p.confirm({ message: `Push ${String(changeCount)} product change${changeCount === 1 ? "" : "s"} to Stripe?` });
+			if (p.isCancel(shouldContinue) || !shouldContinue) {
+				p.cancel("Aborted");
+				process.exit(0);
+			}
+		}
+		const syncedCount = (await deps.syncProducts(ctx)).filter((r) => r.action !== "unchanged").length;
+		p.outro(`Done ${picocolors.dim("·")} synced ${String(syncedCount)} product${syncedCount === 1 ? "" : "s"}`);
+	} 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 products 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/status.js

@@ -0,0 +1,84 @@
+import { checkDatabase, checkStripe, createPool, formatProductDiffs, loadCliDeps, loadProductDiffs } from "../utils/shared.js";
+import picocolors from "picocolors";
+import path from "node:path";
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+//#region src/cli/commands/status.ts
+async function statusAction(options) {
+	const cwd = path.resolve(options.cwd);
+	const s = p.spinner();
+	s.start("Checking");
+	const deps = await loadCliDeps();
+	deps.capture("cli_command", { command: "status" });
+	const pm = deps.detectPackageManager(cwd);
+	const pushCmd = deps.getRunCommand(pm, "paykitjs push");
+	let config;
+	try {
+		config = await deps.getPayKitConfig({
+			configPath: options.config,
+			cwd
+		});
+	} catch (error) {
+		s.stop("");
+		const message = error instanceof Error ? error.message : String(error);
+		p.log.error(`Config\n  ${picocolors.red("✖")} ${message}`);
+		process.exit(1);
+	}
+	const planCount = config.options.plans ? Object.values(config.options.plans).length : 0;
+	if (!Boolean(config.options.provider)) {
+		s.stop("");
+		p.log.error(`Config\n  ${picocolors.green("✔")} ${picocolors.dim(config.path)}\n  ${picocolors.green("✔")} ${String(planCount)} plan${planCount === 1 ? "" : "s"} defined\n  ${picocolors.red("✖")} No provider configured`);
+		p.outro("Fix config issues before continuing");
+		process.exit(1);
+	}
+	const database = createPool(deps, config.options.database);
+	const connStr = deps.getConnectionString(database);
+	const [dbResult, stripeResult] = await Promise.all([checkDatabase(database, deps), checkStripe(deps, config.options.provider.secretKey)]);
+	if (!dbResult.ok) {
+		s.stop("");
+		p.log.error(`Database\n  ${picocolors.red("✖")} ${connStr}\n  ${dbResult.message}`);
+		p.outro("Fix database issues before continuing");
+		await database.end();
+		process.exit(1);
+	}
+	if (!stripeResult.account.ok) {
+		s.stop("");
+		p.log.error(`Stripe\n  ${picocolors.red("✖")} ${stripeResult.account.message}`);
+		p.outro("Fix Stripe issues before continuing");
+		await database.end();
+		process.exit(1);
+	}
+	const pendingMigrations = dbResult.pendingMigrations;
+	let webhookStatus;
+	if (stripeResult.webhooks === null) webhookStatus = `${picocolors.dim("?")} Could not check webhook status`;
+	else if (stripeResult.webhooks.length > 0) webhookStatus = stripeResult.webhooks.map((ep) => picocolors.dim(`· Webhook endpoint registered (${ep.url})`)).join("\n  ");
+	else webhookStatus = picocolors.dim("· No webhook endpoint (use Stripe CLI for local testing)");
+	let needsSync = false;
+	let productsBlock;
+	if (pendingMigrations > 0) productsBlock = `Products\n  ${picocolors.dim("?")} Cannot check sync status until migrations are applied`;
+	else {
+		const { ctx, diffs } = await loadProductDiffs(config, deps);
+		if (diffs.length === 0) productsBlock = `Products\n  ${picocolors.dim("No products defined")}`;
+		else {
+			const allSynced = diffs.every((d) => d.action === "unchanged");
+			if (!allSynced) needsSync = true;
+			productsBlock = `Products\n  ${allSynced ? `${picocolors.green("✔")} All synced` : `${picocolors.red("✖")} Not synced (run ${picocolors.bold(pushCmd)})`}\n${formatProductDiffs(diffs, ctx.plans.plans, deps).join("\n")}`;
+		}
+	}
+	await database.end();
+	const migrationStatus = pendingMigrations > 0 ? `${picocolors.red("✖")} Schema needs migration` : `${picocolors.green("✔")} Schema up to date`;
+	s.stop("");
+	p.log.info(`Config\n  ${picocolors.green("✔")} ${picocolors.dim(config.path)}\n  ${picocolors.green("✔")} ${String(planCount)} plan${planCount === 1 ? "" : "s"} defined\n  ${picocolors.green("✔")} Stripe provider configured`);
+	p.log.info(`Database\n  ${picocolors.green("✔")} ${connStr}\n  ${migrationStatus}`);
+	p.log.info(`Stripe\n  ${picocolors.green("✔")} ${stripeResult.account.displayName} (${stripeResult.account.mode})\n  ${webhookStatus}`);
+	p.log.info(productsBlock);
+	const needsMigration = pendingMigrations > 0;
+	if (needsMigration || needsSync) {
+		const action = needsMigration && needsSync ? "apply migrations and sync products" : needsMigration ? "apply migrations" : "sync products";
+		p.outro(`Run ${picocolors.bold(pushCmd)} to ${action}`);
+		if (options.throw) process.exit(1);
+	} else p.outro("Everything looks good");
+}
+const statusCommand = new Command("status").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.").option("--throw", "exit with code 1 if there are issues").action(statusAction);
+//#endregion
+export { statusCommand };

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+//#region src/cli/index.ts
+process.env.PAYKIT_CLI = "1";
+const program = new Command().name("paykitjs").description("CLI for PayKit");
+const commandName = process.argv[2];
+switch (commandName) {
+	case "status": {
+		const { statusCommand } = await import("./commands/status.js");
+		program.addCommand(statusCommand);
+		break;
+	}
+	case "init": {
+		const { initCommand } = await import("./commands/init.js");
+		program.addCommand(initCommand);
+		break;
+	}
+	case "push": {
+		const { pushCommand } = await import("./commands/push.js");
+		program.addCommand(pushCommand);
+		break;
+	}
+	default: {
+		const [{ statusCommand }, { initCommand }, { pushCommand }] = await Promise.all([
+			import("./commands/status.js"),
+			import("./commands/init.js"),
+			import("./commands/push.js")
+		]);
+		program.addCommand(statusCommand);
+		program.addCommand(initCommand);
+		program.addCommand(pushCommand);
+	}
+}
+try {
+	await program.parseAsync(process.argv);
+} catch (error) {
+	const { captureError, flush } = await import("./utils/telemetry.js");
+	captureError(commandName ?? "unknown", error);
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(`\n  error: ${message}\n`);
+	await flush();
+	process.exit(1);
+}
+//#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,73 @@
+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 getRunCommand(pm, script) {
+	if (pm === "npm") return `npx ${script}`;
+	if (pm === "bun") return `bunx ${script}`;
+	if (pm === "yarn") return `yarn dlx ${script}`;
+	return `pnpm dlx ${script}`;
+}
+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, getRunCommand, hasTsconfigPathAlias, isPackageInstalled, resolveImportPath };