create-asaje-go-vue 0.3.8 → 0.3.9

package/bin/create-asaje-go-vue.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 
-import crypto from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
@@ -8,63 +7,100 @@ import {
   cancel,
   confirm,
   intro,
-  isCancel,
   outro,
-  password,
   select,
   text,
 } from "@clack/prompts";
-import degit from "degit";
 import { execa } from "execa";
 import fs from "fs-extra";
 import pc from "picocolors";
+import {
+  parseCreateArgs,
+  parseDeployRailwayArgs,
+  parseDestroyRailwayArgs,
+  parseDirectoryArgs,
+  parseSetupRailwayArgs,
+  parseStartArgs,
+  parseUpdateArgs,
+} from "../src/cli/args.js";
+import { toEnvContent, tryReadEnvFile } from "../src/cli/env.js";
+import { splitCommaSeparatedPaths, uniquePaths } from "../src/cli/paths.js";
+import { prompt } from "../src/cli/prompts.js";
+import { checkCommand, createManagedProcess, runCommand } from "../src/cli/process.js";
+import { runCliCommand } from "../src/cli/runner.js";
+import {
+  randomSecret,
+  resolveProjectSlug,
+  shellEscape,
+} from "../src/cli/strings.js";
+import { fetchRailwayProjectServices } from "../src/railway/client.js";
+import {
+  readRailwayManifest as readRailwayManifestFile,
+  writeRailwayManifest as writeRailwayManifestFile,
+} from "../src/railway/manifest.js";
+import {
+  DEFAULT_RAILWAY_APP_SERVICE_SPECS,
+  buildCreateRailwayServices,
+  buildSyncedRailwayManifest,
+  findCreatedRailwayService,
+  findRailwayService,
+  findRailwayServiceByKey,
+  normalizeRailwayServiceName,
+  normalizeRailwayServices,
+  resolveRailwayAppServiceSpecs,
+  resolveRailwayServiceName,
+  updateRailwayManifestAppServices,
+} from "../src/railway/services.js";
+import {
+  buildGithubWorkflowContent,
+  buildProjectReadmeContent,
+  buildReadmeAnswersFromProjectConfig,
+  getGithubActionsDeployConfig,
+} from "../src/project/docs.js";
+import { buildProjectMakefileContent } from "../src/project/makefile.js";
+import {
+  cleanupTemplateFiles,
+  cloneTemplate,
+  ensureDestinationIsAvailable,
+  ensureProjectStructure,
+  ensureScaffoldedSurfaces,
+  loadProjectConfig,
+} from "../src/project/files.js";
+import {
+  buildSyncedProjectConfig,
+  getRailwayConfig,
+  scanProjectForManagedRailwayServices,
+} from "../src/project/sync.js";
+import { collectCreateAnswers } from "../src/create/questions.js";
+import { collectStartAnswers } from "../src/start/answers.js";
+import {
+  ensureEnvFiles,
+  installProjectDependencies,
+  loadRuntimeConfig,
+  startInfrastructure,
+} from "../src/start/runtime.js";
+import {
+  buildRailwayConfigExportFilename,
+  buildRailwayConfigSnapshotDiff,
+  readRailwayConfigSnapshot,
+  sanitizeRailwayConfigSnapshotDiff,
+  assertRailwaySnapshotImportable,
+} from "../src/railway/snapshot.js";
+import {
+  assignManagedRailwayServiceVariables,
+  buildRailwayBrowserOrigins,
+  buildRailwayVariableDiff,
+  formatRailwayVariableValue,
+  sanitizeVariablesForOutput,
+} from "../src/railway/variables.js";
+import { resolveInvocation } from "../src/cli/invocation.js";
 
 const DEFAULT_TEMPLATE = process.env.ASAJE_TEMPLATE_REPO || "asaje379/boilerplate-go-vue";
 const DEFAULT_BRANCH = process.env.ASAJE_TEMPLATE_BRANCH || "main";
-const EXCLUDED_TEMPLATE_PATHS = ["cli"];
-const RAILWAY_GRAPHQL_ENDPOINT = "https://backboard.railway.com/graphql/v2";
 const RAILWAY_MANIFEST_FILENAME = "asaje.railway.json";
 const DEFAULT_RAILWAY_BUCKET = "boilerplate-files";
 const RAILWAY_SERVICE_DISCOVERY_RETRY_DELAY_MS = 2000;
 const RAILWAY_SERVICE_DISCOVERY_RETRY_COUNT = 5;
