dineway 0.1.3 → 0.1.5

package/dist/cli/index.mjs

@@ -1,20 +1,21 @@
 #!/usr/bin/env node
 import { t as __exportAll } from "../chunk-ClPoSABd.mjs";
-import { n as createDatabase } from "../connection-C9pxzuag.mjs";
-import { s as listTablesLike } from "../dialect-helpers-B9uSp2GJ.mjs";
-import { r as runMigrations, t as getMigrationStatus } from "../runner-BGUGywgG.mjs";
-import { t as ContentRepository } from "../content-zSgdNmnt.mjs";
+import { n as createDatabase } from "../connection-BCNICDWN.mjs";
+import { s as listTablesLike } from "../dialect-helpers-DhTzaUxP.mjs";
+import { r as runMigrations, t as getMigrationStatus } from "../runner-DWZm2KQm.mjs";
+import { t as ContentRepository } from "../content-DWi4d0rT.mjs";
 import { i as encodeBase64url } from "../base64-F8-DUraK.mjs";
 import "../types-BawVha09.mjs";
 import { t as MediaRepository } from "../media-DMTr80Gv.mjs";
-import { f as OptionsRepository, p as TaxonomyRepository, t as applySeed } from "../apply-CAPvMfoU.mjs";
-import { n as SchemaRegistry } from "../registry-DSd1GWB8.mjs";
-import "../redirect-JPqLAbxa.mjs";
-import "../byline-DeWCMU_i.mjs";
-import { r as isI18nEnabled } from "../config-Cq8H0SfX.mjs";
-import "../loader-qKmo0wAY.mjs";
-import { i as pluginManifestSchema } from "../manifest-schema-CTSEyIJ3.mjs";
-import { t as validateSeed } from "../validate-CXnRKfJK.mjs";
+import { m as TaxonomyRepository, p as OptionsRepository, t as applySeed } from "../apply-iVSqz2qs.mjs";
+import "../redirect-DnEWAkVg.mjs";
+import "../byline-OhH2dlRu.mjs";
+import { r as isI18nEnabled } from "../config-BXwuX8Bx.mjs";
+import { n as SchemaRegistry } from "../registry-C0zjeB9P.mjs";
+import "../loader-sMG4TZ-u.mjs";
+import "../request-cache-Dk5qPSOx.mjs";
+import { i as pluginManifestSchema } from "../manifest-schema-D1MSVnoI.mjs";
+import { t as validateSeed } from "../validate-BZ5wnLLp.mjs";
 import { LocalStorage } from "../storage/local.mjs";
 import { createHeaderAwareFetch, customHeadersInterceptor, isRedirectResponse, resolveCustomHeaders } from "../client/external-auth-headers.mjs";
 import { DinewayClient } from "../client/index.mjs";
@@ -28,6 +29,7 @@ import { defineCommand, runCommand, runMain } from "citty";
 import consola, { consola as consola$1 } from "consola";
 import pc from "picocolors";
 import { homedir } from "node:os";
+import { createInterface } from "node:readline/promises";
 import { spawn } from "node:child_process";
 import { pipeline } from "node:stream/promises";
 import { packTar } from "modern-tar/fs";
@@ -648,12 +650,16 @@ const publishCommand$1 = defineCommand({
 			description: "Content item ID or slug",
 			required: true
 		},
+		"review-request-id": {
+			type: "string",
+			description: "Approved review request ID for token-authenticated publish"
+		},
 		...connectionArgs
 	},
 	async run({ args }) {
 		configureOutputMode(args);
 		try {
-			await createClientFromArgs(args).publish(args.collection, args.id);
+			await createClientFromArgs(args).publish(args.collection, args.id, { reviewRequestId: args["review-request-id"] });
 			consola$1.success(`Published ${args.collection}/${args.id}`);
 		} catch (error) {
 			consola$1.error(error instanceof Error ? error.message : "Unknown error");
@@ -800,6 +806,918 @@ const contentCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/cli/commands/deploy/utils/dockerfile.ts
+const NODE_START_COMMAND = "node ./dist/server/entry.mjs";
+const HEALTH_CHECK_PATH = "/_dineway/api/health";
+function generateDockerfile() {
+	return `FROM node:22-bookworm-slim AS dependencies
+WORKDIR /app
+RUN corepack enable
+COPY . .
+RUN if [ -f pnpm-lock.yaml ]; then pnpm install --frozen-lockfile; \\
+\telif [ -f yarn.lock ]; then yarn install --frozen-lockfile; \\
+\telif [ -f bun.lock ] || [ -f bun.lockb ]; then npm install --global bun && bun install --frozen-lockfile; \\
+\telif [ -f package-lock.json ]; then npm ci; \\
+\telse npm install; fi
+
+FROM dependencies AS builder
+RUN mkdir -p public seed
+RUN if [ -f pnpm-lock.yaml ]; then pnpm build; \\
+\telif [ -f yarn.lock ]; then yarn build; \\
+\telif [ -f bun.lock ] || [ -f bun.lockb ]; then bun run build; \\
+\telse npm run build; fi
+
+FROM node:22-bookworm-slim AS runner
+WORKDIR /app
+ENV HOST=0.0.0.0
+ENV PORT=4321
+ENV NODE_ENV=production
+COPY --from=builder /app/package.json ./package.json
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/public ./public
+COPY --from=builder /app/seed ./seed
+EXPOSE 4321
+HEALTHCHECK --interval=30s --timeout=5s --start-period=30s --retries=3 CMD ["node", "-e", "fetch('http://127.0.0.1:' + (process.env.PORT || '4321') + '${HEALTH_CHECK_PATH}').then((r) => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"]
+CMD ["node", "./dist/server/entry.mjs"]
+`;
+}
+function generateDockerignore() {
+	return `.astro
+.dineway
+.env
+.env.*
+.git
+.github
+.plan
+dist
+node_modules
+uploads
+data
+*.db
+*.db-*
+npm-debug.log*
+pnpm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+`;
+}
+function generateDockerCompose() {
+	return `services:
+  dineway:
+    build: .
+    ports:
+      - "4321:4321"
+    environment:
+      HOST: 0.0.0.0
+      PORT: 4321
+      DINEWAY_DATABASE_URL: file:./data/dineway.db
+      DINEWAY_AUTH_SECRET: \${DINEWAY_AUTH_SECRET}
+      DINEWAY_PREVIEW_SECRET: \${DINEWAY_PREVIEW_SECRET}
+    volumes:
+      - dineway-data:/app/data
+    healthcheck:
+      test: ["CMD", "node", "-e", "fetch('http://127.0.0.1:4321${HEALTH_CHECK_PATH}').then((r) => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+      start_period: 30s
+    restart: unless-stopped
+
+volumes:
+  dineway-data:
+`;
+}
+
+//#endregion
+//#region src/cli/commands/deploy/targets/docker.ts
+async function fileExists$9(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function writeGeneratedFile$2(cwd, relativePath, content, dryRun) {
+	const path = join(cwd, relativePath);
+	if (await fileExists$9(path)) return {
+		path: relativePath,
+		action: "exists"
+	};
+	if (dryRun) return {
+		path: relativePath,
+		action: "skipped"
+	};
+	await writeFile(path, content, "utf-8");
+	return {
+		path: relativePath,
+		action: "created"
+	};
+}
+const dockerTarget = {
+	name: "docker",
+	label: "Docker",
+	description: "Generate Docker deployment files without running Docker locally.",
+	supportLevel: "stable",
+	async generateConfig(cwd, options) {
+		const files = [await writeGeneratedFile$2(cwd, "Dockerfile", generateDockerfile(), options.dryRun), await writeGeneratedFile$2(cwd, ".dockerignore", generateDockerignore(), options.dryRun)];
+		if (options.compose) files.push(await writeGeneratedFile$2(cwd, "docker-compose.yml", generateDockerCompose(), options.dryRun));
+		return files;
+	},
+	async deploy(_cwd, options) {
+		if (options.dryRun) return { message: options.compose ? "[dry-run] Would generate Dockerfile, .dockerignore, and docker-compose.yml." : "[dry-run] Would generate Dockerfile and .dockerignore." };
+		return { message: options.compose ? "Generated Dockerfile, .dockerignore, and docker-compose.yml." : "Generated Dockerfile and .dockerignore." };
+	}
+};
+
+//#endregion
+//#region src/cli/commands/deploy/utils/spawn.ts
+async function runCommand$1(command, args, options) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd: options.cwd,
+			env: {
+				...process.env,
+				...options.env
+			},
+			stdio: options.stdio === "inherit" ? "inherit" : [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			shell: false
+		});
+		let stdout = "";
+		let stderr = "";
+		if (options.stdio !== "inherit") {
+			child.stdout?.on("data", (chunk) => {
+				stdout += chunk.toString();
+			});
+			child.stderr?.on("data", (chunk) => {
+				stderr += chunk.toString();
+			});
+		}
+		child.on("error", reject);
+		child.on("close", (code) => {
+			resolve({
+				code: code ?? 0,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+async function runCommandOrThrow(command, args, options) {
+	const result = await runCommand$1(command, args, options);
+	if (result.code !== 0) {
+		const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+		throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/cli/commands/deploy/targets/fly.ts
+const FLY_URL_RE = /https:\/\/[^\s"]+\.fly\.dev[^\s"]*/;
+const FLY_HOST_RE = /\b[a-z0-9][a-z0-9-]*\.fly\.dev\b/;
+const INVALID_FLY_APP_CHARS_RE = /[^a-z0-9-]+/g;
+const REPEATED_HYPHENS_RE$1 = /-+/g;
+const EDGE_HYPHENS_RE$1 = /^-|-$/g;
+const LINE_SPLIT_RE = /\r?\n/;
+const DEFAULT_REGION$1 = "iad";
+const FLY_VOLUME_NAME = "dineway_data";
+async function fileExists$8(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function writeGeneratedFile$1(cwd, relativePath, content, dryRun) {
+	const path = join(cwd, relativePath);
+	if (await fileExists$8(path)) return {
+		path: relativePath,
+		action: "exists"
+	};
+	if (dryRun) return {
+		path: relativePath,
+		action: "skipped"
+	};
+	await writeFile(path, content, "utf-8");
+	return {
+		path: relativePath,
+		action: "created"
+	};
+}
+async function readPackageName$1(cwd) {
+	try {
+		return JSON.parse(await readFile(join(cwd, "package.json"), "utf-8")).name;
+	} catch {
+		return;
+	}
+}
+function normalizeFlyAppName(name) {
+	return (name?.split("/").at(-1) ?? "dineway-app").toLowerCase().replace(INVALID_FLY_APP_CHARS_RE, "-").replace(REPEATED_HYPHENS_RE$1, "-").replace(EDGE_HYPHENS_RE$1, "") || "dineway-app";
+}
+async function defaultFlyAppName(cwd) {
+	return normalizeFlyAppName(await readPackageName$1(cwd));
+}
+function parseFlyTomlValue(toml, key) {
+	return toml.match(new RegExp(`^\\s*${key}\\s*=\\s*"([^"]+)"`, "m"))?.[1];
+}
+async function readFlyConfig(cwd) {
+	try {
+		const toml = await readFile(join(cwd, "fly.toml"), "utf-8");
+		return {
+			app: parseFlyTomlValue(toml, "app"),
+			region: parseFlyTomlValue(toml, "primary_region"),
+			hasMount: toml.includes(`source = "${FLY_VOLUME_NAME}"`)
+		};
+	} catch {
+		return { hasMount: false };
+	}
+}
+function generateFlyToml(app, region = DEFAULT_REGION$1) {
+	return `app = "${app}"
+primary_region = "${region}"
+
+[build]
+  dockerfile = "Dockerfile"
+
+[env]
+  HOST = "0.0.0.0"
+  PORT = "4321"
+  DINEWAY_DATABASE_URL = "file:./data/dineway.db"
+
+[[mounts]]
+  source = "${FLY_VOLUME_NAME}"
+  destination = "/app/data"
+
+[http_service]
+  internal_port = 4321
+  force_https = true
+  auto_stop_machines = "stop"
+  auto_start_machines = true
+  min_machines_running = 1
+
+[checks]
+  [checks.dineway_liveness]
+    grace_period = "30s"
+    interval = "30s"
+    method = "get"
+    path = "${HEALTH_CHECK_PATH}"
+    port = 4321
+    timeout = "5s"
+    type = "http"
+`;
+}
+function parseFlyUrl(stdout) {
+	const direct = stdout.match(FLY_URL_RE);
+	if (direct) return direct[0];
+	for (const line of stdout.split(LINE_SPLIT_RE).filter(Boolean)) try {
+		const url = findFlyUrl(JSON.parse(line));
+		if (url) return url;
+	} catch {
+		const host = line.match(FLY_HOST_RE);
+		if (host) return `https://${host[0]}`;
+	}
+}
+function findFlyUrl(value) {
+	if (typeof value === "string") {
+		if (value.startsWith("https://") && value.includes(".fly.dev")) return value;
+		if (FLY_HOST_RE.test(value)) return `https://${value.match(FLY_HOST_RE)?.[0]}`;
+		return;
+	}
+	if (!value || typeof value !== "object") return void 0;
+	for (const item of Object.values(value)) {
+		const found = findFlyUrl(item);
+		if (found) return found;
+	}
+}
+function volumeExists(stdout, volumeName) {
+	try {
+		return findVolumeName(JSON.parse(stdout), volumeName);
+	} catch {
+		return stdout.includes(volumeName);
+	}
+}
+function findVolumeName(value, volumeName) {
+	if (typeof value === "string") return value === volumeName;
+	if (!value || typeof value !== "object") return false;
+	return Object.values(value).some((item) => findVolumeName(item, volumeName));
+}
+async function ensureVolume(cwd) {
+	const config = await readFlyConfig(cwd);
+	if (!config.hasMount) return;
+	const result = await runCommand$1("fly", [
+		"volumes",
+		"list",
+		"--json"
+	], { cwd });
+	if (result.code === 0 && volumeExists(result.stdout, FLY_VOLUME_NAME)) return;
+	const region = config.region ?? DEFAULT_REGION$1;
+	throw new Error(`Fly volume "${FLY_VOLUME_NAME}" is required for file-backed Dineway data. Create it with: fly volumes create ${FLY_VOLUME_NAME} --region ${region} --size 1`);
+}
+const flyTarget = {
+	name: "fly",
+	label: "fly.io",
+	description: "Deploy with flyctl and the Fly remote builder.",
+	supportLevel: "stable",
+	cli: {
+		npmPackage: null,
+		binary: "fly",
+		versionCommand: {
+			command: "fly",
+			args: ["version"]
+		},
+		installHint: "Install flyctl from https://fly.io/docs/flyctl/install/"
+	},
+	async checkAuth(cwd) {
+		return (await runCommand$1("fly", ["auth", "whoami"], { cwd })).code === 0;
+	},
+	async login(cwd) {
+		await runCommandOrThrow("fly", ["auth", "login"], {
+			cwd,
+			stdio: "inherit"
+		});
+	},
+	async isLinked(cwd) {
+		return (await runCommand$1("fly", ["status"], { cwd })).code === 0;
+	},
+	async link(cwd) {
+		await runCommandOrThrow("fly", [
+			"launch",
+			"--no-deploy",
+			"--copy-config",
+			"--dockerfile",
+			"Dockerfile",
+			"--no-github-workflow",
+			"--no-db",
+			"--no-object-storage"
+		], {
+			cwd,
+			stdio: "inherit"
+		});
+	},
+	async generateConfig(cwd, options) {
+		return [
+			await writeGeneratedFile$1(cwd, "Dockerfile", generateDockerfile(), options.dryRun),
+			await writeGeneratedFile$1(cwd, ".dockerignore", generateDockerignore(), options.dryRun),
+			await writeGeneratedFile$1(cwd, "fly.toml", generateFlyToml(await defaultFlyAppName(cwd)), options.dryRun)
+		];
+	},
+	async deploy(cwd, options) {
+		if (options.dryRun) return { message: "[dry-run] Would run fly deploy --remote-only." };
+		await ensureVolume(cwd);
+		await runCommandOrThrow("fly", ["deploy", "--remote-only"], {
+			cwd,
+			env: options.env,
+			stdio: "inherit"
+		});
+		const status = await runCommand$1("fly", ["status", "--json"], { cwd }).catch(() => null);
+		const url = status ? parseFlyUrl(status.stdout) : void 0;
+		return {
+			url,
+			message: url ? `Deploy complete: ${url}` : "Deploy complete. Check Fly dashboard for URL."
+		};
+	}
+};
+
+//#endregion
+//#region src/cli/commands/deploy/targets/gcp.ts
+const CLOUD_RUN_URL_RE = /https:\/\/[^\s"]+\.run\.app[^\s"]*/;
+const INVALID_SERVICE_CHARS_RE = /[^a-z0-9-]+/g;
+const REPEATED_HYPHENS_RE = /-+/g;
+const EDGE_HYPHENS_RE = /^-|-$/g;
+const DEFAULT_REGION = "us-central1";
+const GCLOUDIGNORE = `.env
+.env.*
+.git
+.github
+.plan
+.astro
+.dineway
+node_modules
+dist
+uploads
+data
+*.db
+*.db-*
+npm-debug.log*
+pnpm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+`;
+async function fileExists$7(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function writeGeneratedFile(cwd, relativePath, content, dryRun) {
+	const path = join(cwd, relativePath);
+	if (await fileExists$7(path)) return {
+		path: relativePath,
+		action: "exists"
+	};
+	if (dryRun) return {
+		path: relativePath,
+		action: "skipped"
+	};
+	await writeFile(path, content, "utf-8");
+	return {
+		path: relativePath,
+		action: "created"
+	};
+}
+async function readPackageName(cwd) {
+	try {
+		return JSON.parse(await readFile(join(cwd, "package.json"), "utf-8")).name;
+	} catch {
+		return;
+	}
+}
+function normalizeCloudRunServiceName(name) {
+	return (name?.split("/").at(-1) ?? "dineway").toLowerCase().replace(INVALID_SERVICE_CHARS_RE, "-").replace(REPEATED_HYPHENS_RE, "-").replace(EDGE_HYPHENS_RE, "") || "dineway";
+}
+function resolveEnvValue(env, key) {
+	return env?.[key] ?? process.env[key];
+}
+async function resolveServiceName(cwd, env) {
+	return resolveEnvValue(env, "DINEWAY_GCP_SERVICE") || resolveEnvValue(env, "CLOUD_RUN_SERVICE") || normalizeCloudRunServiceName(await readPackageName(cwd));
+}
+function resolveRegion(env) {
+	return resolveEnvValue(env, "DINEWAY_GCP_REGION") || resolveEnvValue(env, "GOOGLE_CLOUD_REGION") || resolveEnvValue(env, "CLOUDSDK_RUN_REGION") || DEFAULT_REGION;
+}
+function parseCloudRunUrl(stdout) {
+	return stdout.match(CLOUD_RUN_URL_RE)?.[0];
+}
+function assertCloudRunStorageEnv(env) {
+	const databaseUrl = resolveEnvValue(env, "DINEWAY_DATABASE_URL");
+	if (!databaseUrl || databaseUrl.startsWith("file:")) throw new Error("Cloud Run requires a remote DINEWAY_DATABASE_URL such as libSQL HTTP or PostgreSQL. File-backed libSQL is not supported on Cloud Run's ephemeral filesystem.");
+}
+function buildDeployArgs(service, region) {
+	return [
+		"run",
+		"deploy",
+		service,
+		"--source",
+		".",
+		"--region",
+		region,
+		"--port",
+		"4321",
+		"--allow-unauthenticated",
+		"--set-build-env-vars",
+		"GOOGLE_NODE_RUN_SCRIPTS=build",
+		"--update-env-vars",
+		"HOST=0.0.0.0",
+		"--liveness-probe",
+		`httpGet.path=${HEALTH_CHECK_PATH},httpGet.port=4321,initialDelaySeconds=30,timeoutSeconds=5,periodSeconds=30,failureThreshold=3`
+	];
+}
+async function describeServiceUrl(cwd, service, region, env) {
+	const result = await runCommand$1("gcloud", [
+		"run",
+		"services",
+		"describe",
+		service,
+		"--region",
+		region,
+		"--format",
+		"value(status.url)"
+	], {
+		cwd,
+		env
+	}).catch(() => null);
+	if (!result || result.code !== 0) return void 0;
+	return parseCloudRunUrl(result.stdout) ?? (result.stdout.trim() || void 0);
+}
+const gcpTarget = {
+	name: "gcp",
+	label: "GCP Cloud Run",
+	description: "Deploy to Cloud Run from local source with gcloud.",
+	supportLevel: "experimental",
+	cli: {
+		npmPackage: null,
+		binary: "gcloud",
+		versionCommand: {
+			command: "gcloud",
+			args: ["--version"]
+		},
+		installHint: "Install the Google Cloud CLI from https://cloud.google.com/sdk/docs/install"
+	},
+	async checkAuth(cwd) {
+		const result = await runCommand$1("gcloud", [
+			"auth",
+			"list",
+			"--filter=status:ACTIVE",
+			"--format",
+			"value(account)"
+		], { cwd });
+		return result.code === 0 && result.stdout.trim().length > 0;
+	},
+	async login(cwd) {
+		await runCommandOrThrow("gcloud", ["auth", "login"], {
+			cwd,
+			stdio: "inherit"
+		});
+	},
+	async isLinked(cwd) {
+		const result = await runCommand$1("gcloud", [
+			"config",
+			"get-value",
+			"project"
+		], { cwd });
+		const project = result.stdout.trim();
+		return result.code === 0 && project.length > 0 && project !== "(unset)";
+	},
+	async link() {
+		throw new Error("No active Google Cloud project. Run: gcloud config set project PROJECT_ID");
+	},
+	async generateConfig(cwd, options) {
+		return [await writeGeneratedFile(cwd, ".gcloudignore", GCLOUDIGNORE, options.dryRun)];
+	},
+	async deploy(cwd, options) {
+		const service = await resolveServiceName(cwd, options.env);
+		const region = resolveRegion(options.env);
+		if (options.dryRun) return { message: `[dry-run] Would run gcloud run deploy ${service} --source . --region ${region}.` };
+		assertCloudRunStorageEnv(options.env);
+		const deployArgs = buildDeployArgs(service, region);
+		let result = await runCommand$1("gcloud", deployArgs, {
+			cwd,
+			env: options.env,
+			stdio: "inherit"
+		});
+		if (result.code !== 0 && !await fileExists$7(join(cwd, "Dockerfile"))) {
+			await writeFile(join(cwd, "Dockerfile"), generateDockerfile(), "utf-8");
+			result = await runCommand$1("gcloud", deployArgs, {
+				cwd,
+				env: options.env,
+				stdio: "inherit"
+			});
+		}
+		if (result.code !== 0) throw new Error("gcloud run deploy failed. Check Cloud Build and Cloud Run logs for details.");
+		const url = parseCloudRunUrl(result.stdout) ?? await describeServiceUrl(cwd, service, region, options.env);
+		return {
+			url,
+			message: url ? `Deploy complete: ${url}` : `Deploy complete. Start command is ${NODE_START_COMMAND}; check Cloud Run dashboard for URL.`
+		};
+	}
+};
+
+//#endregion
+//#region src/cli/commands/deploy/utils/build.ts
+async function fileExists$6(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function detectBuildCommand(cwd) {
+	if (await fileExists$6(join(cwd, "pnpm-lock.yaml"))) return {
+		packageManager: "pnpm",
+		command: "pnpm",
+		args: ["build"],
+		display: "pnpm build"
+	};
+	if (await fileExists$6(join(cwd, "yarn.lock"))) return {
+		packageManager: "yarn",
+		command: "yarn",
+		args: ["build"],
+		display: "yarn build"
+	};
+	if (await fileExists$6(join(cwd, "bun.lock")) || await fileExists$6(join(cwd, "bun.lockb"))) return {
+		packageManager: "bun",
+		command: "bun",
+		args: ["run", "build"],
+		display: "bun run build"
+	};
+	return {
+		packageManager: "npm",
+		command: "npm",
+		args: ["run", "build"],
+		display: "npm run build"
+	};
+}
+async function runBuild(cwd, env) {
+	const build = await detectBuildCommand(cwd);
+	await runCommandOrThrow(build.command, build.args, {
+		cwd,
+		env,
+		stdio: "inherit"
+	});
+	return build;
+}
+
+//#endregion
+//#region src/cli/commands/deploy/targets/railway.ts
+const NONEMPTY_LINE_RE = /\r?\n/;
+const RAILWAY_URL_RE = /https:\/\/[^\s"]+\.up\.railway\.app[^\s"]*/;
+async function fileExists$5(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function parseRailwayUrl(stdout) {
+	for (const line of stdout.split(NONEMPTY_LINE_RE).filter(Boolean)) try {
+		const url = findUrl(JSON.parse(line));
+		if (url) return url;
+	} catch {
+		const match = line.match(RAILWAY_URL_RE);
+		if (match) return match[0];
+	}
+}
+function findUrl(value) {
+	if (typeof value === "string") return value.startsWith("https://") && value.includes("railway.app") ? value : void 0;
+	if (!value || typeof value !== "object") return void 0;
+	for (const item of Object.values(value)) {
+		const found = findUrl(item);
+		if (found) return found;
+	}
+}
+const railwayTarget = {
+	name: "railway",
+	label: "Railway",
+	description: "Deploy a standard Dineway Node server with Railway CLI.",
+	recommended: true,
+	supportLevel: "stable",
+	cli: {
+		npmPackage: "@railway/cli",
+		binary: "railway",
+		versionCommand: {
+			command: "railway",
+			args: ["--version"]
+		},
+		installHint: "Install the Railway CLI from https://docs.railway.app/reference/cli"
+	},
+	async checkAuth(cwd) {
+		return (await runCommand$1("railway", ["whoami"], { cwd })).code === 0;
+	},
+	async login(cwd) {
+		await runCommandOrThrow("railway", ["login"], {
+			cwd,
+			stdio: "inherit"
+		});
+	},
+	async isLinked(cwd) {
+		return (await runCommand$1("railway", ["status"], { cwd })).code === 0;
+	},
+	async link(cwd) {
+		await runCommandOrThrow("railway", ["link"], {
+			cwd,
+			stdio: "inherit"
+		});
+	},
+	async generateConfig(cwd, options) {
+		const railwayPath = join(cwd, "railway.json");
+		if (await fileExists$5(railwayPath)) return [{
+			path: "railway.json",
+			action: "exists"
+		}];
+		const config = {
+			$schema: "https://railway.app/railway.schema.json",
+			build: {
+				builder: "NIXPACKS",
+				buildCommand: (await detectBuildCommand(cwd)).display
+			},
+			deploy: {
+				startCommand: NODE_START_COMMAND,
+				healthcheckPath: HEALTH_CHECK_PATH,
+				healthcheckTimeout: 100,
+				restartPolicyType: "ON_FAILURE"
+			}
+		};
+		if (options.dryRun) return [{
+			path: "railway.json",
+			action: "skipped"
+		}];
+		await writeFile(railwayPath, JSON.stringify(config, null, "	") + "\n", "utf-8");
+		return [{
+			path: "railway.json",
+			action: "created"
+		}];
+	},
+	async deploy(cwd, options) {
+		if (options.dryRun) return { message: "[dry-run] Would run railway up." };
+		await runCommandOrThrow("railway", ["up"], {
+			cwd,
+			env: options.env,
+			stdio: "inherit"
+		});
+		const domain = await runCommand$1("railway", ["domain", "--json"], { cwd }).catch(() => null);
+		const status = await runCommand$1("railway", ["status", "--json"], { cwd }).catch(() => null);
+		const url = (domain ? parseRailwayUrl(domain.stdout) : void 0) ?? (status ? parseRailwayUrl(status.stdout) : void 0);
+		return {
+			url,
+			message: url ? `Deploy complete: ${url}` : "Deploy started. Check Railway dashboard for URL."
+		};
+	}
+};
+
+//#endregion
+//#region src/cli/commands/deploy/utils/cli-resolver.ts
+async function confirm(message) {
+	if (!process.stdin.isTTY) return false;
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const answer = await rl.question(`${message} [y/N] `);
+		return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+	} finally {
+		rl.close();
+	}
+}
+async function ensureTargetCli(target, cwd, options = {}) {
+	if (!target.cli) return;
+	if ((await runCommand$1(target.cli.versionCommand.command, target.cli.versionCommand.args, { cwd }).catch(() => ({
+		code: 1,
+		stdout: "",
+		stderr: ""
+	}))).code === 0) return;
+	if (options.dryRun) {
+		consola.info(`[dry-run] Would verify ${target.cli.binary} CLI with ${target.cli.versionCommand.command} ${target.cli.versionCommand.args.join(" ")}`);
+		if (target.cli.npmPackage) consola.info(`[dry-run] Would offer to install ${target.cli.npmPackage}`);
+		else consola.info(`[dry-run] ${target.cli.installHint ?? `Install ${target.cli.binary} before deploying.`}`);
+		return;
+	}
+	if (!target.cli.npmPackage) throw new Error(`${target.label} CLI is required. ${target.cli.installHint ?? `Install ${target.cli.binary} and try again.`}`);
+	if (options.yes) throw new Error(`Install ${target.cli.npmPackage} and run this command again. The --yes flag does not approve global CLI installation.`);
+	if (!await confirm(`${target.label} CLI is not installed. Install ${target.cli.npmPackage} globally now?`)) throw new Error(`Install ${target.cli.npmPackage} and run this command again.`);
+	await runCommandOrThrow("npm", [
+		"install",
+		"--global",
+		target.cli.npmPackage
+	], {
+		cwd,
+		stdio: "inherit"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/deploy/utils/config.ts
+async function readDeployPackageJson(cwd) {
+	const content = await readFile(join(cwd, "package.json"), "utf-8");
+	return JSON.parse(content);
+}
+async function readSavedDeployTarget(cwd) {
+	return (await readDeployPackageJson(cwd)).dineway?.deploy?.target;
+}
+async function writeDeployTarget(cwd, target) {
+	const pkgPath = join(cwd, "package.json");
+	const pkg = await readDeployPackageJson(cwd);
+	pkg.dineway = {
+		...pkg.dineway,
+		deploy: {
+			...pkg.dineway?.deploy,
+			target
+		}
+	};
+	await writeFile(pkgPath, JSON.stringify(pkg, null, "	") + "\n", "utf-8");
+}
+
+//#endregion
+//#region src/cli/commands/deploy/index.ts
+const targets = [
+	railwayTarget,
+	dockerTarget,
+	flyTarget,
+	gcpTarget
+];
+function getTarget(name) {
+	return targets.find((target) => target.name === name);
+}
+function targetList() {
+	return targets.map((target) => target.name).join(", ");
+}
+async function promptForTarget() {
+	const recommended = targets.find((target) => target.recommended) ?? targets[0];
+	if (!process.stdin.isTTY || !recommended) throw new Error(`No deploy target configured. Pass one of: ${targetList()}`);
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		consola.info("Available deploy targets:");
+		targets.forEach((target, index) => {
+			const suffix = target.recommended ? " (recommended)" : "";
+			consola.info(`  ${index + 1}. ${target.label}${suffix} - ${target.description}`);
+		});
+		const value = (await rl.question(`Choose a target [${recommended.name}]: `)).trim() || recommended.name;
+		const byIndex = Number(value);
+		const target = Number.isInteger(byIndex) ? targets[byIndex - 1] : getTarget(value);
+		if (!target) throw new Error(`Unknown deploy target "${value}". Available targets: ${targetList()}`);
+		return target;
+	} finally {
+		rl.close();
+	}
+}
+async function resolveTarget(cwd, explicitTarget) {
+	if (explicitTarget) {
+		const target = getTarget(explicitTarget);
+		if (!target) throw new Error(`Unknown deploy target "${explicitTarget}". Available targets: ${targetList()}`);
+		return target;
+	}
+	const saved = await readSavedDeployTarget(cwd).catch(() => void 0);
+	if (saved) {
+		const target = getTarget(saved);
+		if (!target) throw new Error(`Saved deploy target "${saved}" is unknown. Available targets: ${targetList()}`);
+		return target;
+	}
+	return promptForTarget();
+}
+const deployCommand = defineCommand({
+	meta: {
+		name: "deploy",
+		description: "Deploy a Dineway Node server through a provider CLI"
+	},
+	args: {
+		target: {
+			type: "positional",
+			description: "Deploy target",
+			required: false
+		},
+		cwd: {
+			type: "string",
+			description: "Working directory",
+			default: process.cwd()
+		},
+		"skip-build": {
+			type: "boolean",
+			description: "Skip running the package build command before deploy",
+			default: false
+		},
+		compose: {
+			type: "boolean",
+			description: "Generate docker-compose.yml for Docker target",
+			default: false
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Accept safe interactive prompts",
+			default: false
+		},
+		"dry-run": {
+			type: "boolean",
+			description: "Print planned actions without writing files or deploying",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const cwd = resolve(args.cwd);
+		const target = await resolveTarget(cwd, args.target);
+		const options = {
+			skipBuild: args["skip-build"],
+			compose: args.compose,
+			yes: args.yes,
+			dryRun: args["dry-run"]
+		};
+		consola.start(`Preparing ${target.label} deploy`);
+		await ensureTargetCli(target, cwd, {
+			yes: options.yes,
+			dryRun: options.dryRun
+		});
+		const generated = await target.generateConfig(cwd, options);
+		for (const file of generated) {
+			if (file.action === "created") consola.success(`Created ${file.path}`);
+			if (file.action === "exists") consola.info(`${file.path} already exists`);
+			if (file.action === "skipped") consola.info(`[dry-run] Would create ${file.path}`);
+		}
+		if (!options.dryRun) {
+			if (target.checkAuth && !await target.checkAuth(cwd)) {
+				if (!target.login) throw new Error(`${target.label} CLI is not authenticated.`);
+				await target.login(cwd);
+			}
+			if (target.isLinked && !await target.isLinked(cwd)) {
+				if (!target.link) throw new Error(`${target.label} project is not linked.`);
+				await target.link(cwd);
+			}
+		} else consola.info("[dry-run] Would verify provider authentication and project link");
+		if (!options.skipBuild && target.name !== "docker") {
+			const build = options.dryRun ? null : await runBuild(cwd, options.env);
+			consola.info(options.dryRun ? "[dry-run] Would run build" : `Built with ${build?.display}`);
+		}
+		if (!options.dryRun) await writeDeployTarget(cwd, target.name);
+		else consola.info(`[dry-run] Would save dineway.deploy.target=${target.name}`);
+		const result = await target.deploy(cwd, options);
+		if (result.url) consola.success(result.url);
+		consola.success(result.message);
+	}
+});
+
 //#endregion
 //#region src/cli/database-url.ts
 const REMOTE_DATABASE_URL_PREFIXES = [
@@ -2276,13 +3194,13 @@ async function findBuildOutput(dir, baseName) {
 */
 async function resolveSourceEntry(pluginDir, distPath) {
 	const cleaned = distPath.replace(LEADING_DOT_SLASH_RE, "");
-	const direct = resolve(pluginDir, cleaned);
-	if (await fileExists$1(direct)) return direct;
 	const srcPath = cleaned.replace(DIST_PREFIX_RE, "src/").replace(MJS_EXT_RE, ".ts");
 	const srcFull = resolve(pluginDir, srcPath);
 	if (await fileExists$1(srcFull)) return srcFull;
 	const tsxFull = resolve(pluginDir, srcPath.replace(TS_TO_TSX_RE, ".tsx"));
 	if (await fileExists$1(tsxFull)) return tsxFull;
+	const direct = resolve(pluginDir, cleaned);
+	if (await fileExists$1(direct)) return direct;
 }
 const TS_SOURCE_EXPORT_RE = /\.(?:ts|tsx|mts|cts|jsx)$/;
 /**
@@ -3954,6 +4872,7 @@ const typesCommand = defineCommand({
 * - search: Full-text search
 * - taxonomy: Manage taxonomies and terms
 * - menu: Manage navigation menus
+* - deploy: Deploy a standard Dineway Node server through a provider CLI
 * - plugin: Plugin management (init, bundle, validate, publish, login, logout)
 */
 runMain(defineCommand({
@@ -3966,6 +4885,7 @@ runMain(defineCommand({
 		init: initCommand,
 		types: typesCommand,
 		dev: devCommand,
+		deploy: deployCommand,
 		doctor: doctorCommand,
 		seed: seedCommand,
 		"export-seed": exportSeedCommand,