-const DEFAULT_RAILWAY_APP_SERVICE_SPECS = [
-  {
-    aliases: ["api", "backend", "server"],
-    baseName: "api",
-    directory: "api",
-    key: "api",
-  },
-  {
-    aliases: ["worker", "api-worker"],
-    baseName: "worker",
-    directory: "api",
-    key: "worker",
-  },
-  {
-    aliases: ["admin", "frontend", "web"],
-    baseName: "admin",
-    directory: "admin",
-    key: "admin",
-  },
-  {
-    aliases: ["realtime-gateway", "realtime"],
-    baseName: "realtime-gateway",
-    directory: "realtime-gateway",
-    key: "realtime",
-  },
-  {
-    aliases: ["landing", "marketing"],
-    baseName: "landing",
-    directory: "landing",
-    key: "landing",
-  },
-  {
-    aliases: ["pwa", "mobile-web"],
-    baseName: "pwa",
-    directory: "pwa",
-    key: "pwa",
-  },
-];
 const SAFE_UPDATE_PATHS = [
   ".github/workflows/deploy-railway.yml",
   "docker-compose.yml",
@@ -87,13 +123,6 @@ const SAFE_UPDATE_PATHS = [
   "pwa/nginx.conf",
   "pwa/public",
 ];
-const ENV_FILE_SPECS = [
-  { envPath: "admin/.env", examplePath: "admin/.env.example" },
-  { envPath: "api/.env", examplePath: "api/.env.example" },
-  { envPath: "realtime-gateway/.env", examplePath: "realtime-gateway/.env.example" },
-  { envPath: "landing/.env", examplePath: "landing/.env.example" },
-  { envPath: "pwa/.env", examplePath: "pwa/.env.example" },
-];
 
 await main();
 
@@ -102,110 +131,27 @@ async function main() {
   intro(pc.cyan(invocation.title));
 
   try {
-    if (invocation.command === "help") {
-      printHelp();
-      outro(pc.green("Ready."));
-      return;
-    }
-
-    if (invocation.command === "start") {
-      await runStart(invocation.argv);
-      outro(pc.green("Services stopped."));
-      return;
-    }
-
-    if (invocation.command === "doctor") {
-      await runDoctor(invocation.argv);
-      outro(pc.green("Doctor finished."));
-      return;
-    }
-
-    if (invocation.command === "publish") {
-      await runPublish(invocation.argv);
-      outro(pc.green("Publish checklist complete."));
-      return;
-    }
-
-    if (invocation.command === "update") {
-      await runUpdate(invocation.argv);
-      outro(pc.green("Project update complete."));
-      return;
-    }
-
-    if (invocation.command === "sync-project-config") {
-      await runSyncProjectConfig(invocation.argv);
-      outro(pc.green("Project config sync complete."));
-      return;
-    }
-
-    if (invocation.command === "sync-readme") {
-      await runSyncReadme(invocation.argv);
-      outro(pc.green("Project README sync complete."));
-      return;
-    }
-
-    if (invocation.command === "sync-github-workflow") {
-      await runSyncGithubWorkflow(invocation.argv);
-      outro(pc.green("GitHub workflow sync complete."));
-      return;
-    }
-
-    if (invocation.command === "setup-railway") {
-      await runSetupRailway(invocation.argv);
-      outro(pc.green("Railway setup complete."));
-      return;
-    }
-
-    if (invocation.command === "update-railway") {
-      await runUpdateRailway(invocation.argv);
-      outro(pc.green("Railway update complete."));
-      return;
-    }
-
-    if (invocation.command === "sync-railway-env") {
-      await runSyncRailwayEnv(invocation.argv);
-      outro(pc.green("Railway environment sync complete."));
-      return;
-    }
-
-    if (invocation.command === "print-railway-config") {
-      await runPrintRailwayConfig(invocation.argv);
-      outro(pc.green("Railway config printed."));
-      return;
-    }
-
-    if (invocation.command === "export-railway-config") {
-      await runExportRailwayConfig(invocation.argv);
-      outro(pc.green("Railway config exported."));
-      return;
-    }
-
-    if (invocation.command === "import-railway-config") {
-      await runImportRailwayConfig(invocation.argv);
-      outro(pc.green("Railway config imported."));
-      return;
-    }
-
-    if (invocation.command === "diff-railway-config") {
-      await runDiffRailwayConfig(invocation.argv);
-      outro(pc.green("Railway config diff complete."));
-      return;
-    }
-
-    if (invocation.command === "deploy-railway") {
-      await runDeployRailway(invocation.argv);
-      outro(pc.green("Railway deployment complete."));
-      return;
-    }
-
-    if (invocation.command === "destroy-railway") {
-      await runDestroyRailway(invocation.argv);
-      outro(pc.green("Railway teardown complete."));
-      return;
-    }
-
-    await runCreate(invocation.argv);
-    outro(pc.green("Project ready."));
+    const completionMessage = await runCliCommand(invocation, {
+      printHelp,
+      runCreate,
+      runDeployRailway,
+      runDestroyRailway,
+      runDiffRailwayConfig,
+      runDoctor,
+      runExportRailwayConfig,
+      runImportRailwayConfig,
+      runPrintRailwayConfig,
+      runPublish,
+      runSetupRailway,
+      runStart,
+      runSyncGithubWorkflow,
+      runSyncProjectConfig,
+      runSyncRailwayEnv,
+      runSyncReadme,
+      runUpdate,
+      runUpdateRailway,
+    });
+    outro(pc.green(completionMessage));
   } catch (error) {
     if (error instanceof Error) {
       cancel(error.message);
@@ -217,159 +163,6 @@ async function main() {
   }
 }
 
-function resolveInvocation(argv) {
-  const binName = path.basename(argv[1] || "create-asaje-go-vue");
-  const normalizedBinName = binName.replace(/\.js$/, "");
-  const rawArgs = argv.slice(2);
-  const firstArg = rawArgs[0];
-
-  if (["help", "--help", "-h"].includes(firstArg || "")) {
-    return { argv: rawArgs.slice(1), command: "help", title: normalizedBinName };
-  }
-
-  if (normalizedBinName === "asaje") {
-    if (!firstArg) {
-      return { argv: [], command: "help", title: "asaje" };
-    }
-
-    if (firstArg === "start") {
-      return { argv: rawArgs.slice(1), command: "start", title: "asaje start" };
-    }
-
-    if (firstArg === "doctor") {
-      return { argv: rawArgs.slice(1), command: "doctor", title: "asaje doctor" };
-    }
-
-    if (firstArg === "publish") {
-      return { argv: rawArgs.slice(1), command: "publish", title: "asaje publish" };
-    }
-
-    if (firstArg === "update") {
-      return { argv: rawArgs.slice(1), command: "update", title: "asaje update" };
-    }
-
-    if (firstArg === "sync-project-config") {
-      return { argv: rawArgs.slice(1), command: "sync-project-config", title: "asaje sync-project-config" };
-    }
-
-    if (firstArg === "sync-readme") {
-      return { argv: rawArgs.slice(1), command: "sync-readme", title: "asaje sync-readme" };
-    }
-
-    if (firstArg === "sync-github-workflow") {
-      return { argv: rawArgs.slice(1), command: "sync-github-workflow", title: "asaje sync-github-workflow" };
-    }
-
-    if (firstArg === "setup-railway") {
-      return { argv: rawArgs.slice(1), command: "setup-railway", title: "asaje setup-railway" };
-    }
-
-    if (firstArg === "update-railway") {
-      return { argv: rawArgs.slice(1), command: "update-railway", title: "asaje update-railway" };
-    }
-
-    if (firstArg === "sync-railway-env") {
-      return { argv: rawArgs.slice(1), command: "sync-railway-env", title: "asaje sync-railway-env" };
-    }
-
-    if (firstArg === "print-railway-config") {
-      return { argv: rawArgs.slice(1), command: "print-railway-config", title: "asaje print-railway-config" };
-    }
-
-    if (firstArg === "export-railway-config") {
-      return { argv: rawArgs.slice(1), command: "export-railway-config", title: "asaje export-railway-config" };
-    }
-
-    if (firstArg === "import-railway-config") {
-      return { argv: rawArgs.slice(1), command: "import-railway-config", title: "asaje import-railway-config" };
-    }
-
-    if (firstArg === "diff-railway-config") {
-      return { argv: rawArgs.slice(1), command: "diff-railway-config", title: "asaje diff-railway-config" };
-    }
-
-    if (firstArg === "deploy-railway") {
-      return { argv: rawArgs.slice(1), command: "deploy-railway", title: "asaje deploy-railway" };
-    }
-
-    if (firstArg === "destroy-railway") {
-      return { argv: rawArgs.slice(1), command: "destroy-railway", title: "asaje destroy-railway" };
-    }
-
-    if (firstArg === "create") {
-      return { argv: rawArgs.slice(1), command: "create", title: "asaje create" };
-    }
-
-    return { argv: [], command: "help", title: "asaje" };
-  }
-
-  if (firstArg === "start") {
-    return { argv: rawArgs.slice(1), command: "start", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "doctor") {
-    return { argv: rawArgs.slice(1), command: "doctor", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "publish") {
-    return { argv: rawArgs.slice(1), command: "publish", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "update") {
-    return { argv: rawArgs.slice(1), command: "update", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "sync-project-config") {
-    return { argv: rawArgs.slice(1), command: "sync-project-config", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "sync-readme") {
-    return { argv: rawArgs.slice(1), command: "sync-readme", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "sync-github-workflow") {
-    return { argv: rawArgs.slice(1), command: "sync-github-workflow", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "setup-railway") {
-    return { argv: rawArgs.slice(1), command: "setup-railway", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "update-railway") {
-    return { argv: rawArgs.slice(1), command: "update-railway", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "sync-railway-env") {
-    return { argv: rawArgs.slice(1), command: "sync-railway-env", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "print-railway-config") {
-    return { argv: rawArgs.slice(1), command: "print-railway-config", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "export-railway-config") {
-    return { argv: rawArgs.slice(1), command: "export-railway-config", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "import-railway-config") {
-    return { argv: rawArgs.slice(1), command: "import-railway-config", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "diff-railway-config") {
-    return { argv: rawArgs.slice(1), command: "diff-railway-config", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "deploy-railway") {
-    return { argv: rawArgs.slice(1), command: "deploy-railway", title: "create-asaje-go-vue" };
-  }
-
-  if (firstArg === "destroy-railway") {
-    return { argv: rawArgs.slice(1), command: "destroy-railway", title: "create-asaje-go-vue" };
-  }
-
-  return { argv: rawArgs, command: "create", title: "create-asaje-go-vue" };
-}
-
 function printHelp() {
   console.log(pc.bold("\nCommands"));
   console.log(`- ${pc.bold("create-asaje-go-vue <directory>")} scaffold a new project`);
@@ -412,575 +205,33 @@ function printHelp() {
 }
 
 async function runCreate(argv) {
-  const args = parseCreateArgs(argv);
-  const answers = await collectCreateAnswers(args);
-  const destinationDir = path.resolve(process.cwd(), answers.directory);
-
-  await ensureDestinationIsAvailable(destinationDir);
-
-  console.log(pc.dim("\nScaffolding project from GitHub template..."));
-  await cloneTemplate(answers.template, answers.branch, destinationDir);
-  await cleanupTemplateFiles(destinationDir);
-  await ensureScaffoldedSurfaces(destinationDir, answers);
-  await writeProjectConfig(destinationDir, answers);
-  await writeEnvFiles(destinationDir, answers);
-  await writeProjectReadme(destinationDir, answers);
-  await writeGithubWorkflow(destinationDir, answers);
-
-  if (answers.installDependencies) {
-    console.log(pc.dim("\nInstalling frontend and Go dependencies..."));
-    await installProjectDependencies(destinationDir);
-  }
-
-  if (answers.startInfra) {
-    console.log(pc.dim("\nStarting local infrastructure with Docker Compose..."));
-    await startInfrastructure(destinationDir);
-  }
-
-  printCreateSummary(destinationDir, answers);
-}
-
-function parseCreateArgs(argv) {
-  const options = {
-    branch: DEFAULT_BRANCH,
-    installDependencies: undefined,
-    startInfra: undefined,
-    template: DEFAULT_TEMPLATE,
-    yes: false,
-  };
-  const positionals = [];
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-
-    if (arg === "--yes" || arg === "-y") {
-      options.yes = true;
-      continue;
-    }
-
-    if (arg === "--template") {
-      options.template = argv[index + 1] || options.template;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--template=")) {
-      options.template = arg.split("=")[1] || options.template;
-      continue;
-    }
-
-    if (arg === "--branch") {
-      options.branch = argv[index + 1] || options.branch;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--branch=")) {
-      options.branch = arg.split("=")[1] || options.branch;
-      continue;
-    }
-
-    if (arg === "--install") {
-      options.installDependencies = true;
-      continue;
-    }
-
-    if (arg === "--skip-install") {
-      options.installDependencies = false;
-      continue;
-    }
-
-    if (arg === "--start-infra") {
-      options.startInfra = true;
-      continue;
-    }
-
-    if (arg === "--skip-infra") {
-      options.startInfra = false;
-      continue;
-    }
-
-    positionals.push(arg);
-  }
-
-  return { ...options, directory: positionals[0] };
-}
-
-function parseUpdateArgs(argv) {
-  const options = {
-    branch: undefined,
-    directory: ".",
-    dryRun: false,
-    include: [],
-    template: undefined,
-    yes: false,
-  };
-  const positionals = [];
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-
-    if (arg === "--yes" || arg === "-y") {
-      options.yes = true;
-      continue;
-    }
-
-    if (arg === "--dry-run") {
-      options.dryRun = true;
-      continue;
-    }
-
-    if (arg === "--template") {
-      options.template = argv[index + 1] || options.template;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--template=")) {
-      options.template = arg.split("=")[1] || options.template;
-      continue;
-    }
-
-    if (arg === "--branch") {
-      options.branch = argv[index + 1] || options.branch;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--branch=")) {
-      options.branch = arg.split("=")[1] || options.branch;
-      continue;
-    }
-
-    if (arg === "--include") {
-      options.include.push(...splitCommaSeparatedPaths(argv[index + 1] || ""));
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--include=")) {
-      options.include.push(...splitCommaSeparatedPaths(arg.split("=")[1] || ""));
-      continue;
-    }
-
-    positionals.push(arg);
-  }
-
-  options.directory = positionals[0] || options.directory;
-  options.include = uniquePaths(options.include);
-  return options;
-}
-
-async function collectCreateAnswers(args) {
-  const defaultDirectory = args.directory || "my-asaje-app";
-  const defaultSlug = slugify(path.basename(defaultDirectory));
-  const defaultAppName = titleize(defaultSlug || "asaje app");
-
-  if (args.yes) {
-    return buildCreateAnswers({
-      adminPort: 5173,
-      apiPort: 8080,
-      appName: defaultAppName,
-      branch: args.branch,
-      bucketBasePath: defaultSlug,
-      corsAllowedOrigins: "",
-      defaultLocale: "fr",
-      directory: defaultDirectory,
-      includeLanding: true,
-      includePwa: true,
-      installDependencies: args.installDependencies ?? true,
-      mailFromEmail: `no-reply@${defaultSlug || "asaje-app"}.local`,
-      mailFromName: defaultAppName,
-      mailProvider: "mailchimp",
-      mailchimpApiKey: "dev-placeholder-key",
-      realtimePort: 8090,
-      seedAdmin: false,
-      seedUser: false,
-      startInfra: args.startInfra ?? true,
-      storageProvider: "minio",
-      swaggerUsername: "swagger",
-      template: args.template,
-    });
-  }
-
-  const directory = await prompt(
-    text({
-      defaultValue: defaultDirectory,
-      message: "Project directory?",
-      placeholder: "my-asaje-app",
-      validate(value) {
-        return value.trim().length === 0 ? "Directory is required" : undefined;
-      },
-    }),
-  );
-
-  const appName = await prompt(
-    text({
-      defaultValue: defaultAppName,
-      message: "App name?",
-      placeholder: "My Asaje App",
-      validate(value) {
-        return value.trim().length === 0 ? "App name is required" : undefined;
-      },
-    }),
-  );
-
-  const defaultLocale = await prompt(
-    select({
-      initialValue: "fr",
-      message: "Default locale?",
-      options: [
-        { label: "French", value: "fr" },
-        { label: "English", value: "en" },
-      ],
-    }),
-  );
-
-  const adminPort = await promptNumber("Admin dev server port?", 5173);
-  const apiPort = await promptNumber("API port?", 8080);
-  const realtimePort = await promptNumber("Realtime gateway port?", 8090);
-  const swaggerUsername = await prompt(
-    text({
-      defaultValue: "swagger",
-      message: "Swagger username?",
-      validate(value) {
-        return value.trim().length === 0 ? "Swagger username is required" : undefined;
-      },
-    }),
-  );
-
-  const seedAdmin = await prompt(
-    confirm({
-      initialValue: true,
-      message: "Seed an admin account now?",
-    }),
-  );
-
-  let adminName = "Admin";
-  let adminEmail = "admin@example.com";
-  let adminPassword = "admin12345";
-
-  if (seedAdmin) {
-    adminName = await prompt(
-      text({
-        defaultValue: adminName,
-        message: "Admin name?",
-        validate(value) {
-          return value.trim().length >= 2 ? undefined : "Admin name must be at least 2 characters";
-        },
-      }),
-    );
-
-    adminEmail = await promptEmail("Admin email?", adminEmail);
-    adminPassword = await promptSecret("Admin password?", 8);
-  }
-
-  const seedUser = await prompt(
-    confirm({
-      initialValue: false,
-      message: "Seed a standard user too?",
-    }),
-  );
-
-  let seedUserName = "User";
-  let seedUserEmail = "user@example.com";
-  let seedUserPassword = "user12345";
-
-  if (seedUser) {
-    seedUserName = await prompt(
-      text({
-        defaultValue: seedUserName,
-        message: "User name?",
-        validate(value) {
-          return value.trim().length >= 2 ? undefined : "User name must be at least 2 characters";
-        },
-      }),
-    );
-
-    seedUserEmail = await promptEmail("User email?", seedUserEmail);
-    seedUserPassword = await promptSecret("User password?", 8);
-  }
-
-  const storageProvider = await prompt(
-    select({
-      initialValue: "minio",
-      message: "Object storage provider?",
-      options: [
-        { label: "Local MinIO", value: "minio" },
-        { label: "AWS S3 / compatible", value: "aws" },
-      ],
-    }),
-  );
-
-  const slug = slugify(path.basename(directory));
-  const bucketBasePath = await prompt(
-    text({
-      defaultValue: slug,
-      message: "Bucket base path?",
-      placeholder: slug,
-    }),
-  );
-
-  let minioEndpoint = "localhost";
-  let minioPort = 9000;
-  let minioUseSSL = false;
-  let minioAccessKey = "minioadmin";
-  let minioSecretKey = "minioadmin";
-  let minioBucket = "boilerplate-files";
-  let minioPublicURL = "http://localhost:9000";
-  let awsEndpointURL = "";
-  let awsAccessKeyId = "";
-  let awsSecretAccessKey = "";
-  let awsBucket = "";
-  let awsRegion = "us-east-1";
-
-  if (storageProvider === "minio") {
-    minioEndpoint = await prompt(
-      text({
-        defaultValue: minioEndpoint,
-        message: "MinIO host?",
-        validate(value) {
-          return value.trim().length === 0 ? "MinIO host is required" : undefined;
-        },
-      }),
-    );
-    minioPort = await promptNumber("MinIO port?", minioPort);
-    minioUseSSL = await prompt(
-      confirm({
-        initialValue: false,
-        message: "Use SSL for MinIO?",
-      }),
-    );
-    minioAccessKey = await prompt(
-      text({
-        defaultValue: minioAccessKey,
-        message: "MinIO access key?",
-        validate(value) {
-          return value.trim().length === 0 ? "MinIO access key is required" : undefined;
-        },
-      }),
-    );
-    minioSecretKey = await promptSecret("MinIO secret key?", 3, minioSecretKey);
-    minioBucket = await prompt(
-      text({
-        defaultValue: minioBucket,
-        message: "MinIO bucket name?",
-        validate(value) {
-          return value.trim().length === 0 ? "MinIO bucket name is required" : undefined;
-        },
-      }),
-    );
-    minioPublicURL = await prompt(
-      text({
-        defaultValue: minioPublicURL,
-        message: "MinIO public URL?",
-        validate(value) {
-          return isHttpUrl(value) ? undefined : "Enter a valid URL";
-        },
-      }),
-    );
-  } else {
-    awsEndpointURL = await prompt(
-      text({
-        defaultValue: awsEndpointURL,
-        message: "AWS endpoint URL? (leave empty for AWS)",
-      }),
-    );
-    awsAccessKeyId = await prompt(
-      text({
-        message: "AWS access key id?",
-        validate(value) {
-          return value.trim().length === 0 ? "AWS access key id is required" : undefined;
-        },
-      }),
-    );
-    awsSecretAccessKey = await promptSecret("AWS secret access key?", 3);
-    awsBucket = await prompt(
-      text({
-        message: "AWS bucket name?",
-        validate(value) {
-          return value.trim().length === 0 ? "AWS bucket name is required" : undefined;
-        },
-      }),
-    );
-    awsRegion = await prompt(
-      text({
-        defaultValue: awsRegion,
-        message: "AWS region?",
-        validate(value) {
-          return value.trim().length === 0 ? "AWS region is required" : undefined;
-        },
-      }),
-    );
-  }
-
-  const mailProvider = await prompt(
-    select({
-      initialValue: "mailchimp",
-      message: "Transactional email mode?",
-      options: [
-        { label: "Mailchimp Transactional", value: "mailchimp" },
-        { label: "Brevo", value: "brevo" },
-        { label: "SMTP", value: "smtp" },
-      ],
-    }),
-  );
-
-  const mailFromEmail = await promptEmail(
-    "Transactional sender email?",
-    `no-reply@${slug || "asaje-app"}.local`,
-  );
-  const mailFromName = await prompt(
-    text({
-      defaultValue: appName,
-      message: "Transactional sender name?",
-      validate(value) {
-        return value.trim().length === 0 ? "Sender name is required" : undefined;
-      },
-    }),
-  );
-  const mailchimpApiKey = mailProvider === "mailchimp" ? await promptSecret("Mailchimp Transactional API key?", 3) : "";
-  const brevoApiKey = mailProvider === "brevo" ? await promptSecret("Brevo API key?", 3) : "";
-  const smtpHost =
-    mailProvider === "smtp"
-      ? await prompt(
-          text({
-            defaultValue: "smtp.gmail.com",
-            message: "SMTP host?",
-            validate(value) {
-              return value.trim().length === 0 ? "SMTP host is required" : undefined;
-            },
-          }),
-        )
-      : "";
-  const smtpPort = mailProvider === "smtp" ? await promptNumber("SMTP port?", 587) : 587;
-  const smtpUsername = mailProvider === "smtp" ? await prompt(text({ defaultValue: "", message: "SMTP username?" })) : "";
-  const smtpPassword = mailProvider === "smtp" ? await promptSecret("SMTP password?", 0, "") : "";
-  const smtpUseSSL =
-    mailProvider === "smtp"
-      ? await prompt(
-          confirm({
-            initialValue: false,
-            message: "Use SSL for SMTP?",
-          }),
-        )
-      : false;
-
-  const includeLanding = await prompt(
-    confirm({
-      initialValue: true,
-      message: "Enable the optional landing surface?",
-    }),
-  );
-  const includePwa = await prompt(
-    confirm({
-      initialValue: true,
-      message: "Enable the optional PWA surface?",
-    }),
-  );
+  const args = parseCreateArgs(argv, { defaultBranch: DEFAULT_BRANCH, defaultTemplate: DEFAULT_TEMPLATE });
+  const answers = await collectCreateAnswers(args);
+  const destinationDir = path.resolve(process.cwd(), answers.directory);
 
-  const enableGithubWorkflow = await prompt(
-    confirm({
-      initialValue: true,
-      message: "Generate a GitHub Actions Railway deploy workflow?",
-    }),
-  );
-  const productionBranch = enableGithubWorkflow
-    ? await prompt(
-        text({
-          defaultValue: "main",
-          message: "Production branch?",
-          validate(value) {
-            return value.trim().length === 0 ? "Production branch is required" : undefined;
-          },
-        }),
-      )
-    : "main";
-  const stagingBranch = enableGithubWorkflow
-    ? await prompt(
-        text({
-          defaultValue: "develop",
-          message: "Staging branch?",
-          validate(value) {
-            return value.trim().length === 0 ? "Staging branch is required" : undefined;
-          },
-        }),
-      )
-    : "develop";
+  await ensureDestinationIsAvailable(destinationDir);
 
-  const corsAllowedOrigins = await prompt(
-    text({
-      defaultValue: "",
-      message: "Extra CORS origins? (comma-separated, optional)",
-      placeholder: "https://app.example.com,https://admin.example.com",
-    }),
-  );
+  console.log(pc.dim("\nScaffolding project from GitHub template..."));
+  await cloneTemplate(answers.template, answers.branch, destinationDir);
+  await cleanupTemplateFiles(destinationDir);
+  await ensureScaffoldedSurfaces(destinationDir, answers);
+  await writeProjectConfig(destinationDir, answers);
+  await writeEnvFiles(destinationDir, answers);
+  await writeProjectMakefile(destinationDir, answers);
+  await writeProjectReadme(destinationDir, answers);
+  await writeGithubWorkflow(destinationDir, answers);
 
-  const installDependencies = await prompt(
-    confirm({
-      initialValue: args.installDependencies ?? true,
-      message: "Install dependencies now?",
-    }),
-  );
+  if (answers.installDependencies) {
+    console.log(pc.dim("\nInstalling frontend and Go dependencies..."));
+    await installProjectDependencies(destinationDir);
+  }
 
-  const startInfra = await prompt(
-    confirm({
-      initialValue: args.startInfra ?? true,
-      message: "Start local Docker services now?",
-    }),
-  );
+  if (answers.startInfra) {
+    console.log(pc.dim("\nStarting local infrastructure with Docker Compose..."));
+    await startInfrastructure(destinationDir);
+  }
 
-  return buildCreateAnswers({
-    adminEmail,
-    adminName,
-    adminPassword,
-    adminPort,
-    apiPort,
-    appName,
-    awsAccessKeyId,
-    awsBucket,
-    awsEndpointURL,
-    awsRegion,
-    awsSecretAccessKey,
-    branch: args.branch,
-    bucketBasePath,
-    corsAllowedOrigins,
-    defaultLocale,
-    directory,
-    enableGithubWorkflow,
-    includeLanding,
-    includePwa,
-    installDependencies,
-    brevoApiKey,
-    mailFromEmail,
-    mailFromName,
-    mailProvider,
-    mailchimpApiKey,
-    minioAccessKey,
-    minioBucket,
-    minioEndpoint,
-    minioPort,
-    minioPublicURL,
-    minioSecretKey,
-    minioUseSSL,
-    realtimePort,
-    seedAdmin,
-    seedUser,
-    seedUserEmail,
-    seedUserName,
-    seedUserPassword,
-    startInfra,
-    storageProvider,
-    swaggerUsername,
-    smtpHost,
-    smtpPassword,
-    smtpPort,
-    smtpUseSSL,
-    smtpUsername,
-    stagingBranch,
-    template: args.template,
-    productionBranch,
-  });
+  printCreateSummary(destinationDir, answers);
 }
 
 async function collectUpdateAnswers(args) {
@@ -1021,115 +272,6 @@ async function collectUpdateAnswers(args) {
   };
 }
 
-function buildCreateAnswers(input) {
-  const directory = input.directory.trim();
-  const slug = slugify(path.basename(directory));
-  const appName = input.appName.trim();
-  const databaseName = slug.replace(/-/g, "_") || "asaje_app";
-  const swaggerPassword = randomSecret(20);
-  const jwtSecret = randomSecret(32);
-  const corsAllowedOrigins = [
-    `http://localhost:${input.adminPort}`,
-    ...splitCsv(input.corsAllowedOrigins || ""),
-  ];
-
-  return {
-    admin: input.seedAdmin
-      ? {
-          email: input.adminEmail.trim(),
-          name: input.adminName.trim(),
-          password: input.adminPassword,
-        }
-      : null,
-    adminPort: input.adminPort,
-    apiPort: input.apiPort,
-    appName,
-    aws: {
-      accessKeyId: (input.awsAccessKeyId || "").trim(),
-      bucket: (input.awsBucket || "").trim(),
-      endpointUrl: (input.awsEndpointURL || "").trim(),
-      region: (input.awsRegion || "us-east-1").trim(),
-      secretAccessKey: input.awsSecretAccessKey || "",
-    },
-    branch: input.branch,
-    brevoApiKey: input.brevoApiKey || "",
-    bucketBasePath: (input.bucketBasePath || slug).trim(),
-    corsAllowedOrigins,
-    databaseName,
-    defaultLocale: input.defaultLocale,
-    directory,
-    github: {
-      enabled: Boolean(input.enableGithubWorkflow),
-      branchEnvironments: Boolean(input.enableGithubWorkflow)
-        ? [
-            { branch: (input.productionBranch || "main").trim(), environment: "production" },
-            { branch: (input.stagingBranch || "develop").trim(), environment: "staging" },
-          ].filter((entry, index, items) => entry.branch && items.findIndex((candidate) => candidate.branch === entry.branch) === index)
-        : [],
-    },
-    includeLanding: Boolean(input.includeLanding),
-    includePwa: Boolean(input.includePwa),
-    installDependencies: input.installDependencies,
-    jwtSecret,
-    mailFromEmail: input.mailFromEmail.trim(),
-    mailFromName: input.mailFromName.trim(),
-    mailProvider: input.mailProvider,
-    mailchimpApiKey: input.mailchimpApiKey,
-    minio: {
-      accessKey: input.minioAccessKey || "minioadmin",
-      bucket: input.minioBucket || "boilerplate-files",
-      endpoint: input.minioEndpoint || "localhost",
-      port: input.minioPort || 9000,
-      publicUrl:
-        input.minioPublicURL || `${input.minioUseSSL ? "https" : "http"}://${input.minioEndpoint}:${input.minioPort}`,
-      secretKey: input.minioSecretKey || "minioadmin",
-      useSSL: Boolean(input.minioUseSSL),
-    },
-    realtimePort: input.realtimePort,
-    seedAdmin: input.seedAdmin,
-    seedUser: input.seedUser,
-    slug,
-    smtp: {
-      host: (input.smtpHost || "").trim(),
-      password: input.smtpPassword || "",
-      port: input.smtpPort || 587,
-      useSSL: Boolean(input.smtpUseSSL),
-      username: (input.smtpUsername || "").trim(),
-    },
-    standardUser: input.seedUser
-      ? {
-          email: input.seedUserEmail.trim(),
-          name: input.seedUserName.trim(),
-          password: input.seedUserPassword,
-        }
-      : null,
-    startInfra: input.startInfra,
-    storageProvider: input.storageProvider,
-    swaggerPassword,
-    swaggerUsername: input.swaggerUsername.trim(),
-    template: input.template,
-  };
-}
-
-function buildCreateRailwayServices(answers) {
-  return DEFAULT_RAILWAY_APP_SERVICE_SPECS.filter((spec) => {
-    if (spec.key === "landing") {
-      return answers.includeLanding;
-    }
-    if (spec.key === "pwa") {
-      return answers.includePwa;
-    }
-    return true;
-  }).map((spec) => ({
-    aliases: [...spec.aliases],
-    baseName: spec.baseName,
-    directory: spec.directory,
-    dockerfile: spec.key === "worker" ? "api/Dockerfile" : `${spec.directory}/Dockerfile`,
-    key: spec.key,
-    seedImage: spec.key === "admin" || spec.key === "landing" || spec.key === "pwa" ? "nginx:1.29-alpine" : "alpine:3.22",
-  }));
-}
-
 async function writeProjectConfig(destinationDir, answers) {
   const config = {
     projectName: answers.appName,
@@ -1189,7 +331,7 @@ async function writeEnvFiles(destinationDir, answers) {
       VITE_API_BASE_URL: `http://localhost:${answers.apiPort}/api/v1`,
       VITE_API_TIMEOUT_MS: "15000",
       VITE_REALTIME_BASE_URL: `http://localhost:${answers.realtimePort}`,
-      VITE_REALTIME_DEFAULT_TRANSPORT: "sse",
+      VITE_REALTIME_DEFAULT_TRANSPORT: "ws",
       VITE_REALTIME_RECONNECT_DELAY_MS: "3000",
     }),
   );
@@ -1307,111 +449,8 @@ async function writeProjectReadme(destinationDir, answers) {
   await fs.writeFile(path.join(destinationDir, "README.md"), buildProjectReadmeContent(answers));
 }
 
-function buildProjectReadmeContent(answers) {
-  const surfaces = [
-    "- `admin/`: Vue 3 admin SPA for back-office and internal tooling",
-    "- `api/`: Go HTTP API with clean architecture and PostgreSQL",
-    "- `realtime-gateway/`: Go realtime transport service for SSE/WebSocket",
-    answers.includeLanding ? "- `landing/`: optional public marketing surface" : null,
-    answers.includePwa ? "- `pwa/`: optional installable end-user PWA surface" : null,
-  ].filter(Boolean).join("\n");
-
-  const ciMappings = (answers.github?.branchEnvironments || [])
-    .map((entry) => `- \`${entry.branch}\` -> \`${entry.environment}\``)
-    .join("\n");
-
-  return `# ${answers.appName}
-
-Generated with \`create-asaje-go-vue\` / \`asaje\`.
-
-## Stack
-
-- Frontend admin: Vue 3, Vite, Pinia, Vue Router, vue-i18n, shadcn-vue
-- API: Go, Gin, GORM, PostgreSQL, JWT
-- Async and realtime: RabbitMQ + realtime gateway (SSE/WebSocket)
-- File storage: ${answers.storageProvider === "aws" ? "AWS S3" : "MinIO / S3-compatible"}
-- Optional mail providers: Mailchimp Transactional, Brevo, SMTP
-- Deployment tooling: Railway + GitHub Actions via \`asaje\`
-
-## Project Surfaces
-
-${surfaces}
-
-## How Things Are Linked
-
-- The admin and PWA call the API through domain API modules, not raw fetches.
-- The API owns business logic and persistence.
-- The API publishes async tasks and realtime events to RabbitMQ.
-- The realtime gateway consumes realtime events and pushes them to browsers.
-- File uploads go through the API and object storage, with stable media URLs exposed by the API.
-
-## Local Development
-
-Install and start the project:
-
-\`\`\`bash
-docker compose up -d
-npx -p create-asaje-go-vue asaje start .
-\`\`\`
-
-Useful local URLs:
-
-- Admin: http://localhost:${answers.adminPort}
-${answers.includeLanding ? `- Landing: http://localhost:8088
-` : ""}${answers.includePwa ? `- PWA: http://localhost:4174
-` : ""}- API: http://localhost:${answers.apiPort}/api/v1
-- Swagger: http://localhost:${answers.apiPort}/swagger/index.html
-- Realtime gateway: http://localhost:${answers.realtimePort}
-
-## Asaje Commands
-
-- \`asaje start .\`: run local services
-- \`asaje doctor .\`: check tooling and project readiness
-- \`asaje update .\`: update managed boilerplate files from the template
-- \`asaje sync-project-config .\`: rescan the project and rewrite config manifests
-- \`asaje setup-railway .\`: provision Railway resources and first deploy
-- \`asaje update-railway .\`: reconcile Railway resources, services, and variables
-- \`asaje sync-railway-env .\`: sync only Railway environment variables
-- \`asaje deploy-railway .\`: deploy the current source tree to Railway
-- \`asaje sync-github-workflow .\`: regenerate the GitHub Actions Railway workflow from config
-
-## Railway And GitHub Actions
-
-- Railway variable mode defaults to \`preserve-remote\`, so existing Railway values are kept unless you explicitly override them in \`asaje.config.json\`.
-${answers.github?.enabled ? `- GitHub Actions deploy workflow is generated in \`.github/workflows/deploy-railway.yml\`.
-- Branch to environment mapping:
-${ciMappings}
-- Add \`RAILWAY_TOKEN\` to your GitHub repository secrets before enabling automatic deploys.
-` : "- No GitHub Actions Railway workflow was generated during bootstrap. You can enable it later in \`asaje.config.json\` and run \`asaje sync-github-workflow .\`.\n"}
-## Important Files
-
-- \`asaje.config.json\`: project config, Railway config, CI/CD metadata
-- \`asaje.railway.json\`: local manifest of discovered Railway services/resources
-- \`api/notifications.yaml\`: generic notification event/channel templates
-- \`api/crons.yaml\`: worker cron configuration
-
-## Notes
-
-- This project is designed to stay modular: keep generic infrastructure in the boilerplate, and move product-specific business logic into your app domain.
-- When you add new app surfaces or Dockerfiles, rerun \`asaje sync-project-config .\`.
-`;
-}
-
-function buildReadmeAnswersFromProjectConfig(projectDir, projectConfig) {
-  const ports = projectConfig?.ports || {};
-  const appServiceSpecs = resolveRailwayAppServiceSpecs(projectConfig);
-  const githubConfig = getGithubActionsDeployConfig(projectConfig);
-
-  return {
-    adminPort: Number(ports.admin || 5173),
-    apiPort: Number(ports.api || 8080),
-    appName: String(projectConfig?.projectName || path.basename(projectDir)),
-    github: githubConfig,
-    includeLanding: appServiceSpecs.some((spec) => spec.key === "landing"),
-    includePwa: appServiceSpecs.some((spec) => spec.key === "pwa"),
-    realtimePort: Number(ports.realtime || 8090),
-    storageProvider: String(projectConfig?.services?.storageProvider || "minio"),
-  };
+async function writeProjectMakefile(destinationDir, answers) {
+  await fs.writeFile(path.join(destinationDir, "Makefile"), buildProjectMakefileContent(answers));
 }
 
 async function writeGithubWorkflowFromProjectConfig(projectDir, projectConfig) {
@@ -1430,147 +469,6 @@ async function writeGithubWorkflowFromProjectConfig(projectDir, projectConfig) {
   await fs.writeFile(workflowPath, buildGithubWorkflowContent(answers));
 }
 
-function getGithubActionsDeployConfig(projectConfig) {
-  const deployRailway = projectConfig?.ci?.githubActions?.deployRailway;
-  const rawMappings = Array.isArray(deployRailway?.branchEnvironments) ? deployRailway.branchEnvironments : [];
-  const branchEnvironments = rawMappings
-    .map((entry) => ({
-      branch: String(entry?.branch || "").trim(),
-      environment: String(entry?.environment || "").trim(),
-    }))
-    .filter((entry, index, items) => entry.branch && entry.environment && items.findIndex((candidate) => candidate.branch === entry.branch) === index);
-
-  return {
-    branchEnvironments,
-    enabled: Boolean(deployRailway?.enabled) && branchEnvironments.length > 0,
-  };
-}
-
-function buildGithubWorkflowContent(answers) {
-  const branchEnvironments = answers.github.branchEnvironments;
-  const branchList = branchEnvironments.map((entry) => `      - ${entry.branch}`).join("\n");
-
-  const branchCase = branchEnvironments
-    .map((entry) => `            ${entry.branch}) echo "environment=${entry.environment}" >> "$GITHUB_OUTPUT" ;;
-`)
-    .join("");
-
-  const managedServices = buildCreateRailwayServices(answers).map((spec) => spec.key);
-  const hasLanding = managedServices.includes("landing");
-  const hasPwa = managedServices.includes("pwa");
-
-  return `name: Deploy Railway
-
-on:
-  push:
-    branches:
-${branchList}
-  workflow_dispatch:
-
-jobs:
-  detect-changes:
-    runs-on: ubuntu-latest
-    outputs:
-      admin: \${{ steps.filter.outputs.admin }}
-      api: \${{ steps.filter.outputs.api }}
-      config: \${{ steps.filter.outputs.config }}
-      landing: \${{ steps.filter.outputs.landing }}
-      pwa: \${{ steps.filter.outputs.pwa }}
-      realtime: \${{ steps.filter.outputs.realtime }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - uses: dorny/paths-filter@v3
-        id: filter
-        with:
-          filters: |
-            api:
-              - 'api/**'
-            realtime:
-              - 'realtime-gateway/**'
-            admin:
-              - 'admin/**'
-            landing:
-              - 'landing/**'
-            pwa:
-              - 'pwa/**'
-            config:
-              - 'asaje.config.json'
-              - 'asaje.railway.json'
-              - 'docker-compose.yml'
-
-  deploy:
-    needs: detect-changes
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-
-      - name: Install Railway CLI
-        run: npm install -g @railway/cli
-
-      - name: Resolve target environment
-        id: target
-        shell: bash
-        run: |
-          branch="\${GITHUB_REF_NAME}"
-          case "$branch" in
-${branchCase}            *) echo "Unsupported branch: $branch" >&2; exit 1 ;;
-          esac
-
-      - name: Sync Railway environment
-        if: needs.detect-changes.outputs.config == 'true'
-        env:
-          RAILWAY_TOKEN: \${{ secrets.RAILWAY_TOKEN }}
-        run: npx -p create-asaje-go-vue@latest asaje sync-railway-env . --yes --environment \${{ steps.target.outputs.environment }}
-
-      - name: Deploy api
-        if: needs.detect-changes.outputs.api == 'true' || needs.detect-changes.outputs.config == 'true'
-        env:
-          RAILWAY_TOKEN: \${{ secrets.RAILWAY_TOKEN }}
-        run: npx -p create-asaje-go-vue@latest asaje deploy-railway . --service api --environment \${{ steps.target.outputs.environment }}
-
-      - name: Deploy worker
-        if: needs.detect-changes.outputs.api == 'true' || needs.detect-changes.outputs.config == 'true'
-        env:
-          RAILWAY_TOKEN: \${{ secrets.RAILWAY_TOKEN }}
-        run: npx -p create-asaje-go-vue@latest asaje deploy-railway . --service worker --environment \${{ steps.target.outputs.environment }}
-
-      - name: Deploy realtime
-        if: needs.detect-changes.outputs.realtime == 'true' || needs.detect-changes.outputs.config == 'true'
-        env:
-          RAILWAY_TOKEN: \${{ secrets.RAILWAY_TOKEN }}
-        run: npx -p create-asaje-go-vue@latest asaje deploy-railway . --service realtime --environment \${{ steps.target.outputs.environment }}
-
-      - name: Deploy admin
-        if: needs.detect-changes.outputs.admin == 'true' || needs.detect-changes.outputs.config == 'true'
-        env:
-          RAILWAY_TOKEN: \${{ secrets.RAILWAY_TOKEN }}
-        run: npx -p create-asaje-go-vue@latest asaje deploy-railway . --service admin --environment \${{ steps.target.outputs.environment }}
-${hasLanding ? `
-      - name: Deploy landing
-        if: needs.detect-changes.outputs.landing == 'true' || needs.detect-changes.outputs.config == 'true'
-        env:
-          RAILWAY_TOKEN: \${{ secrets.RAILWAY_TOKEN }}
-        run: npx -p create-asaje-go-vue@latest asaje deploy-railway . --service landing --environment \${{ steps.target.outputs.environment }}
-` : ""}${hasPwa ? `
-      - name: Deploy pwa
-        if: needs.detect-changes.outputs.pwa == 'true' || needs.detect-changes.outputs.config == 'true'
-        env:
-          RAILWAY_TOKEN: \${{ secrets.RAILWAY_TOKEN }}
-        run: npx -p create-asaje-go-vue@latest asaje deploy-railway . --service pwa --environment \${{ steps.target.outputs.environment }}
-` : ""}`;
-}
-
 function printCreateSummary(destinationDir, answers) {
   console.log(pc.green("\nSetup complete."));
   console.log(`- Project: ${pc.bold(answers.appName)}`);
@@ -1609,7 +507,11 @@ async function runStart(argv) {
   const projectDir = path.resolve(process.cwd(), answers.directory);
 
   await ensureProjectStructure(projectDir);
-  await ensureEnvFiles(projectDir);
+  await ensureEnvFiles(projectDir, {
+    onCreated(spec) {
+      console.log(pc.yellow(`- Created ${spec.envPath} from ${spec.examplePath}`));
+    },
+  });
 
   if (answers.installDependencies) {
     console.log(pc.dim("\nInstalling frontend and Go dependencies..."));
@@ -1836,7 +738,7 @@ async function runSyncGithubWorkflow(argv) {
 }
 
 async function runSetupRailway(argv) {
-  const args = parseSetupRailwayArgs(argv);
+  const args = parseSetupRailwayArgs(argv, { defaultBucket: DEFAULT_RAILWAY_BUCKET });
   const answers = await collectSetupRailwayAnswers(args);
   const projectDir = path.resolve(process.cwd(), answers.directory);
   const projectConfig = await loadProjectConfig(projectDir);
@@ -1992,7 +894,7 @@ async function runUpdateRailway(argv) {
 }
 
 async function runSyncRailwayEnv(argv) {
-  const args = parseSetupRailwayArgs(argv);
+  const args = parseSetupRailwayArgs(argv, { defaultBucket: DEFAULT_RAILWAY_BUCKET });
   const answers = await collectSetupRailwayAnswers(args);
   const projectDir = path.resolve(process.cwd(), answers.directory);
   const projectConfig = await loadProjectConfig(projectDir);
@@ -2330,95 +1232,6 @@ async function runDestroyRailway(argv) {
   }
 }
 
-function parseDirectoryArgs(argv) {
-  return { directory: argv[0] || "." };
-}
-
-function parseSetupRailwayArgs(argv) {
-  const options = {
-    bucket: DEFAULT_RAILWAY_BUCKET,
-    bucketProvided: false,
-    directory: ".",
-    diff: false,
-    dryRun: false,
-    environment: undefined,
-    services: [],
-    yes: false,
-  };
-  const positionals = [];
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-
-    if (arg === "--yes" || arg === "-y") {
-      options.yes = true;
-      continue;
-    }
-
-    if (arg === "--dry-run") {
-      options.dryRun = true;
-      continue;
-    }
-
-    if (arg === "--diff") {
-      options.diff = true;
-      continue;
-    }
-
-    if (arg === "--bucket") {
-      options.bucket = argv[index + 1] || options.bucket;
-      options.bucketProvided = true;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--bucket=")) {
-      options.bucket = arg.split("=")[1] || options.bucket;
-      options.bucketProvided = true;
-      continue;
-    }
-
-    if (arg === "--environment" || arg === "-e") {
-      options.environment = argv[index + 1] || options.environment;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--environment=")) {
-      options.environment = arg.split("=")[1] || options.environment;
-      continue;
-    }
-
-    if (arg === "--service") {
-      options.services.push(argv[index + 1] || "");
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--service=")) {
-      options.services.push(arg.split("=")[1] || "");
-      continue;
-    }
-
-    if (arg === "--services") {
-      options.services.push(...splitCsv(argv[index + 1] || ""));
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--services=")) {
-      options.services.push(...splitCsv(arg.split("=")[1] || ""));
-      continue;
-    }
-
-    positionals.push(arg);
-  }
-
-  options.directory = positionals[0] || options.directory;
-  options.services = [...new Set(options.services.map((service) => service.trim()).filter(Boolean))];
-  return options;
-}
-
 function parsePrintRailwayConfigArgs(argv) {
   const options = {
     directory: ".",
@@ -2604,106 +1417,8 @@ function parseSyncGithubWorkflowArgs(argv) {
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
 
-    if (arg === "--dry-run") {
-      options.dryRun = true;
-      continue;
-    }
-
-    positionals.push(arg);
-  }
-
-  options.directory = positionals[0] || options.directory;
-  return options;
-}
-
-function parseSyncReadmeArgs(argv) {
-  const options = {
-    directory: ".",
-    dryRun: false,
-  };
-  const positionals = [];
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-
-    if (arg === "--dry-run") {
-      options.dryRun = true;
-      continue;
-    }
-
-    positionals.push(arg);
-  }
-
-  options.directory = positionals[0] || options.directory;
-  return options;
-}
-
-function parseDiffRailwayConfigArgs(argv) {
-  const options = {
-    compareEnvironment: undefined,
-    compareFile: undefined,
-    directory: ".",
-    environment: undefined,
-    file: undefined,
-    json: false,
-    showSecrets: false,
-  };
-  const positionals = [];
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-
-    if (arg === "--json") {
-      options.json = true;
-      continue;
-    }
-
-    if (arg === "--show-secrets") {
-      options.showSecrets = true;
-      continue;
-    }
-
-    if (arg === "--environment" || arg === "-e") {
-      options.environment = argv[index + 1] || options.environment;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--environment=")) {
-      options.environment = arg.split("=")[1] || options.environment;
-      continue;
-    }
-
-    if (arg === "--compare-environment") {
-      options.compareEnvironment = argv[index + 1] || options.compareEnvironment;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--compare-environment=")) {
-      options.compareEnvironment = arg.split("=")[1] || options.compareEnvironment;
-      continue;
-    }
-
-    if (arg === "--file" || arg === "-f") {
-      options.file = argv[index + 1] || options.file;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--file=")) {
-      options.file = arg.split("=")[1] || options.file;
-      continue;
-    }
-
-    if (arg === "--compare-file") {
-      options.compareFile = argv[index + 1] || options.compareFile;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--compare-file=")) {
-      options.compareFile = arg.split("=")[1] || options.compareFile;
+    if (arg === "--dry-run") {
+      options.dryRun = true;
       continue;
     }
 
@@ -2711,97 +1426,53 @@ function parseDiffRailwayConfigArgs(argv) {
   }
 
   options.directory = positionals[0] || options.directory;
-  if (!options.compareEnvironment && !options.compareFile) {
-    throw new Error("diff-railway-config requires --compare-environment <name> or --compare-file <snapshot.json>.");
-  }
   return options;
 }
 
-function parseDeployRailwayArgs(argv) {
+function parseSyncReadmeArgs(argv) {
   const options = {
     directory: ".",
     dryRun: false,
-    environment: undefined,
-    services: [],
-    yes: false,
   };
   const positionals = [];
 
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
 
-    if (arg === "--yes" || arg === "-y") {
-      options.yes = true;
-      continue;
-    }
-
     if (arg === "--dry-run") {
       options.dryRun = true;
       continue;
     }
 
-    if (arg === "--environment" || arg === "-e") {
-      options.environment = argv[index + 1] || options.environment;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--environment=")) {
-      options.environment = arg.split("=")[1] || options.environment;
-      continue;
-    }
-
-    if (arg === "--service") {
-      options.services.push(argv[index + 1] || "");
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--service=")) {
-      options.services.push(arg.split("=")[1] || "");
-      continue;
-    }
-
-    if (arg === "--services") {
-      options.services.push(...splitCsv(argv[index + 1] || ""));
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--services=")) {
-      options.services.push(...splitCsv(arg.split("=")[1] || ""));
-      continue;
-    }
-
     positionals.push(arg);
   }
 
   options.directory = positionals[0] || options.directory;
-  options.services = [...new Set(options.services.map((service) => service.trim()).filter(Boolean))];
   return options;
 }
 
-function parseDestroyRailwayArgs(argv) {
+function parseDiffRailwayConfigArgs(argv) {
   const options = {
+    compareEnvironment: undefined,
+    compareFile: undefined,
     directory: ".",
-    dryRun: false,
     environment: undefined,
-    scope: "environment",
-    twoFactorCode: undefined,
-    yes: false,
+    file: undefined,
+    json: false,
+    showSecrets: false,
   };
   const positionals = [];
 
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
 
-    if (arg === "--yes" || arg === "-y") {
-      options.yes = true;
+    if (arg === "--json") {
+      options.json = true;
       continue;
     }
 
-    if (arg === "--dry-run") {
-      options.dryRun = true;
+    if (arg === "--show-secrets") {
+      options.showSecrets = true;
       continue;
     }
 
@@ -2816,25 +1487,36 @@ function parseDestroyRailwayArgs(argv) {
       continue;
     }
 
-    if (arg === "--scope") {
-      options.scope = argv[index + 1] || options.scope;
+    if (arg === "--compare-environment") {
+      options.compareEnvironment = argv[index + 1] || options.compareEnvironment;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith("--compare-environment=")) {
+      options.compareEnvironment = arg.split("=")[1] || options.compareEnvironment;
+      continue;
+    }
+
+    if (arg === "--file" || arg === "-f") {
+      options.file = argv[index + 1] || options.file;
       index += 1;
       continue;
     }
 
-    if (arg.startsWith("--scope=")) {
-      options.scope = arg.split("=")[1] || options.scope;
+    if (arg.startsWith("--file=")) {
+      options.file = arg.split("=")[1] || options.file;
       continue;
     }
 
-    if (arg === "--2fa-code") {
-      options.twoFactorCode = argv[index + 1] || options.twoFactorCode;
+    if (arg === "--compare-file") {
+      options.compareFile = argv[index + 1] || options.compareFile;
       index += 1;
       continue;
     }
 
-    if (arg.startsWith("--2fa-code=")) {
-      options.twoFactorCode = arg.split("=")[1] || options.twoFactorCode;
+    if (arg.startsWith("--compare-file=")) {
+      options.compareFile = arg.split("=")[1] || options.compareFile;
       continue;
     }
 
@@ -2842,10 +1524,9 @@ function parseDestroyRailwayArgs(argv) {
   }
 
   options.directory = positionals[0] || options.directory;
-  if (!["environment", "project"].includes(options.scope)) {
-    throw new Error("--scope must be either 'environment' or 'project'");
+  if (!options.compareEnvironment && !options.compareFile) {
+    throw new Error("diff-railway-config requires --compare-environment <name> or --compare-file <snapshot.json>.");
   }
-
   return options;
 }
 
@@ -3107,27 +1788,16 @@ async function ensureRailwayEnvironmentLinked(projectDir, environment) {
 }
 
 async function readRailwayManifest(projectDir) {
-  const manifestPath = path.join(projectDir, RAILWAY_MANIFEST_FILENAME);
-  if (!(await fs.pathExists(manifestPath))) {
-    return {
-      appServices: {},
-      bucket: DEFAULT_RAILWAY_BUCKET,
-      environmentId: null,
-      environmentName: null,
-      projectSlug: null,
-      projectId: null,
-      projectName: null,
-      resources: {},
-      updatedAt: null,
-    };
-  }
-
-  return fs.readJson(manifestPath);
+  return readRailwayManifestFile(projectDir, {
+    defaultBucket: DEFAULT_RAILWAY_BUCKET,
+    filename: RAILWAY_MANIFEST_FILENAME,
+  });
 }
 
 async function writeRailwayManifest(projectDir, manifest) {
-  const manifestPath = path.join(projectDir, RAILWAY_MANIFEST_FILENAME);
-  await fs.writeJson(manifestPath, manifest, { spaces: 2 });
+  await writeRailwayManifestFile(projectDir, manifest, {
+    filename: RAILWAY_MANIFEST_FILENAME,
+  });
 }
 
 async function loadRailwayContext(projectDir, environment) {
@@ -3177,55 +1847,11 @@ async function discoverRailwayServices(railwayContext, projectDir) {
     return cliServices;
   }
 
-  const auth = getRailwayApiAuth();
-  if (!auth || !railwayContext.projectId) {
+  if (!railwayContext.projectId) {
     return [];
   }
 
-  try {
-    const response = await fetch(RAILWAY_GRAPHQL_ENDPOINT, {
-      body: JSON.stringify({
-        query: `query SetupRailwayServices($projectId: String!) {
-          project(id: $projectId) {
-            services {
-              edges {
-                node {
-                  id
-                  name
-                  icon
-                }
-              }
-            }
-          }
-        }`,
-        variables: {
-          projectId: railwayContext.projectId,
-        },
-      }),
-      headers: {
-        ...auth.headers,
-        "Content-Type": "application/json",
-      },
-      method: "POST",
-    });
-
-    if (!response.ok) {
-      return [];
-    }
-
-    const payload = await response.json();
-    const nodes = payload?.data?.project?.services?.edges || [];
-    return nodes
-      .map((edge) => edge?.node)
-      .filter(Boolean)
-      .map((service) => ({
-        icon: typeof service.icon === "string" ? service.icon : null,
-        id: typeof service.id === "string" ? service.id : null,
-        name: typeof service.name === "string" ? service.name : null,
-      }));
-  } catch {
-    return [];
-  }
+  return fetchRailwayProjectServices(railwayContext.projectId);
 }
 
 async function discoverRailwayServicesViaCli(railwayContext, projectDir) {
@@ -3254,26 +1880,6 @@ async function discoverRailwayServicesViaCli(railwayContext, projectDir) {
   }
 }
 
-function getRailwayApiAuth() {
-  if (process.env.RAILWAY_API_TOKEN) {
-    return {
-      headers: {
-        Authorization: `Bearer ${process.env.RAILWAY_API_TOKEN}`,
-      },
-    };
-  }
-
-  if (process.env.RAILWAY_TOKEN) {
-    return {
-      headers: {
-        "Project-Access-Token": process.env.RAILWAY_TOKEN,
-      },
-    };
-  }
-
-  return null;
-}
-
 async function ensureRailwayResource(config) {
   const manifestEntry = config.manifest.resources?.[config.key];
   const existingService = findRailwayService(config.existingServices, config.aliases, manifestEntry?.serviceName);
@@ -3464,29 +2070,6 @@ function resolveDeployRailwaySpecs(selectedServices, availableSpecs = DEFAULT_RA
   return specs;
 }
 
-function resolveRailwayAppServiceSpecs(projectConfig) {
-  const configuredServices = projectConfig?.railway?.services;
-  if (!Array.isArray(configuredServices) || configuredServices.length === 0) {
-    return DEFAULT_RAILWAY_APP_SERVICE_SPECS.map((spec) => ({ ...spec, aliases: [...spec.aliases] }));
-  }
-
-  const specs = configuredServices.map((service, index) => normalizeRailwayAppServiceSpec(service, index));
-  const seenKeys = new Set();
-  for (const spec of specs) {
-    if (seenKeys.has(spec.key)) {
-      throw new Error(`Duplicate railway.services key \`${spec.key}\`.`);
-    }
-    seenKeys.add(spec.key);
-  }
-
-  return specs;
-}
-
-function getRailwayConfig(projectConfig) {
-  const railwayConfig = projectConfig?.railway;
-  return railwayConfig && typeof railwayConfig === "object" && !Array.isArray(railwayConfig) ? railwayConfig : {};
-}
-
 function listRailwayEnvironmentEntries(projectConfig) {
   const environments = getRailwayConfig(projectConfig).environments;
   if (!environments || typeof environments !== "object" || Array.isArray(environments)) {
@@ -3551,75 +2134,6 @@ function resolveRailwayEnvironmentSelection(projectConfig, requestedEnvironment,
   };
 }
 
-function normalizeRailwayAppServiceSpec(input, index) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    throw new Error(`Invalid railway.services entry at index ${index}.`);
-  }
-
-  const key = slugify(String(input.key || "").trim());
-  const directory = String(input.directory || "").trim().replace(/^\.\//, "").replace(/\/+$/g, "");
-  const baseName = slugify(String(input.baseName || input.key || path.basename(directory) || "").trim());
-  const aliases = [
-    key,
-    baseName,
-    ...(Array.isArray(input.aliases) ? input.aliases : []),
-  ]
-    .map((value) => normalizeRailwayServiceName(value))
-    .filter(Boolean);
-
-  if (!key) {
-    throw new Error("Each railway.services entry needs a non-empty `key`.");
-  }
-  if (!directory) {
-    throw new Error(`Railway service \`${key}\` needs a non-empty \`directory\`.`);
-  }
-  if (!baseName) {
-    throw new Error(`Railway service \`${key}\` needs a valid \`baseName\` or \`key\`.`);
-  }
-
-  return {
-    aliases: [...new Set(aliases)],
-    baseName,
-    directory,
-    dockerfile: String(input.dockerfile || "").trim() || null,
-    key,
-    seedImage: String(input.seedImage || (key === "admin" ? "nginx:1.29-alpine" : "alpine:3.22")).trim(),
-    serviceName: String(input.serviceName || "").trim() || null,
-  };
-}
-
-function resolveRailwayServiceName(spec, projectSlug) {
-  return spec.serviceName || buildRailwayAppServiceName(projectSlug, spec.baseName);
-}
-
-function findRailwayAppServiceSpec(appServiceSpecs, key) {
-  const exact = appServiceSpecs.find((candidate) => candidate.key === key);
-  if (exact) {
-    return exact;
-  }
-
-  const defaultSpec = DEFAULT_RAILWAY_APP_SERVICE_SPECS.find((candidate) => candidate.key === key);
-  if (!defaultSpec) {
-    return null;
-  }
-
-  const defaultNames = [defaultSpec.key, defaultSpec.baseName, ...defaultSpec.aliases].map(normalizeRailwayServiceName);
-  return appServiceSpecs.find((candidate) => {
-    const names = [candidate.key, candidate.baseName, ...candidate.aliases].map(normalizeRailwayServiceName);
-    return names.some((name) => defaultNames.includes(name));
-  }) || null;
-}
-
-function findRailwayServiceByKey(services, appServiceSpecs, manifest, key) {
-  const spec = findRailwayAppServiceSpec(appServiceSpecs, key);
-  if (!spec) {
-    return null;
-  }
-
-  const preferredName = manifest.appServices?.[key]?.serviceName || resolveRailwayServiceName(spec, manifest.projectSlug);
-  return findRailwayService(services, spec.aliases, preferredName);
-}
-
 function resolveRailwayVariablesMode(projectConfig) {
   const mode = String(getRailwayConfig(projectConfig).variablesMode || "preserve-remote").trim().toLowerCase();
   if (!mode) {
@@ -3731,33 +2245,6 @@ function mergeRailwayServiceVariables(registryEntry, variables) {
   };
 }
 
-function assignManagedRailwayServiceVariables(registryEntry, variables, variablesMode) {
-  if (!registryEntry || !registryEntry.name) {
-    return;
-  }
-
-  const nextVariables = {};
-  const existingVariables = registryEntry.existingVariables || {};
-
-  for (const [key, value] of Object.entries(variables || {})) {
-    if (typeof value !== "string" || value.length === 0) {
-      continue;
-    }
-
-    if (
-      variablesMode === "preserve-remote" &&
-      Object.prototype.hasOwnProperty.call(existingVariables, key)
-    ) {
-      nextVariables[key] = existingVariables[key];
-      continue;
-    }
-
-    nextVariables[key] = value;
-  }
-
-  mergeRailwayServiceVariables(registryEntry, nextVariables);
-}
-
 async function hydrateRailwayServiceVariables(projectDir, environment, serviceRegistry) {
   await Promise.all(
     Object.values(serviceRegistry)
@@ -3829,7 +2316,7 @@ async function resolveRailwayVariablePlan(config) {
   const declaredVariables = resolveDeclaredRailwayVariables(config.projectConfig, config.environmentSelection);
   validateDeclaredRailwayVariableTargets(declaredVariables, serviceRegistry);
 
-  if (variablesMode === "preserve-remote") {
+  if (variablesMode === "preserve-remote" || variablesMode === "sync-managed") {
     await hydrateRailwayServiceVariables(config.projectDir, config.railwayContext.environmentRef, serviceRegistry);
   }
 
@@ -3880,8 +2367,9 @@ async function resolveRailwayVariablePlan(config) {
     if (infra.objectStorage?.name) {
       Object.assign(variables, buildObjectStorageVariables(infra.objectStorage.name));
     }
-    if (appServices.admin?.name) {
-      variables.CORS_ALLOWED_ORIGINS = `https://${railwayReference(appServices.admin.name, "RAILWAY_PUBLIC_DOMAIN")}`;
+    const browserOrigins = buildRailwayBrowserOrigins(appServices);
+    if (browserOrigins) {
+      variables.CORS_ALLOWED_ORIGINS = browserOrigins;
     }
     variables.PUBLIC_API_BASE_URL = `https://${railwayReference(appServices.api.name, "RAILWAY_PUBLIC_DOMAIN")}`;
     assignManagedRailwayServiceVariables(serviceRegistry.api, variables, variablesMode);
@@ -3896,8 +2384,9 @@ async function resolveRailwayVariablePlan(config) {
     if (appServices.api?.name) {
       variables.JWT_SECRET = railwayReference(appServices.api.name, "JWT_SECRET");
     }
-    if (appServices.admin?.name) {
-      variables.CORS_ALLOWED_ORIGINS = `https://${railwayReference(appServices.admin?.name || "admin", "RAILWAY_PUBLIC_DOMAIN")}`;
+    const browserOrigins = buildRailwayBrowserOrigins(appServices);
+    if (browserOrigins) {
+      variables.CORS_ALLOWED_ORIGINS = browserOrigins;
     }
     assignManagedRailwayServiceVariables(serviceRegistry.realtime, variables, variablesMode);
   }
@@ -4109,7 +2598,7 @@ function buildAdminDefaults(localEnv) {
   return {
     VITE_API_TIMEOUT_MS: localEnv.admin.VITE_API_TIMEOUT_MS || "15000",
     VITE_APP_NAME: localEnv.admin.VITE_APP_NAME || "Admin Blueprint",
-    VITE_REALTIME_DEFAULT_TRANSPORT: localEnv.admin.VITE_REALTIME_DEFAULT_TRANSPORT || "sse",
+    VITE_REALTIME_DEFAULT_TRANSPORT: localEnv.admin.VITE_REALTIME_DEFAULT_TRANSPORT || "ws",
     VITE_REALTIME_RECONNECT_DELAY_MS: localEnv.admin.VITE_REALTIME_RECONNECT_DELAY_MS || "3000",
   };
 }
@@ -4137,14 +2626,6 @@ function sanitizeSecret(value, placeholder) {
   return normalized;
 }
 
-async function tryReadEnvFile(filePath) {
-  if (!(await fs.pathExists(filePath))) {
-    return {};
-  }
-
-  return readEnvFile(filePath);
-}
-
 function buildObjectStorageVariables(serviceName) {
   return {
     MINIO_ACCESS_KEY: railwayReference(serviceName, "MINIO_ROOT_USER"),
@@ -4209,185 +2690,42 @@ async function applyRailwayVariables(config) {
   });
 }
 
-function buildRailwayVariableDiff(currentVariables, nextVariables, options = {}) {
-  const changes = [];
-  const includeRemoved = options.includeRemoved ?? true;
-  const keys = [...new Set([...Object.keys(nextVariables || {}), ...(includeRemoved ? Object.keys(currentVariables || {}) : [])])].sort();
-  for (const key of keys) {
-    const rawCurrent = currentVariables?.[key];
-    const rawNext = nextVariables?.[key];
-    const currentValue = typeof rawCurrent === "string" ? rawCurrent : rawCurrent === undefined || rawCurrent === null ? undefined : String(rawCurrent);
-    const nextValue = typeof rawNext === "string" ? rawNext : rawNext === undefined || rawNext === null ? undefined : String(rawNext);
-    if (nextValue === undefined && currentValue === undefined) {
-      continue;
-    }
-
-    let status = "unchanged";
-    if (currentValue === undefined) {
-      status = "added";
-    } else if (nextValue === undefined) {
-      status = "removed";
-    } else if (currentValue !== nextValue) {
-      status = "changed";
-    }
-
-    changes.push({ currentValue, key, nextValue, status });
-  }
-
-  return {
-    added: changes.filter((item) => item.status === "added"),
-    changed: changes.filter((item) => item.status === "changed"),
-    removed: changes.filter((item) => item.status === "removed"),
-    unchanged: changes.filter((item) => item.status === "unchanged"),
-  };
-}
-
 function printRailwayVariableDiff(serviceName, diff) {
   const counts = [`${diff.added.length} added`, `${diff.changed.length} changed`, `${diff.unchanged.length} unchanged`].join(", ");
   console.log(`- ${pc.cyan(serviceName)} diff: ${counts}`);
 
   for (const item of [...diff.added, ...diff.changed]) {
-    const before = item.currentValue === undefined ? "<unset>" : formatRailwayVariableValue(item.key, item.currentValue);
-    const after = formatRailwayVariableValue(item.key, item.nextValue);
-    console.log(`  ${item.key}: ${before} -> ${after}`);
-  }
-}
-
-function sanitizeVariablesForOutput(variables, showSecrets = false) {
-  const sanitized = {};
-  for (const [key, value] of Object.entries(variables)) {
-    sanitized[key] = formatRailwayVariableValue(key, value, showSecrets);
-  }
-  return sanitized;
-}
-
-function formatRailwayVariableValue(key, value, showSecrets = false) {
-  if (value === undefined) {
-    return "<unset>";
-  }
-
-  const normalizedKey = String(key || "").toUpperCase();
-  if (!showSecrets && /(SECRET|PASSWORD|TOKEN|API_KEY|ACCESS_KEY|SECRET_KEY|ERLANG_COOKIE)/.test(normalizedKey)) {
-    return redactRailwayVariableValue(value);
-  }
-
-  return String(value);
-}
-
-function redactRailwayVariableValue(value) {
-  const textValue = String(value || "");
-  if (textValue.length <= 8) {
-    return "[redacted]";
-  }
-  return `${textValue.slice(0, 3)}...[redacted]...${textValue.slice(-2)}`;
-}
-
-function printResolvedRailwayConfig(payload) {
-  console.log(pc.bold("\nRailway config"));
-  console.log(`- Directory: ${pc.bold(payload.directory)}`);
-  console.log(`- Variables mode: ${pc.bold(payload.variablesMode)}`);
-  console.log(`- Environment key: ${pc.bold(payload.environment.configKey || "<none>")}`);
-  console.log(`- Railway environment: ${pc.bold(payload.environment.railwayEnvironment || "<linked default>")}`);
-
-  console.log(pc.bold("\nServices"));
-  for (const service of payload.services) {
-    console.log(`- ${pc.bold(service.key)} -> ${service.serviceName}`);
-    console.log(`  directory: ${service.directory}`);
-    if (service.dockerfile) {
-      console.log(`  dockerfile: ${service.dockerfile}`);
-    }
-    console.log(`  aliases: ${service.aliases.join(", ")}`);
-    const variableEntries = Object.entries(service.variables || {});
-    if (variableEntries.length === 0) {
-      console.log("  variables: <none>");
-      continue;
-    }
-    console.log("  variables:");
-    for (const [key, value] of variableEntries.sort(([left], [right]) => left.localeCompare(right))) {
-      console.log(`    ${key}=${value}`);
-    }
-  }
-}
-
-function buildRailwayConfigExportFilename(payload) {
-  const envSuffix = slugify(payload.environment.configKey || payload.environment.railwayEnvironment || "default") || "default";
-  return path.join(payload.directory, `.railway-config.${envSuffix}.json`);
-}
-
-async function readRailwayConfigSnapshot(filePath) {
-  const absolutePath = path.resolve(process.cwd(), filePath);
-  if (!(await fs.pathExists(absolutePath))) {
-    throw new Error(`Railway config snapshot not found: ${absolutePath}`);
-  }
-
-  const payload = await fs.readJson(absolutePath);
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    throw new Error(`Railway config snapshot is invalid: ${absolutePath}`);
-  }
-
-  if (!Array.isArray(payload.services)) {
-    throw new Error(`Railway config snapshot is missing a services array: ${absolutePath}`);
-  }
-
-  return payload;
-}
-
-function assertRailwaySnapshotImportable(snapshot) {
-  const redactedEntries = [];
-  for (const service of snapshot.services || []) {
-    for (const [key, value] of Object.entries(service.variables || {})) {
-      if (String(value || "").includes("[redacted]")) {
-        redactedEntries.push(`${service.key}.${key}`);
-      }
-    }
-  }
-
-  if (redactedEntries.length > 0) {
-    throw new Error(
-      `Snapshot contains redacted values and cannot be imported safely. Re-export with --show-secrets. Problem keys: ${redactedEntries.join(", ")}`,
-    );
-  }
-}
-
-function buildRailwayConfigSnapshotDiff(left, right) {
-  const leftServices = new Map((left.services || []).map((service) => [service.key, service]));
-  const rightServices = new Map((right.services || []).map((service) => [service.key, service]));
-  const serviceKeys = [...new Set([...leftServices.keys(), ...rightServices.keys()])].sort();
-
-  const services = serviceKeys.map((key) => {
-    const leftService = leftServices.get(key) || null;
-    const rightService = rightServices.get(key) || null;
-    return {
-      key,
-      metadata: {
-        directory: buildRailwayFieldDiff(leftService?.directory, rightService?.directory),
-        dockerfile: buildRailwayFieldDiff(leftService?.dockerfile, rightService?.dockerfile),
-        serviceName: buildRailwayFieldDiff(leftService?.serviceName, rightService?.serviceName),
-      },
-      status: !leftService ? "added" : !rightService ? "removed" : "present",
-      variables: buildRailwayVariableDiff(leftService?.variables || {}, rightService?.variables || {}),
-    };
-  });
-
-  return {
-    left: {
-      directory: left.directory,
-      environment: left.environment,
-    },
-    right: {
-      directory: right.directory,
-      environment: right.environment,
-    },
-    services,
-  };
+    const before = item.currentValue === undefined ? "<unset>" : formatRailwayVariableValue(item.key, item.currentValue);
+    const after = formatRailwayVariableValue(item.key, item.nextValue);
+    console.log(`  ${item.key}: ${before} -> ${after}`);
+  }
 }
 
-function buildRailwayFieldDiff(leftValue, rightValue) {
-  return {
-    left: leftValue ?? null,
-    right: rightValue ?? null,
-    status: leftValue === rightValue ? "unchanged" : leftValue === undefined ? "added" : rightValue === undefined ? "removed" : "changed",
-  };
+function printResolvedRailwayConfig(payload) {
+  console.log(pc.bold("\nRailway config"));
+  console.log(`- Directory: ${pc.bold(payload.directory)}`);
+  console.log(`- Variables mode: ${pc.bold(payload.variablesMode)}`);
+  console.log(`- Environment key: ${pc.bold(payload.environment.configKey || "<none>")}`);
+  console.log(`- Railway environment: ${pc.bold(payload.environment.railwayEnvironment || "<linked default>")}`);
+
+  console.log(pc.bold("\nServices"));
+  for (const service of payload.services) {
+    console.log(`- ${pc.bold(service.key)} -> ${service.serviceName}`);
+    console.log(`  directory: ${service.directory}`);
+    if (service.dockerfile) {
+      console.log(`  dockerfile: ${service.dockerfile}`);
+    }
+    console.log(`  aliases: ${service.aliases.join(", ")}`);
+    const variableEntries = Object.entries(service.variables || {});
+    if (variableEntries.length === 0) {
+      console.log("  variables: <none>");
+      continue;
+    }
+    console.log("  variables:");
+    for (const [key, value] of variableEntries.sort(([left], [right]) => left.localeCompare(right))) {
+      console.log(`    ${key}=${value}`);
+    }
+  }
 }
 
 function printRailwayConfigSnapshotDiff(diff) {
@@ -4411,33 +2749,6 @@ function printRailwayConfigSnapshotDiff(diff) {
   }
 }
 
-function sanitizeRailwayConfigSnapshotDiff(diff, showSecrets) {
-  if (showSecrets) {
-    return diff;
-  }
-
-  return {
-    ...diff,
-    services: diff.services.map((service) => ({
-      ...service,
-      variables: {
-        added: service.variables.added.map(sanitizeRailwayDiffEntry),
-        changed: service.variables.changed.map(sanitizeRailwayDiffEntry),
-        removed: service.variables.removed.map(sanitizeRailwayDiffEntry),
-        unchanged: service.variables.unchanged.map(sanitizeRailwayDiffEntry),
-      },
-    })),
-  };
-}
-
-function sanitizeRailwayDiffEntry(entry) {
-  return {
-    ...entry,
-    currentValue: formatRailwayVariableValue(entry.key, entry.currentValue),
-    nextValue: formatRailwayVariableValue(entry.key, entry.nextValue),
-  };
-}
-
 function formatRailwayDiffSide(side) {
   const env = side.environment?.configKey || side.environment?.railwayEnvironment || "default";
   return `${side.directory || "<snapshot>"} (${env})`;
@@ -4510,80 +2821,6 @@ async function waitForCreatedRailwayService(config) {
   );
 }
 
-function findRailwayService(services, aliases, preferredName) {
-  if (preferredName) {
-    const exact = services.find(
-      (service) => normalizeRailwayServiceName(service.name) === normalizeRailwayServiceName(preferredName),
-    );
-    if (exact) {
-      return exact;
-    }
-  }
-
-  const normalizedAliases = aliases.map(normalizeRailwayServiceName);
-  return services.find((service) => {
-    const normalizedName = normalizeRailwayServiceName(service.name);
-    return normalizedAliases.some((alias) => normalizedName === alias || normalizedName.endsWith(`-${alias}`));
-  });
-}
-
-function normalizeRailwayServiceName(value) {
-  return String(value || "")
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-}
-
-function normalizeRailwayServices(services) {
-  const seen = new Set();
-  const normalized = [];
-
-  for (const service of services) {
-    const name = pickFirstString([service.name, service.serviceName]);
-    if (!name) {
-      continue;
-    }
-
-    const id = pickFirstString([service.id, service.serviceId]);
-    const key = `${normalizeRailwayServiceName(name)}:${id || ""}`;
-    if (seen.has(key)) {
-      continue;
-    }
-
-    seen.add(key);
-    normalized.push({ id, name });
-  }
-
-  return normalized;
-}
-
-function findCreatedRailwayService(config) {
-  const beforeServices = normalizeRailwayServices(config.beforeServices);
-  const afterServices = normalizeRailwayServices(config.servicesAfter);
-  const beforeKeys = new Set(beforeServices.map(createRailwayServiceIdentity));
-  const newServices = afterServices.filter((service) => !beforeKeys.has(createRailwayServiceIdentity(service)));
-
-  if (newServices.length === 1) {
-    return newServices[0];
-  }
-
-  const aliasMatch = findRailwayService(newServices, config.aliases, config.manifestServiceName);
-  if (aliasMatch) {
-    return aliasMatch;
-  }
-
-  return null;
-}
-
-function createRailwayServiceIdentity(service) {
-  if (service?.id) {
-    return `id:${service.id}`;
-  }
-
-  return `name:${normalizeRailwayServiceName(service?.name)}`;
-}
-
 function normalizeRailwayVariables(input) {
   const normalized = {};
 
@@ -4604,27 +2841,6 @@ function normalizeRailwayVariables(input) {
   return normalized;
 }
 
-function updateRailwayManifestAppServices(manifest, services, appServiceSpecs, projectSlug) {
-  manifest.appServices ||= {};
-
-  for (const spec of appServiceSpecs) {
-    const key = spec.key;
-    const service = findRailwayService(
-      services,
-      spec.aliases,
-      manifest.appServices[key]?.serviceName || resolveRailwayServiceName(spec, projectSlug || manifest.projectSlug),
-    );
-    if (!service?.name) {
-      continue;
-    }
-
-    manifest.appServices[key] = {
-      serviceId: service.id || manifest.appServices[key]?.serviceId || null,
-      serviceName: service.name,
-    };
-  }
-}
-
 function extractRailwayServiceCandidates(input) {
   const candidates = [];
 
@@ -4795,302 +3011,36 @@ function printRailwaySetupSummary(config) {
   }
 
   if (!getRailwayApiAuth()) {
-    console.log(pc.yellow("\nNote: Set RAILWAY_API_TOKEN or RAILWAY_TOKEN to let future runs verify remote services before provisioning."));
-  }
-}
-
-function printRailwayDeploySummary(config) {
-  console.log(pc.bold("\nRailway deploy"));
-  console.log(`- Directory: ${pc.bold(config.projectDir)}`);
-  if (config.railwayContext.projectName || config.railwayContext.projectId) {
-    console.log(`- Project: ${pc.bold(config.railwayContext.projectName || config.railwayContext.projectId)}`);
-  }
-  if (config.railwayContext.environmentName || config.railwayContext.environmentId) {
-    console.log(`- Environment: ${pc.bold(config.railwayContext.environmentName || config.railwayContext.environmentId)}`);
-  }
-  console.log(`- Default managed services: ${pc.bold("api, worker, realtime-gateway, admin")}`);
-  console.log(`- Services: ${pc.bold(config.selectedServices.join(", "))}`);
-
-  console.log(pc.bold("\nDeployments"));
-  if (config.deploySummary.length === 0) {
-    console.log("- No application deployments were triggered");
-  } else {
-    for (const item of config.deploySummary) {
-      console.log(`- ${pc.bold(item.serviceName)}: ${item.status} from ${item.directory}/`);
-    }
-  }
-
-  if (config.dryRun) {
-    console.log(`- Dry run only, ${pc.bold(RAILWAY_MANIFEST_FILENAME)} was not written`);
-  } else {
-    console.log(`- Manifest written to ${pc.bold(RAILWAY_MANIFEST_FILENAME)} for future runs`);
-  }
-}
-
-function parseStartArgs(argv) {
-  const options = {
-    directory: ".",
-    installDependencies: undefined,
-    profile: undefined,
-    startInfra: undefined,
-    yes: false,
-  };
-  const positionals = [];
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-
-    if (arg === "--yes" || arg === "-y") {
-      options.yes = true;
-      continue;
-    }
-
-    if (arg === "--install") {
-      options.installDependencies = true;
-      continue;
-    }
-
-    if (arg === "--skip-install") {
-      options.installDependencies = false;
-      continue;
-    }
-
-    if (arg === "--start-infra") {
-      options.startInfra = true;
-      continue;
-    }
-
-    if (arg === "--skip-infra") {
-      options.startInfra = false;
-      continue;
-    }
-
-    if (arg === "--profile") {
-      options.profile = argv[index + 1] || options.profile;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--profile=")) {
-      options.profile = arg.split("=")[1] || options.profile;
-      continue;
-    }
-
-    if (arg === "--skip-api") {
-      options.api = false;
-      continue;
-    }
-
-    if (arg === "--skip-worker") {
-      options.worker = false;
-      continue;
-    }
-
-    if (arg === "--skip-realtime") {
-      options.realtime = false;
-      continue;
-    }
-
-    if (arg === "--skip-admin") {
-      options.admin = false;
-      continue;
-    }
-
-    if (arg === "--skip-landing") {
-      options.landing = false;
-      continue;
-    }
-
-    if (arg === "--skip-pwa") {
-      options.pwa = false;
-      continue;
-    }
-
-    positionals.push(arg);
-  }
-
-  options.directory = positionals[0] || options.directory;
-  return options;
-}
-
-async function collectStartAnswers(args) {
-  if (args.yes) {
-    return {
-      directory: args.directory,
-      installDependencies: args.installDependencies ?? false,
-      profile: args.profile || inferProfileFromArgs(args) || "full",
-      selectedServices: buildSelectedServices(args),
-      startInfra: args.startInfra ?? true,
-    };
-  }
-
-  const directory = await prompt(
-    text({
-      defaultValue: args.directory,
-      message: "Project directory to start?",
-      placeholder: ".",
-      validate(value) {
-        return value.trim().length === 0 ? "Project directory is required" : undefined;
-      },
-    }),
-  );
-
-  const installDependencies = await prompt(
-    confirm({
-      initialValue: args.installDependencies ?? false,
-      message: "Install dependencies before start?",
-    }),
-  );
-
-  const startInfra = await prompt(
-    confirm({
-      initialValue: args.startInfra ?? true,
-      message: "Start local Docker services?",
-    }),
-  );
-
-  const profile = await prompt(
-    select({
-      initialValue: inferProfileFromArgs(args) || "full",
-      message: "Startup profile?",
-      options: [
-        { label: "Full stack", value: "full" },
-        { label: "Backend only", value: "backend-only" },
-        { label: "Frontend only", value: "frontend-only" },
-        { label: "Custom", value: "custom" },
-      ],
-    }),
-  );
-
-  if (profile !== "custom") {
-    return {
-      directory,
-      installDependencies,
-      profile,
-      selectedServices: profileToServices(profile),
-      startInfra,
-    };
-  }
-
-  const api = await prompt(
-    confirm({
-      initialValue: args.api ?? true,
-      message: "Start API server?",
-    }),
-  );
-  const worker = await prompt(
-    confirm({
-      initialValue: args.worker ?? true,
-      message: "Start API worker?",
-    }),
-  );
-  const realtime = await prompt(
-    confirm({
-      initialValue: args.realtime ?? true,
-      message: "Start realtime gateway?",
-    }),
-  );
-  const admin = await prompt(
-    confirm({
-      initialValue: args.admin ?? true,
-      message: "Start admin frontend?",
-    }),
-  );
-  const landing = await prompt(
-    confirm({
-      initialValue: args.landing ?? true,
-      message: "Start landing surface?",
-    }),
-  );
-  const pwa = await prompt(
-    confirm({
-      initialValue: args.pwa ?? true,
-      message: "Start PWA surface?",
-    }),
-  );
-
-  return {
-    directory,
-    installDependencies,
-    profile: "custom",
-    selectedServices: [api && "api", worker && "worker", realtime && "realtime", admin && "admin", landing && "landing", pwa && "pwa"].filter(Boolean),
-    startInfra,
-  };
-}
-
-function buildSelectedServices(args) {
-  if (args.profile) {
-    return applyServiceOverrides(profileToServices(args.profile), args);
-  }
-
-  return applyServiceOverrides(profileToServices("full"), args);
-}
-
-function inferProfileFromArgs(args) {
-  const selected = [
-    args.api !== false && "api",
-    args.worker !== false && "worker",
-    args.realtime !== false && "realtime",
-    args.admin !== false && "admin",
-    args.landing !== false && "landing",
-    args.pwa !== false && "pwa",
-  ].filter(Boolean);
-
-  if (selected.length === 6) {
-    return "full";
-  }
-
-  if (arraysEqual(selected, profileToServices("backend-only"))) {
-    return "backend-only";
-  }
-
-  if (arraysEqual(selected, profileToServices("frontend-only"))) {
-    return "frontend-only";
-  }
-
-  return undefined;
-}
-
-function profileToServices(profile) {
-  switch (profile) {
-    case "backend-only":
-      return ["api", "worker", "realtime"];
-    case "frontend-only":
-      return ["admin", "landing", "pwa"];
-    case "custom":
-      return [];
-    case "full":
-    default:
-      return ["api", "worker", "realtime", "admin", "landing", "pwa"];
-  }
-}
-
-function applyServiceOverrides(services, args) {
-  return services.filter((service) => args[service] !== false);
-}
-
-function arraysEqual(left, right) {
-  return left.length === right.length && left.every((value, index) => value === right[index]);
+    console.log(pc.yellow("\nNote: Set RAILWAY_API_TOKEN or RAILWAY_TOKEN to let future runs verify remote services before provisioning."));
+  }
 }
 
-async function ensureProjectStructure(projectDir) {
-  const requiredPaths = ["admin", "api", "realtime-gateway", "docker-compose.yml"];
+function printRailwayDeploySummary(config) {
+  console.log(pc.bold("\nRailway deploy"));
+  console.log(`- Directory: ${pc.bold(config.projectDir)}`);
+  if (config.railwayContext.projectName || config.railwayContext.projectId) {
+    console.log(`- Project: ${pc.bold(config.railwayContext.projectName || config.railwayContext.projectId)}`);
+  }
+  if (config.railwayContext.environmentName || config.railwayContext.environmentId) {
+    console.log(`- Environment: ${pc.bold(config.railwayContext.environmentName || config.railwayContext.environmentId)}`);
+  }
+  console.log(`- Default managed services: ${pc.bold("api, worker, realtime-gateway, admin")}`);
+  console.log(`- Services: ${pc.bold(config.selectedServices.join(", "))}`);
 
-  for (const relativePath of requiredPaths) {
-    const target = path.join(projectDir, relativePath);
-    if (!(await fs.pathExists(target))) {
-      throw new Error(`Project root not recognized, missing ${relativePath} in ${projectDir}`);
+  console.log(pc.bold("\nDeployments"));
+  if (config.deploySummary.length === 0) {
+    console.log("- No application deployments were triggered");
+  } else {
+    for (const item of config.deploySummary) {
+      console.log(`- ${pc.bold(item.serviceName)}: ${item.status} from ${item.directory}/`);
     }
   }
-}
 
-async function loadProjectConfig(projectDir) {
-  const configPath = path.join(projectDir, "asaje.config.json");
-  if (!(await fs.pathExists(configPath))) {
-    return null;
+  if (config.dryRun) {
+    console.log(`- Dry run only, ${pc.bold(RAILWAY_MANIFEST_FILENAME)} was not written`);
+  } else {
+    console.log(`- Manifest written to ${pc.bold(RAILWAY_MANIFEST_FILENAME)} for future runs`);
   }
-
-  return fs.readJson(configPath);
 }
 
 async function ensureRailwayAppServiceTargets(projectDir, appServiceSpecs) {
@@ -5109,191 +3059,6 @@ async function ensureRailwayAppServiceTargets(projectDir, appServiceSpecs) {
   }
 }
 
-async function scanProjectForManagedRailwayServices(projectDir) {
-  const dockerfiles = [];
-  await collectDockerfiles(projectDir, "", dockerfiles);
-
-  const scannedSpecs = dockerfiles
-    .map((dockerfilePath) => buildScannedRailwayServiceSpec(projectDir, dockerfilePath))
-    .filter(Boolean)
-    .sort((left, right) => left.directory.localeCompare(right.directory));
-
-  const serviceSpecs = synthesizeDerivedRailwayServices(scannedSpecs);
-
-  return {
-    dockerfiles,
-    serviceSpecs,
-  };
-}
-
-function synthesizeDerivedRailwayServices(serviceSpecs) {
-  const nextSpecs = [...serviceSpecs];
-  const hasAPI = serviceSpecs.some((spec) => spec.key === "api" && spec.directory === "api");
-  const hasWorker = serviceSpecs.some((spec) => spec.key === "worker");
-  if (hasAPI && !hasWorker) {
-    nextSpecs.push({
-      aliases: ["worker", "api-worker"],
-      baseName: "worker",
-      directory: "api",
-      dockerfile: "api/Dockerfile",
-      key: "worker",
-      seedImage: "alpine:3.22",
-      serviceName: null,
-    });
-  }
-
-  return nextSpecs.sort((left, right) => `${left.directory}:${left.key}`.localeCompare(`${right.directory}:${right.key}`));
-}
-
-async function collectDockerfiles(projectDir, relativeDir, results) {
-  const absoluteDir = path.join(projectDir, relativeDir);
-  const entries = await fs.readdir(absoluteDir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const nextRelativePath = relativeDir ? path.posix.join(relativeDir, entry.name) : entry.name;
-    if (entry.isDirectory()) {
-      if (shouldSkipProjectScanDirectory(entry.name, nextRelativePath)) {
-        continue;
-      }
-
-      await collectDockerfiles(projectDir, nextRelativePath, results);
-      continue;
-    }
-
-    if (entry.isFile() && entry.name === "Dockerfile") {
-      results.push(nextRelativePath);
-    }
-  }
-}
-
-function shouldSkipProjectScanDirectory(name, relativePath) {
-  const normalized = String(name || "").trim();
-  if (!normalized) {
-    return false;
-  }
-
-  if ([".git", ".turbo", ".next", ".nuxt", "node_modules", "dist", "build", "coverage", "tmp", "vendor"].includes(normalized)) {
-    return true;
-  }
-
-  if (relativePath === "cli") {
-    return true;
-  }
-
-  return normalized.startsWith(".") && normalized !== ".well-known";
-}
-
-function buildScannedRailwayServiceSpec(projectDir, dockerfilePath) {
-  const directory = path.posix.dirname(dockerfilePath);
-  if (!directory || directory === ".") {
-    return null;
-  }
-
-  const inferred = inferRailwayServiceIdentity(directory);
-  return {
-    aliases: inferred.aliases,
-    baseName: inferred.baseName,
-    directory,
-    dockerfile: dockerfilePath,
-    key: inferred.key,
-    seedImage: inferred.key === "admin" ? "nginx:1.29-alpine" : "alpine:3.22",
-    serviceName: null,
-  };
-}
-
-function inferRailwayServiceIdentity(directory) {
-  const normalizedDirectory = directory.replace(/\/+$/g, "");
-  const directoryName = path.posix.basename(normalizedDirectory);
-  const normalizedName = normalizeRailwayServiceName(directoryName);
-
-  if (["api", "backend", "server"].includes(normalizedName)) {
-    return { aliases: ["api", "backend", "server"], baseName: "api", key: "api" };
-  }
-  if (["admin", "frontend", "web"].includes(normalizedName)) {
-    return { aliases: ["admin", "frontend", "web"], baseName: "admin", key: "admin" };
-  }
-  if (["realtime", "realtime-gateway"].includes(normalizedName)) {
-    return { aliases: ["realtime-gateway", "realtime"], baseName: "realtime-gateway", key: "realtime" };
-  }
-
-  const slug = slugify(directoryName);
-  return { aliases: [slug], baseName: slug, key: slug };
-}
-
-function buildSyncedProjectConfig(projectDir, projectConfig, scannedServiceSpecs) {
-  const nextConfig = {
-    ...(projectConfig || {}),
-    projectName: projectConfig?.projectName || path.basename(projectDir),
-    projectSlug: projectConfig?.projectSlug || slugify(path.basename(projectDir)),
-  };
-
-  const previousServices = resolveRailwayAppServiceSpecs(projectConfig);
-  const mergedServices = mergeScannedRailwayServices(previousServices, scannedServiceSpecs);
-
-  nextConfig.railway = {
-    ...(getRailwayConfig(projectConfig) || {}),
-    services: mergedServices.map((service) => ({
-      baseName: service.baseName,
-      directory: service.directory,
-      ...(service.dockerfile ? { dockerfile: service.dockerfile } : {}),
-      key: service.key,
-      ...(service.aliases?.length > 0 ? { aliases: service.aliases } : {}),
-      ...(service.serviceName ? { serviceName: service.serviceName } : {}),
-      ...(service.seedImage ? { seedImage: service.seedImage } : {}),
-    })),
-  };
-
-  return nextConfig;
-}
-
-function mergeScannedRailwayServices(previousServices, scannedServiceSpecs) {
-  const previousByKey = new Map(previousServices.map((service) => [service.key, service]));
-  const previousByDirectory = new Map(previousServices.map((service) => [service.directory, service]));
-
-  return scannedServiceSpecs.map((scanned) => {
-    const previous = previousByKey.get(scanned.key) || previousByDirectory.get(scanned.directory);
-    return {
-      aliases: uniqueStrings([...(previous?.aliases || []), ...scanned.aliases]),
-      baseName: previous?.baseName || scanned.baseName,
-      directory: scanned.directory,
-      dockerfile: scanned.dockerfile,
-      key: previous?.key || scanned.key,
-      seedImage: previous?.seedImage || scanned.seedImage,
-      serviceName: previous?.serviceName || null,
-    };
-  });
-}
-
-function buildSyncedRailwayManifest(manifest, nextProjectConfig, scannedServiceSpecs) {
-  const nextManifest = {
-    ...(manifest || {}),
-    appServices: {},
-    projectSlug: nextProjectConfig.projectSlug || manifest?.projectSlug || null,
-    updatedAt: new Date().toISOString(),
-  };
-
-  const previousAppServices = manifest?.appServices || {};
-  const existingSpecs = resolveRailwayAppServiceSpecs(nextProjectConfig);
-  for (const spec of existingSpecs) {
-    const previousEntry =
-      previousAppServices[spec.key] ||
-      findRailwayManifestAppServiceByName(previousAppServices, resolveRailwayServiceName(spec, nextManifest.projectSlug));
-
-    nextManifest.appServices[spec.key] = {
-      serviceId: previousEntry?.serviceId || null,
-      serviceName: previousEntry?.serviceName || resolveRailwayServiceName(spec, nextManifest.projectSlug),
-    };
-  }
-
-  return nextManifest;
-}
-
-function findRailwayManifestAppServiceByName(appServices, serviceName) {
-  return Object.values(appServices || {}).find(
-    (entry) => normalizeRailwayServiceName(entry?.serviceName) === normalizeRailwayServiceName(serviceName),
-  ) || null;
-}
-
 async function writeProjectConfigFile(projectDir, projectConfig) {
   const configPath = path.join(projectDir, "asaje.config.json");
   await fs.writeJson(configPath, projectConfig, { spaces: 2 });
@@ -5326,20 +3091,6 @@ function printSyncProjectConfigSummary(config) {
   }
 }
 
-function uniqueStrings(values) {
-  return [...new Set((values || []).map((value) => String(value || "").trim()).filter(Boolean))];
-}
-
-function resolveProjectSlug(projectDir, projectConfig) {
-  return slugify(projectConfig?.projectSlug || projectConfig?.projectName || path.basename(projectDir) || "asaje-app");
-}
-
-function buildRailwayAppServiceName(projectSlug, baseName) {
-  const normalizedSlug = slugify(projectSlug || "asaje-app");
-  const normalizedBaseName = slugify(baseName);
-  return `${normalizedSlug}-${normalizedBaseName}`;
-}
-
 async function updateProjectTemplateConfig(projectDir, projectConfig, templateRepository, templateBranch) {
   const configPath = path.join(projectDir, "asaje.config.json");
   const nextConfig = {
@@ -5420,81 +3171,6 @@ function printUpdateSummary(config) {
   }
 }
 
-function splitCommaSeparatedPaths(value) {
-  return value
-    .split(",")
-    .map((entry) => normalizeRelativePath(entry))
-    .filter(Boolean);
-}
-
-function uniquePaths(paths) {
-  return [...new Set(paths.map((entry) => normalizeRelativePath(entry)).filter(Boolean))];
-}
-
-function normalizeRelativePath(value) {
-  const trimmed = String(value || "").trim();
-  if (!trimmed) {
-    return "";
-  }
-
-  return trimmed.replace(/^\.\//, "").replace(/\\/g, "/").replace(/\/$/, "");
-}
-
-async function ensureEnvFiles(projectDir) {
-  for (const spec of ENV_FILE_SPECS) {
-    const serviceDir = spec.envPath.split("/")[0];
-    if (!(await fs.pathExists(path.join(projectDir, serviceDir)))) {
-      continue;
-    }
-
-    const envPath = path.join(projectDir, spec.envPath);
-    if (await fs.pathExists(envPath)) {
-      continue;
-    }
-
-    const examplePath = path.join(projectDir, spec.examplePath);
-    if (!(await fs.pathExists(examplePath))) {
-      throw new Error(`Missing ${spec.envPath} and ${spec.examplePath}`);
-    }
-
-    await fs.copyFile(examplePath, envPath);
-    console.log(pc.yellow(`- Created ${spec.envPath} from ${spec.examplePath}`));
-  }
-}
-
-async function loadRuntimeConfig(projectDir) {
-  const configPath = path.join(projectDir, "asaje.config.json");
-  let ports = { admin: 5173, api: 8080, realtime: 8090, landing: 8088, pwa: 4174 };
-
-  if (await fs.pathExists(configPath)) {
-    const fileConfig = await fs.readJson(configPath);
-    ports = {
-      admin: Number(fileConfig?.ports?.admin || ports.admin),
-      api: Number(fileConfig?.ports?.api || ports.api),
-      landing: Number(fileConfig?.ports?.landing || ports.landing),
-      pwa: Number(fileConfig?.ports?.pwa || ports.pwa),
-      realtime: Number(fileConfig?.ports?.realtime || ports.realtime),
-    };
-  } else {
-    const [apiEnv, realtimeEnv, adminEnv, landingEnv, pwaEnv] = await Promise.all([
-      readEnvFile(path.join(projectDir, "api/.env")),
-      readEnvFile(path.join(projectDir, "realtime-gateway/.env")),
-      readEnvFile(path.join(projectDir, "admin/.env")),
-      tryReadEnvFile(path.join(projectDir, "landing/.env")),
-      tryReadEnvFile(path.join(projectDir, "pwa/.env")),
-    ]);
-    ports = {
-      admin: Number(adminEnv.VITE_ADMIN_PORT || ports.admin),
-      api: Number(apiEnv.PORT || ports.api),
-      landing: Number(landingEnv.PORT || ports.landing),
-      pwa: Number(pwaEnv.PORT || pwaEnv.VITE_PORT || ports.pwa),
-      realtime: Number(realtimeEnv.PORT || ports.realtime),
-    };
-  }
-
-  return { ports };
-}
-
 function printStartSummary(projectDir, runtimeConfig, profile, selectedServices) {
   console.log(pc.green("\nStarting project services."));
   console.log(`- Directory: ${pc.bold(projectDir)}`);
@@ -5610,275 +3286,3 @@ async function startManagedProcesses(projectDir, runtimeConfig, selectedServices
     process.removeListener("SIGTERM", onSignal);
   }
 }
-
-function createManagedProcess(spec) {
-  const child = execa(spec.command, spec.args, {
-    cwd: spec.cwd,
-    stderr: "pipe",
-    stdout: "pipe",
-  });
-
-  const prefix = spec.color(`[${spec.name}] `);
-  child.stdout?.on("data", (chunk) => {
-    process.stdout.write(prefixChunk(prefix, chunk));
-  });
-  child.stderr?.on("data", (chunk) => {
-    process.stderr.write(prefixChunk(prefix, chunk));
-  });
-
-  const managed = child.then((result) => ({ ...result, name: spec.name }));
-  managed.kill = (...args) => child.kill(...args);
-  return managed;
-}
-
-function prefixChunk(prefix, chunk) {
-  const textValue = chunk.toString();
-  const normalized = textValue.replace(/\n/g, `\n${prefix}`);
-  return `${prefix}${normalized}`;
-}
-
-async function cloneTemplate(template, branch, destinationDir) {
-  const fallbackBranches = [branch, "main", "master", "develop"].filter(
-    (value, index, array) => value && array.indexOf(value) === index,
-  );
-  let lastError = null;
-
-  for (const candidate of fallbackBranches) {
-    try {
-      const emitter = degit(`${template}#${candidate}`, {
-        cache: false,
-        force: false,
-        verbose: false,
-      });
-      await emitter.clone(destinationDir);
-      return;
-    } catch (error) {
-      lastError = error;
-    }
-  }
-
-  throw lastError instanceof Error ? lastError : new Error(`Unable to clone template ${template}`);
-}
-
-async function cleanupTemplateFiles(destinationDir) {
-  for (const relativePath of EXCLUDED_TEMPLATE_PATHS) {
-    await fs.remove(path.join(destinationDir, relativePath));
-  }
-}
-
-async function ensureScaffoldedSurfaces(destinationDir, answers) {
-  const requiredDirectories = ["admin", "api", "realtime-gateway"];
-
-  if (answers.includeLanding) {
-    requiredDirectories.push("landing");
-  }
-  if (answers.includePwa) {
-    requiredDirectories.push("pwa");
-  }
-
-  const missing = [];
-  for (const relativeDir of requiredDirectories) {
-    if (!(await fs.pathExists(path.join(destinationDir, relativeDir)))) {
-      missing.push(relativeDir);
-    }
-  }
-
-  if (missing.length > 0) {
-    throw new Error(
-      `Template scaffold is missing expected directories: ${missing.join(", ")}. ` +
-      `This usually means the selected template/branch does not include the requested surfaces. ` +
-      `Try another branch or update the template repository before running create again.`,
-    );
-  }
-}
-
-async function ensureDestinationIsAvailable(destinationDir) {
-  const exists = await fs.pathExists(destinationDir);
-  if (!exists) {
-    return;
-  }
-
-  const files = await fs.readdir(destinationDir);
-  if (files.length > 0) {
-    throw new Error(`Destination already exists and is not empty: ${destinationDir}. Choose another directory or empty it before running create.`);
-  }
-}
-
-async function installProjectDependencies(projectDir) {
-  await runCommand("pnpm", ["install"], path.join(projectDir, "admin"));
-  if (await fs.pathExists(path.join(projectDir, "landing/package.json"))) {
-    await runCommand("pnpm", ["install"], path.join(projectDir, "landing"));
-  }
-  if (await fs.pathExists(path.join(projectDir, "pwa/package.json"))) {
-    await runCommand("pnpm", ["install"], path.join(projectDir, "pwa"));
-  }
-  await runCommand("go", ["mod", "download"], path.join(projectDir, "api"));
-  await runCommand("go", ["mod", "download"], path.join(projectDir, "realtime-gateway"));
-}
-
-async function startInfrastructure(projectDir) {
-  await runCommand(
-    "docker",
-    ["compose", "up", "-d", "postgres", "rabbitmq", "minio", "minio-create-bucket"],
-    projectDir,
-  );
-}
-
-async function runCommand(command, args, cwd) {
-  await execa(command, args, {
-    cwd,
-    stdio: "inherit",
-  });
-}
-
-async function checkCommand(spec) {
-  try {
-    const result = await execa(spec.command, spec.args, {
-      reject: false,
-    });
-
-    if (result.exitCode !== 0) {
-      return { message: `${spec.name} unavailable`, ok: false };
-    }
-
-    const version = (result.stdout || result.stderr || "").split(/\r?\n/)[0].trim();
-    return { message: `${spec.name} detected${version ? ` (${version})` : ""}`, ok: true };
-  } catch {
-    return { message: `${spec.name} unavailable`, ok: false };
-  }
-}
-
-async function readEnvFile(filePath) {
-  const contents = await fs.readFile(filePath, "utf8");
-  const result = {};
-
-  for (const line of contents.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      continue;
-    }
-
-    const separatorIndex = trimmed.indexOf("=");
-    if (separatorIndex === -1) {
-      continue;
-    }
-
-    const key = trimmed.slice(0, separatorIndex).trim();
-    let value = trimmed.slice(separatorIndex + 1).trim();
-    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1);
-    }
-    result[key] = value;
-  }
-
-  return result;
-}
-
-function toEnvContent(values) {
-  return `${Object.entries(values)
-    .map(([key, value]) => `${key}=${escapeEnvValue(String(value))}`)
-    .join("\n")}\n`;
-}
-
-function escapeEnvValue(value) {
-  if (value === "") {
-    return "";
-  }
-
-  if (/\s|#|"/.test(value)) {
-    return JSON.stringify(value);
-  }
-
-  return value;
-}
-
-async function prompt(promise) {
-  const result = await promise;
-  if (isCancel(result)) {
-    cancel("Operation cancelled");
-    process.exit(0);
-  }
-  return result;
-}
-
-async function promptNumber(message, defaultValue) {
-  const result = await prompt(
-    text({
-      defaultValue: String(defaultValue),
-      message,
-      validate(value) {
-        const number = Number(value);
-        return Number.isInteger(number) && number > 0 ? undefined : "Enter a positive integer";
-      },
-    }),
-  );
-
-  return Number(result);
-}
-
-async function promptEmail(message, defaultValue) {
-  return prompt(
-    text({
-      defaultValue,
-      message,
-      validate(value) {
-        return value.includes("@") ? undefined : "Enter a valid email";
-      },
-    }),
-  );
-}
-
-async function promptSecret(message, minLength, defaultValue) {
-  return prompt(
-    password({
-      message,
-      ...(defaultValue ? { mask: "*" } : {}),
-      validate(value) {
-        return value.length >= minLength ? undefined : `Must be at least ${minLength} characters`;
-      },
-    }),
-  );
-}
-
-function splitCsv(value) {
-  return value
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean);
-}
-
-function slugify(value) {
-  return value
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-}
-
-function titleize(value) {
-  return value
-    .split(/[-_\s]+/)
-    .filter(Boolean)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join(" ");
-}
-
-function randomSecret(bytes) {
-  return crypto.randomBytes(bytes).toString("base64url");
-}
-
-function shellEscape(value) {
-  if (/^[a-zA-Z0-9_./-]+$/.test(value)) {
-    return value;
-  }
-
-  return JSON.stringify(value);
-}
-
-function isHttpUrl(value) {
-  try {
-    const parsed = new URL(value);
-    return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch {
-    return false;
-  }
-}