create-asaje-go-vue 0.2.1 → 0.2.3

package/README.md

@@ -44,6 +44,20 @@ npx -p create-asaje-go-vue@latest asaje doctor ./my-app
 npx -p create-asaje-go-vue@latest asaje publish
 ```
 
+### Provision Railway resources
+
+```bash
+npx -p create-asaje-go-vue@latest asaje setup-railway ./my-app
+npx -p create-asaje-go-vue@latest asaje setup-railway ./my-app --dry-run
+```
+
+### Sync Railway app variables
+
+```bash
+npx -p create-asaje-go-vue@latest asaje sync-railway-env ./my-app
+npx -p create-asaje-go-vue@latest asaje sync-railway-env ./my-app --dry-run
+```
+
 ## What `create` does
 
 - clones the boilerplate from GitHub with `degit`
@@ -75,6 +89,28 @@ npx -p create-asaje-go-vue@latest asaje publish
 - runs `npm run pack:dry-run`
 - prints the final manual npm release steps
 
+## What `asaje setup-railway` does
+
+- validates the target project structure
+- checks that the Railway CLI is installed and authenticated
+- reads the linked Railway project context
+- provisions PostgreSQL, RabbitMQ, and S3-compatible object storage on Railway
+- creates missing Railway app services for `api`, `realtime-gateway`, and `admin`
+- wires Railway variables for `api`, `realtime-gateway`, and `admin`
+- triggers the first Railway deployment for each app service using the service-local `Dockerfile` and `railway.json`
+- generates missing app secrets such as `JWT_SECRET` and `SWAGGER_PASSWORD`, while reusing existing Railway values when present
+- supports `--dry-run` to preview provisioning and variable changes without applying them
+- writes an `asaje.railway.json` manifest in the target project for future runs, including discovered Railway app service names
+
+## What `asaje sync-railway-env` does
+
+- validates the target project structure
+- checks that the Railway CLI is installed and authenticated
+- reads the linked Railway project context
+- discovers existing Railway app and infra services
+- syncs variables for `api`, `realtime-gateway`, and `admin` without provisioning infra resources
+- supports `--dry-run` to preview variable changes without applying them
+
 ## Useful flags
 
 ```bash
@@ -85,6 +121,9 @@ node ./bin/asaje.js start ../my-app --yes --profile frontend-only
 node ./bin/asaje.js start ../my-app --yes --skip-admin --skip-worker
 node ./bin/asaje.js doctor ../my-app
 node ./bin/asaje.js publish .
+node ./bin/asaje.js setup-railway ../my-app --yes
+node ./bin/asaje.js setup-railway ../my-app --yes --dry-run
+node ./bin/asaje.js sync-railway-env ../my-app --yes
 ```
 
 ## Publish checklist
@@ -103,5 +142,6 @@ npm publish
 - default template repo comes from `ASAJE_TEMPLATE_REPO` or falls back to `asaje379/boilerplate-go-vue`
 - default branch comes from `ASAJE_TEMPLATE_BRANCH` or falls back to `main`
 - if the selected branch is missing, the CLI retries `main`, `master`, then `develop`
+- `asaje setup-railway` works best with `RAILWAY_API_TOKEN` or `RAILWAY_TOKEN` set so it can verify existing remote services before provisioning
 - the package currently uses `UNLICENSED`; change that before public distribution if needed
 - OTP email delivery still requires a valid Mailchimp Transactional key for real email sends

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

@@ -21,6 +21,31 @@ import pc from "picocolors";
 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 RAILWAY_APP_SERVICE_SPECS = [
+  {
+    aliases: ["api", "backend", "server"],
+    directory: "api",
+    key: "api",
+    serviceName: "api",
+  },
+  {
+    aliases: ["admin", "frontend", "web"],
+    directory: "admin",
+    key: "admin",
+    serviceName: "admin",
+  },
+  {
+    aliases: ["realtime-gateway", "realtime"],
+    directory: "realtime-gateway",
+    key: "realtime",
+    serviceName: "realtime-gateway",
+  },
+];
 const ENV_FILE_SPECS = [
   { envPath: "admin/.env", examplePath: "admin/.env.example" },
   { envPath: "api/.env", examplePath: "api/.env.example" },
@@ -58,6 +83,18 @@ async function main() {
       return;
     }
 
+    if (invocation.command === "setup-railway") {
+      await runSetupRailway(invocation.argv);
+      outro(pc.green("Railway setup complete."));
+      return;
+    }
+
+    if (invocation.command === "sync-railway-env") {
+      await runSyncRailwayEnv(invocation.argv);
+      outro(pc.green("Railway environment sync complete."));
+      return;
+    }
+
     await runCreate(invocation.argv);
     outro(pc.green("Project ready."));
   } catch (error) {
@@ -98,6 +135,14 @@ function resolveInvocation(argv) {
       return { argv: rawArgs.slice(1), command: "publish", title: "asaje publish" };
     }
 
+    if (firstArg === "setup-railway") {
+      return { argv: rawArgs.slice(1), command: "setup-railway", title: "asaje setup-railway" };
+    }
+
+    if (firstArg === "sync-railway-env") {
+      return { argv: rawArgs.slice(1), command: "sync-railway-env", title: "asaje sync-railway-env" };
+    }
+
     if (firstArg === "create") {
       return { argv: rawArgs.slice(1), command: "create", title: "asaje create" };
     }
@@ -127,12 +172,16 @@ function printHelp() {
   console.log(`- ${pc.bold("asaje start [directory]")} start a configured project`);
   console.log(`- ${pc.bold("asaje doctor [directory]")} check environment and project readiness`);
   console.log(`- ${pc.bold("asaje publish")} run npm publish checklist for the CLI package`);
+  console.log(`- ${pc.bold("asaje setup-railway [directory]")} provision Railway infrastructure for a project`);
+  console.log(`- ${pc.bold("asaje sync-railway-env [directory]")} sync Railway app variables without provisioning`);
   console.log(pc.bold("\nExamples"));
   console.log(`- ${pc.bold("npx create-asaje-go-vue my-app")}`);
   console.log(`- ${pc.bold("node ./bin/create-asaje-go-vue.js my-app --yes")}`);
   console.log(`- ${pc.bold("node ./bin/asaje.js start ../my-app")}`);
   console.log(`- ${pc.bold("node ./bin/asaje.js doctor ..")}`);
   console.log(`- ${pc.bold("node ./bin/asaje.js publish")}`);
+  console.log(`- ${pc.bold("node ./bin/asaje.js setup-railway ..")}`);
+  console.log(`- ${pc.bold("node ./bin/asaje.js sync-railway-env ..")}`);
 }
 
 async function runCreate(argv) {
@@ -862,10 +911,1219 @@ async function runPublish(argv) {
   console.log(`- Publish with ${pc.bold("npm publish")}`);
 }
 
+async function runSetupRailway(argv) {
+  const args = parseSetupRailwayArgs(argv);
+  const answers = await collectSetupRailwayAnswers(args);
+  const projectDir = path.resolve(process.cwd(), answers.directory);
+
+  await ensureProjectStructure(projectDir);
+  await ensureRailwayCliInstalled();
+  await ensureRailwayAuthenticated(projectDir, answers.environment);
+
+  const manifest = await readRailwayManifest(projectDir);
+  manifest.resources ||= {};
+  const railwayContext = await loadRailwayContext(projectDir, answers.environment);
+  railwayContext.environmentRef = answers.environment || railwayContext.environmentId || railwayContext.environmentName;
+  const existingServices = await discoverRailwayServices(railwayContext, projectDir);
+  const resourceSummary = [];
+  const appServiceSummary = [];
+  const deploySummary = [];
+  const variableSummary = [];
+
+  console.log(pc.bold("\nProvisioning"));
+
+  const postgresResult = await ensureRailwayResource({
+    aliases: ["postgres", "postgresql"],
+    commandArgs: ["add", "--database", "postgres"],
+    dryRun: answers.dryRun,
+    existingServices,
+    key: "postgres",
+    manifest,
+    projectDir,
+    railwayContext,
+  });
+  resourceSummary.push(postgresResult);
+
+  const rabbitMqResult = await ensureRailwayResource({
+    aliases: ["rabbitmq"],
+    commandArgs: ["deploy", "--template", "RabbitMQ"],
+    dryRun: answers.dryRun,
+    existingServices,
+    key: "rabbitmq",
+    manifest,
+    projectDir,
+    railwayContext,
+  });
+  resourceSummary.push(rabbitMqResult);
+
+  const objectStorageResult = await ensureRailwayResource({
+    aliases: ["object-storage", "storage", "simple-s3", "minio"],
+    commandArgs: [
+      "deploy",
+      "--template",
+      "simple-s3",
+      "--variable",
+      `MINIO_BUCKET=${answers.bucket}`,
+    ],
+    dryRun: answers.dryRun,
+    existingServices,
+    key: "objectStorage",
+    manifest,
+    metadata: { bucket: answers.bucket },
+    projectDir,
+    railwayContext,
+  });
+  resourceSummary.push(objectStorageResult);
+
+  console.log(pc.bold("\nApplication services"));
+  manifest.appServices ||= {};
+  for (const spec of RAILWAY_APP_SERVICE_SPECS) {
+    const serviceResult = await ensureRailwayAppService({
+      aliases: spec.aliases,
+      dryRun: answers.dryRun,
+      existingServices,
+      key: spec.key,
+      manifest,
+      projectDir,
+      railwayContext,
+      serviceName: spec.serviceName,
+    });
+    appServiceSummary.push(serviceResult);
+  }
+
+  manifest.bucket = answers.bucket;
+  manifest.environmentId = railwayContext.environmentId || manifest.environmentId || null;
+  manifest.environmentName = railwayContext.environmentName || manifest.environmentName || null;
+  manifest.projectId = railwayContext.projectId || manifest.projectId || null;
+  manifest.projectName = railwayContext.projectName || manifest.projectName || null;
+  manifest.updatedAt = new Date().toISOString();
+
+  const servicesAfterProvision = await discoverRailwayServices(railwayContext, projectDir);
+  updateRailwayManifestAppServices(manifest, servicesAfterProvision);
+  await wireRailwayVariables({
+    dryRun: answers.dryRun,
+    manifest,
+    projectDir,
+    railwayContext,
+    services: servicesAfterProvision,
+    summary: variableSummary,
+  });
+  const deploymentResults = await deployRailwayAppServices({
+    dryRun: answers.dryRun,
+    manifest,
+    projectDir,
+    railwayContext,
+    services: servicesAfterProvision,
+  });
+  deploySummary.push(...deploymentResults);
+
+  if (!answers.dryRun) {
+    await writeRailwayManifest(projectDir, manifest);
+  }
+  printRailwaySetupSummary({
+    appServiceSummary,
+    bucket: answers.bucket,
+    deploySummary,
+    dryRun: answers.dryRun,
+    projectDir,
+    railwayContext,
+    resourceSummary,
+    variableSummary,
+  });
+}
+
+async function runSyncRailwayEnv(argv) {
+  const args = parseSetupRailwayArgs(argv);
+  const answers = await collectSetupRailwayAnswers(args);
+  const projectDir = path.resolve(process.cwd(), answers.directory);
+
+  await ensureProjectStructure(projectDir);
+  await ensureRailwayCliInstalled();
+  await ensureRailwayAuthenticated(projectDir, answers.environment);
+
+  const manifest = await readRailwayManifest(projectDir);
+  manifest.resources ||= {};
+  manifest.appServices ||= {};
+
+  const railwayContext = await loadRailwayContext(projectDir, answers.environment);
+  railwayContext.environmentRef = answers.environment || railwayContext.environmentId || railwayContext.environmentName;
+  const services = await discoverRailwayServices(railwayContext, projectDir);
+  const variableSummary = [];
+
+  updateRailwayManifestAppServices(manifest, services);
+  await wireRailwayVariables({
+    dryRun: answers.dryRun,
+    manifest,
+    projectDir,
+    railwayContext,
+    services,
+    summary: variableSummary,
+  });
+
+  manifest.bucket = manifest.bucket || answers.bucket;
+  manifest.environmentId = railwayContext.environmentId || manifest.environmentId || null;
+  manifest.environmentName = railwayContext.environmentName || manifest.environmentName || null;
+  manifest.projectId = railwayContext.projectId || manifest.projectId || null;
+  manifest.projectName = railwayContext.projectName || manifest.projectName || null;
+  manifest.updatedAt = new Date().toISOString();
+
+  if (!answers.dryRun) {
+    await writeRailwayManifest(projectDir, manifest);
+  }
+
+  printRailwaySetupSummary({
+    appServiceSummary: [],
+    bucket: manifest.bucket || answers.bucket,
+    deploySummary: [],
+    dryRun: answers.dryRun,
+    projectDir,
+    railwayContext,
+    resourceSummary: [],
+    variableSummary,
+  });
+}
+
 function parseDirectoryArgs(argv) {
   return { directory: argv[0] || "." };
 }
 
+function parseSetupRailwayArgs(argv) {
+  const options = {
+    bucket: DEFAULT_RAILWAY_BUCKET,
+    directory: ".",
+    dryRun: false,
+    environment: 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 === "--bucket") {
+      options.bucket = argv[index + 1] || options.bucket;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith("--bucket=")) {
+      options.bucket = arg.split("=")[1] || options.bucket;
+      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;
+    }
+
+    positionals.push(arg);
+  }
+
+  options.directory = positionals[0] || options.directory;
+  return options;
+}
+
+async function collectSetupRailwayAnswers(args) {
+  if (args.yes) {
+    return {
+      bucket: args.bucket,
+      directory: args.directory,
+      dryRun: args.dryRun,
+      environment: args.environment,
+    };
+  }
+
+  const directory = await prompt(
+    text({
+      defaultValue: args.directory,
+      message: "Project directory to configure on Railway?",
+      placeholder: ".",
+      validate(value) {
+        return value.trim().length === 0 ? "Project directory is required" : undefined;
+      },
+    }),
+  );
+
+  const bucket = await prompt(
+    text({
+      defaultValue: args.bucket,
+      message: "Object storage bucket name?",
+      placeholder: DEFAULT_RAILWAY_BUCKET,
+      validate(value) {
+        return /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/.test(value)
+          ? undefined
+          : "Use 3-63 lowercase letters, numbers, dots, or hyphens";
+      },
+    }),
+  );
+
+  let environment = args.environment;
+  if (!environment) {
+    environment = await prompt(
+      text({
+        defaultValue: "",
+        message: "Railway environment name or ID? (leave empty for linked default)",
+        placeholder: "production",
+      }),
+    );
+  }
+
+  return {
+    bucket,
+    directory,
+    dryRun: args.dryRun,
+    environment: environment?.trim() || undefined,
+  };
+}
+
+async function ensureRailwayCliInstalled() {
+  const result = await checkCommand({ command: "railway", args: ["--version"], name: "railway" });
+  if (!result.ok) {
+    throw new Error(
+      "Railway CLI is required for this command. Install it with `brew install railway` or `npm i -g @railway/cli`.",
+    );
+  }
+}
+
+async function ensureRailwayAuthenticated(projectDir, environment) {
+  const result = await execa("railway", buildRailwayArgs(["whoami"], environment), {
+    cwd: projectDir,
+    reject: false,
+  });
+
+  if (result.exitCode !== 0) {
+    throw new Error("Railway CLI is not authenticated. Run `railway login` and try again.");
+  }
+}
+
+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,
+      projectId: null,
+      projectName: null,
+      resources: {},
+      updatedAt: null,
+    };
+  }
+
+  return fs.readJson(manifestPath);
+}
+
+async function writeRailwayManifest(projectDir, manifest) {
+  const manifestPath = path.join(projectDir, RAILWAY_MANIFEST_FILENAME);
+  await fs.writeJson(manifestPath, manifest, { spaces: 2 });
+}
+
+async function loadRailwayContext(projectDir, environment) {
+  const result = await execa("railway", buildRailwayArgs(["status", "--json"], environment), {
+    cwd: projectDir,
+    reject: false,
+  });
+
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Unable to read Railway project status for ${projectDir}. Link the directory first with \`railway link\` or \`railway init\`.`,
+    );
+  }
+
+  const payload = parseJsonOutput(result.stdout);
+  if (!payload) {
+    throw new Error("Railway status returned an unexpected response. Make sure the project is linked and try again.");
+  }
+
+  const project = payload.project || payload.linkedProject || payload.workspace?.project || null;
+  const environmentData = payload.environment || payload.linkedEnvironment || payload.deployment?.environment || null;
+
+  return {
+    environmentId: pickFirstString([
+      environmentData?.id,
+      payload.environmentId,
+      findFirstNestedValue(payload, "environmentId"),
+    ]),
+    environmentName: pickFirstString([
+      environmentData?.name,
+      payload.environmentName,
+      environment,
+      findFirstNestedValue(payload, "environmentName"),
+    ]),
+    projectId: pickFirstString([project?.id, payload.projectId, findFirstNestedValue(payload, "projectId")]),
+    projectName: pickFirstString([
+      project?.name,
+      payload.projectName,
+      findFirstNestedValue(payload, "projectName"),
+    ]),
+  };
+}
+
+async function discoverRailwayServices(railwayContext, projectDir) {
+  const cliServices = await discoverRailwayServicesViaCli(railwayContext, projectDir);
+  if (cliServices.length > 0) {
+    return cliServices;
+  }
+
+  const auth = getRailwayApiAuth();
+  if (!auth || !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 [];
+  }
+}
+
+async function discoverRailwayServicesViaCli(railwayContext, projectDir) {
+  try {
+    const result = await execa(
+      "railway",
+      buildRailwayArgs(["service", "status", "--all", "--json"], railwayContext.environmentRef),
+      {
+        cwd: projectDir,
+        reject: false,
+      },
+    );
+
+    if (result.exitCode !== 0) {
+      return [];
+    }
+
+    const payload = parseJsonOutput(result.stdout);
+    if (!payload) {
+      return [];
+    }
+
+    return normalizeRailwayServices(extractRailwayServiceCandidates(payload));
+  } catch {
+    return [];
+  }
+}
+
+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);
+
+  if (existingService) {
+    config.manifest.resources[config.key] = {
+      bucket: config.metadata?.bucket || manifestEntry?.bucket || null,
+      detectedAt: new Date().toISOString(),
+      serviceId: existingService.id || manifestEntry?.serviceId || null,
+      serviceName: existingService.name || manifestEntry?.serviceName || null,
+      source: "remote",
+      status: "existing",
+    };
+
+    console.log(`- ${pc.cyan(config.key)} already present${existingService.name ? ` (${existingService.name})` : ""}`);
+    return {
+      key: config.key,
+      serviceName: existingService.name || manifestEntry?.serviceName || null,
+      status: "existing",
+    };
+  }
+
+  if (manifestEntry?.status === "created" || manifestEntry?.status === "existing") {
+    console.log(`- ${pc.yellow(config.key)} tracked in ${RAILWAY_MANIFEST_FILENAME} but not found remotely, recreating...`);
+  }
+
+  console.log(`- creating ${pc.cyan(config.key)}...`);
+  const servicesBefore = normalizeRailwayServices(config.existingServices);
+  if (!config.dryRun) {
+    await runRailwayCommand(config.projectDir, config.railwayContext.environmentRef, config.commandArgs);
+  }
+
+  let createdService = null;
+  if (!config.dryRun) {
+    createdService = await waitForCreatedRailwayService({
+      aliases: config.aliases,
+      beforeServices: servicesBefore,
+      key: config.key,
+      manifestEntry,
+      projectDir: config.projectDir,
+      railwayContext: config.railwayContext,
+    });
+  }
+
+  config.manifest.resources[config.key] = {
+    bucket: config.metadata?.bucket || null,
+    detectedAt: new Date().toISOString(),
+    serviceId: createdService?.id || null,
+    serviceName: createdService?.name || null,
+    source: "cli",
+    status: "created",
+  };
+
+  return {
+    key: config.key,
+    serviceName: createdService?.name || null,
+    status: config.dryRun ? "dry-run" : "created",
+  };
+}
+
+async function ensureRailwayAppService(config) {
+  const manifestEntry = config.manifest.appServices?.[config.key];
+  const existingService = findRailwayService(
+    config.existingServices,
+    config.aliases,
+    manifestEntry?.serviceName || config.serviceName,
+  );
+
+  if (existingService) {
+    config.manifest.appServices[config.key] = {
+      serviceId: existingService.id || manifestEntry?.serviceId || null,
+      serviceName: existingService.name || manifestEntry?.serviceName || config.serviceName,
+    };
+
+    console.log(`- ${pc.cyan(config.serviceName)} already present${existingService.name ? ` (${existingService.name})` : ""}`);
+    return {
+      key: config.serviceName,
+      serviceName: existingService.name || config.serviceName,
+      status: "existing",
+    };
+  }
+
+  if (manifestEntry?.serviceName) {
+    console.log(`- ${pc.yellow(config.serviceName)} tracked in ${RAILWAY_MANIFEST_FILENAME} but not found remotely, recreating...`);
+  }
+
+  console.log(`- creating ${pc.cyan(config.serviceName)} service...`);
+  const servicesBefore = normalizeRailwayServices(config.existingServices);
+  if (!config.dryRun) {
+    await runRailwayCommand(config.projectDir, config.railwayContext.environmentRef, ["add", "--service", config.serviceName]);
+  }
+
+  let createdService = null;
+  if (!config.dryRun) {
+    createdService = await waitForCreatedRailwayService({
+      aliases: config.aliases,
+      beforeServices: servicesBefore,
+      key: config.serviceName,
+      manifestEntry,
+      projectDir: config.projectDir,
+      railwayContext: config.railwayContext,
+    });
+  }
+
+  config.manifest.appServices[config.key] = {
+    serviceId: createdService?.id || null,
+    serviceName: createdService?.name || config.serviceName,
+  };
+
+  return {
+    key: config.serviceName,
+    serviceName: createdService?.name || config.serviceName,
+    status: config.dryRun ? "dry-run" : "created",
+  };
+}
+
+async function deployRailwayAppServices(config) {
+  console.log(pc.bold("\nDeployments"));
+
+  const summary = [];
+  for (const spec of RAILWAY_APP_SERVICE_SPECS) {
+    const manifestEntry = config.manifest.appServices?.[spec.key];
+    const service = findRailwayService(config.services, spec.aliases, manifestEntry?.serviceName || spec.serviceName);
+    const targetServiceName = service?.name || manifestEntry?.serviceName || spec.serviceName;
+
+    if (!service && !config.dryRun) {
+      console.log(`- ${pc.yellow(spec.serviceName)} service not found, skipping deployment`);
+      continue;
+    }
+
+    if (config.dryRun) {
+      console.log(`- would deploy ${pc.cyan(targetServiceName)} from ${spec.directory}/`);
+      summary.push({ directory: spec.directory, serviceName: targetServiceName, status: "dry-run" });
+      continue;
+    }
+
+    console.log(`- deploying ${pc.cyan(targetServiceName)} from ${spec.directory}/...`);
+    await runRailwayCommand(config.projectDir, config.railwayContext.environmentRef, [
+      "up",
+      spec.directory,
+      "--service",
+      targetServiceName,
+      "--path-as-root",
+      "--detach",
+      "--message",
+      `asaje setup-railway: deploy ${targetServiceName}`,
+    ]);
+    summary.push({ directory: spec.directory, serviceName: targetServiceName, status: "deployed" });
+  }
+
+  return summary;
+}
+
+async function wireRailwayVariables(config) {
+  console.log(pc.bold("\nVariables"));
+
+  const localEnv = await loadRailwayLocalEnvDefaults(config.projectDir);
+
+  const infra = {
+    objectStorage: findRailwayService(
+      config.services,
+      ["object-storage", "storage", "simple-s3", "minio"],
+      config.manifest.resources.objectStorage?.serviceName,
+    ),
+    postgres: findRailwayService(
+      config.services,
+      ["postgres", "postgresql"],
+      config.manifest.resources.postgres?.serviceName,
+    ),
+    rabbitmq: findRailwayService(
+      config.services,
+      ["rabbitmq"],
+      config.manifest.resources.rabbitmq?.serviceName,
+    ),
+  };
+  const appServices = {
+    admin: findRailwayService(config.services, ["admin", "frontend", "web"], config.manifest.appServices?.admin?.serviceName),
+    api: findRailwayService(config.services, ["api", "backend", "server"], config.manifest.appServices?.api?.serviceName),
+    realtime: findRailwayService(
+      config.services,
+      ["realtime-gateway", "realtime"],
+      config.manifest.appServices?.realtime?.serviceName,
+    ),
+  };
+
+  updateRailwayManifestAppServices(config.manifest, Object.values(appServices).filter(Boolean));
+
+  if (!appServices.api) {
+    console.log(`- ${pc.yellow("api")} service not found, skipping API variable wiring`);
+  }
+  if (!appServices.realtime) {
+    console.log(`- ${pc.yellow("realtime-gateway")} service not found, skipping realtime variable wiring`);
+  }
+  if (!appServices.admin) {
+    console.log(`- ${pc.yellow("admin")} service not found, skipping admin variable wiring`);
+  }
+  if (!infra.postgres) {
+    console.log(`- ${pc.yellow("postgres")} resource not found, DATABASE_URL wiring will be skipped`);
+  }
+  if (!infra.rabbitmq) {
+    console.log(`- ${pc.yellow("rabbitmq")} resource not found, RABBITMQ_URL wiring will be skipped`);
+  }
+  if (!infra.objectStorage) {
+    console.log(`- ${pc.yellow("object-storage")} resource not found, S3 variable wiring will be skipped`);
+  }
+
+  if (appServices.api) {
+    const existingApiVariables = await loadRailwayServiceVariables(
+      config.projectDir,
+      config.railwayContext.environmentRef,
+      appServices.api.name,
+    );
+    const variables = {};
+    const sharedSecrets = buildRailwaySharedSecrets(localEnv, existingApiVariables);
+    Object.assign(variables, sharedSecrets.api);
+    if (infra.postgres?.name) {
+      variables.DATABASE_URL = railwayReference(infra.postgres.name, "DATABASE_URL");
+    }
+    if (infra.rabbitmq?.name) {
+      variables.RABBITMQ_URL = buildRabbitMqUrlReference(infra.rabbitmq.name);
+    }
+    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")}`;
+    }
+    await applyRailwayVariables({
+      dryRun: config.dryRun,
+      environment: config.railwayContext.environmentRef,
+      projectDir: config.projectDir,
+      serviceName: appServices.api.name,
+      summary: config.summary,
+      variables,
+    });
+  }
+
+  if (appServices.realtime) {
+    const variables = {};
+    Object.assign(variables, buildRealtimeDefaults(localEnv));
+    if (infra.rabbitmq?.name) {
+      variables.RABBITMQ_URL = buildRabbitMqUrlReference(infra.rabbitmq.name);
+    }
+    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")}`;
+    }
+    await applyRailwayVariables({
+      dryRun: config.dryRun,
+      environment: config.railwayContext.environmentRef,
+      projectDir: config.projectDir,
+      serviceName: appServices.realtime.name,
+      summary: config.summary,
+      variables,
+    });
+  }
+
+  if (appServices.admin) {
+    const variables = {};
+    Object.assign(variables, buildAdminDefaults(localEnv));
+    if (appServices.api?.name) {
+      variables.VITE_API_BASE_URL = `https://${railwayReference(appServices.api.name, "RAILWAY_PUBLIC_DOMAIN")}/api/v1`;
+    }
+    if (appServices.realtime?.name) {
+      variables.VITE_REALTIME_BASE_URL = `https://${railwayReference(appServices.realtime.name, "RAILWAY_PUBLIC_DOMAIN")}`;
+    }
+    await applyRailwayVariables({
+      dryRun: config.dryRun,
+      environment: config.railwayContext.environmentRef,
+      projectDir: config.projectDir,
+      serviceName: appServices.admin.name,
+      summary: config.summary,
+      variables,
+    });
+  }
+}
+
+async function loadRailwayLocalEnvDefaults(projectDir) {
+  const [apiEnv, realtimeEnv, adminEnv] = await Promise.all([
+    tryReadEnvFile(path.join(projectDir, "api/.env")),
+    tryReadEnvFile(path.join(projectDir, "realtime-gateway/.env")),
+    tryReadEnvFile(path.join(projectDir, "admin/.env")),
+  ]);
+
+  return {
+    admin: adminEnv,
+    api: apiEnv,
+    realtime: realtimeEnv,
+  };
+}
+
+function buildRailwaySharedSecrets(localEnv, existingVariables) {
+  const jwtSecret =
+    sanitizeSecret(localEnv.api.JWT_SECRET, "change-me") ||
+    sanitizeSecret(existingVariables.JWT_SECRET, "${{ api.JWT_SECRET }}") ||
+    randomSecret(32);
+  const swaggerPassword =
+    sanitizeSecret(localEnv.api.SWAGGER_PASSWORD, "change-me-too") ||
+    sanitizeSecret(existingVariables.SWAGGER_PASSWORD, "${{ api.SWAGGER_PASSWORD }}") ||
+    randomSecret(18);
+
+  return {
+    api: {
+      ACCESS_TOKEN_TTL_MINUTES: localEnv.api.ACCESS_TOKEN_TTL_MINUTES || "60",
+      DEFAULT_LOCALE: localEnv.api.DEFAULT_LOCALE || "fr",
+      FILE_MAX_SIZE_MB: localEnv.api.FILE_MAX_SIZE_MB || "25",
+      FILE_SIGNED_URL_TTL_MINUTES: localEnv.api.FILE_SIGNED_URL_TTL_MINUTES || "15",
+      JWT_SECRET: jwtSecret,
+      LOGIN_OTP_TTL_MINUTES: localEnv.api.LOGIN_OTP_TTL_MINUTES || "10",
+      MAILCHIMP_TRANSACTIONAL_API_KEY: localEnv.api.MAILCHIMP_TRANSACTIONAL_API_KEY || "dev-placeholder-key",
+      MAIL_FROM_EMAIL: localEnv.api.MAIL_FROM_EMAIL || "no-reply@example.com",
+      MAIL_FROM_NAME: localEnv.api.MAIL_FROM_NAME || "Boilerplate API",
+      PASSWORD_RESET_OTP_TTL_MINUTES: localEnv.api.PASSWORD_RESET_OTP_TTL_MINUTES || "15",
+      RABBITMQ_REALTIME_EXCHANGE: localEnv.api.RABBITMQ_REALTIME_EXCHANGE || "boilerplate.realtime",
+      RABBITMQ_TASKS_EXCHANGE: localEnv.api.RABBITMQ_TASKS_EXCHANGE || "boilerplate.tasks",
+      RABBITMQ_WORKER_CONSUMER_TAG: localEnv.api.RABBITMQ_WORKER_CONSUMER_TAG || "api-worker",
+      RABBITMQ_WORKER_QUEUE: localEnv.api.RABBITMQ_WORKER_QUEUE || "api.worker.default",
+      RATE_LIMIT_BURST: localEnv.api.RATE_LIMIT_BURST || "60",
+      RATE_LIMIT_RPM: localEnv.api.RATE_LIMIT_RPM || "120",
+      REFRESH_TOKEN_TTL_MINUTES: localEnv.api.REFRESH_TOKEN_TTL_MINUTES || "10080",
+      SWAGGER_PASSWORD: swaggerPassword,
+      SWAGGER_USERNAME: localEnv.api.SWAGGER_USERNAME || "swagger",
+    },
+  };
+}
+
+function buildRealtimeDefaults(localEnv) {
+  return {
+    RABBITMQ_REALTIME_EXCHANGE: localEnv.realtime.RABBITMQ_REALTIME_EXCHANGE || "boilerplate.realtime",
+    REALTIME_HEARTBEAT_SECONDS: localEnv.realtime.REALTIME_HEARTBEAT_SECONDS || "25",
+    REALTIME_INSTANCE_ID: localEnv.realtime.REALTIME_INSTANCE_ID || "realtime-gateway-railway",
+    REALTIME_QUEUE_PREFIX: localEnv.realtime.REALTIME_QUEUE_PREFIX || "realtime-gateway",
+    REALTIME_WRITE_TIMEOUT_SECONDS: localEnv.realtime.REALTIME_WRITE_TIMEOUT_SECONDS || "10",
+  };
+}
+
+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_RECONNECT_DELAY_MS: localEnv.admin.VITE_REALTIME_RECONNECT_DELAY_MS || "3000",
+  };
+}
+
+function sanitizeSecret(value, placeholder) {
+  const normalized = String(value || "").trim();
+  if (!normalized || normalized === placeholder) {
+    return "";
+  }
+  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"),
+    MINIO_BUCKET_NAME: railwayReference(serviceName, "MINIO_BUCKET"),
+    MINIO_ENDPOINT: railwayReference(serviceName, "RAILWAY_PRIVATE_DOMAIN"),
+    MINIO_PORT: "9000",
+    MINIO_PUBLIC_URL: `https://${railwayReference(serviceName, "RAILWAY_PUBLIC_DOMAIN")}`,
+    MINIO_SECRET_KEY: railwayReference(serviceName, "MINIO_ROOT_PASSWORD"),
+    MINIO_USE_SSL: "false",
+    OBJECT_STORAGE_PROVIDER: "minio",
+  };
+}
+
+function buildRabbitMqUrlReference(serviceName) {
+  return `amqp://${railwayReference(serviceName, "RABBITMQ_DEFAULT_USER")}:${railwayReference(serviceName, "RABBITMQ_DEFAULT_PASS")}@${railwayReference(serviceName, "RAILWAY_PRIVATE_DOMAIN")}:5672/`;
+}
+
+function railwayReference(serviceName, variableName) {
+  return "${{ " + serviceName + "." + variableName + " }}";
+}
+
+async function applyRailwayVariables(config) {
+  const entries = Object.entries(config.variables).filter(([, value]) => typeof value === "string" && value.length > 0);
+  if (entries.length === 0) {
+    console.log(`- ${pc.dim(config.serviceName)} no variables to set`);
+    return;
+  }
+
+  if (config.dryRun) {
+    console.log(`- ${pc.cyan(config.serviceName)} would set ${entries.map(([key]) => key).join(", ")}`);
+    config.summary.push({
+      keys: entries.map(([key]) => key),
+      serviceName: config.serviceName,
+      status: "dry-run",
+    });
+    return;
+  }
+
+  await runRailwayCommand(config.projectDir, config.environment, [
+    "variable",
+    "set",
+    ...entries.map(([key, value]) => `${key}=${value}`),
+    "--service",
+    config.serviceName,
+  ]);
+  console.log(`- ${pc.cyan(config.serviceName)} set ${entries.map(([key]) => key).join(", ")}`);
+  config.summary.push({
+    keys: entries.map(([key]) => key),
+    serviceName: config.serviceName,
+    status: "updated",
+  });
+}
+
+async function loadRailwayServiceVariables(projectDir, environment, serviceName) {
+  try {
+    const result = await execa(
+      "railway",
+      buildRailwayArgs(["variable", "list", "--json", "--service", serviceName], environment),
+      {
+        cwd: projectDir,
+        reject: false,
+      },
+    );
+
+    if (result.exitCode !== 0) {
+      return {};
+    }
+
+    return normalizeRailwayVariables(parseJsonOutput(result.stdout));
+  } catch {
+    return {};
+  }
+}
+
+async function waitForCreatedRailwayService(config) {
+  for (let attempt = 0; attempt < RAILWAY_SERVICE_DISCOVERY_RETRY_COUNT; attempt += 1) {
+    const servicesAfter = await discoverRailwayServices(config.railwayContext, config.projectDir);
+    const createdService = findCreatedRailwayService({
+      aliases: config.aliases,
+      beforeServices: config.beforeServices,
+      manifestServiceName: config.manifestEntry?.serviceName,
+      servicesAfter,
+    });
+
+    if (createdService) {
+      return createdService;
+    }
+
+    if (attempt < RAILWAY_SERVICE_DISCOVERY_RETRY_COUNT - 1) {
+      await sleep(RAILWAY_SERVICE_DISCOVERY_RETRY_DELAY_MS);
+    }
+  }
+
+  throw new Error(
+    `Railway command for ${config.key} finished but the new service was not detected afterwards. Check the Railway dashboard/logs, then rerun \`asaje setup-railway\` or \`asaje sync-railway-env\` once the service appears.`,
+  );
+}
+
+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.includes(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 = {};
+
+  visitRailwayJson(input, (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return;
+    }
+
+    const key = pickFirstString([value.name, value.key]);
+    const rawValue = pickFirstString([value.value, value.resolvedValue]);
+    if (!key || rawValue === null) {
+      return;
+    }
+
+    normalized[key] = rawValue;
+  });
+
+  return normalized;
+}
+
+function updateRailwayManifestAppServices(manifest, services) {
+  manifest.appServices ||= {};
+
+  const entries = [
+    ["api", findRailwayService(services, ["api", "backend", "server"], manifest.appServices.api?.serviceName)],
+    ["admin", findRailwayService(services, ["admin", "frontend", "web"], manifest.appServices.admin?.serviceName)],
+    [
+      "realtime",
+      findRailwayService(
+        services,
+        ["realtime-gateway", "realtime"],
+        manifest.appServices.realtime?.serviceName,
+      ),
+    ],
+  ];
+
+  for (const [key, service] of entries) {
+    if (!service?.name) {
+      continue;
+    }
+
+    manifest.appServices[key] = {
+      serviceId: service.id || manifest.appServices[key]?.serviceId || null,
+      serviceName: service.name,
+    };
+  }
+}
+
+function extractRailwayServiceCandidates(input) {
+  const candidates = [];
+
+  visitRailwayJson(input, (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return;
+    }
+
+    if (typeof value.name === "string" || typeof value.serviceName === "string") {
+      candidates.push(value);
+    }
+  });
+
+  return candidates;
+}
+
+function visitRailwayJson(input, visitor) {
+  visitor(input);
+  if (!input || typeof input !== "object") {
+    return;
+  }
+
+  if (Array.isArray(input)) {
+    for (const item of input) {
+      visitRailwayJson(item, visitor);
+    }
+    return;
+  }
+
+  for (const value of Object.values(input)) {
+    visitRailwayJson(value, visitor);
+  }
+}
+
+function sleep(delayMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+
+async function runRailwayCommand(projectDir, environment, args) {
+  const result = await execa("railway", buildRailwayArgs(args, environment), {
+    cwd: projectDir,
+    reject: false,
+    stderr: "inherit",
+    stdout: "inherit",
+  });
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Railway command failed: railway ${args.join(" ")}`);
+  }
+}
+
+function buildRailwayArgs(args, environment) {
+  if (!environment) {
+    return args;
+  }
+
+  return [...args, "--environment", environment];
+}
+
+function parseJsonOutput(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function pickFirstString(values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+
+  return null;
+}
+
+function findFirstNestedValue(input, key) {
+  if (!input || typeof input !== "object") {
+    return null;
+  }
+
+  if (typeof input[key] === "string") {
+    return input[key];
+  }
+
+  for (const value of Object.values(input)) {
+    if (!value || typeof value !== "object") {
+      continue;
+    }
+
+    const nested = findFirstNestedValue(value, key);
+    if (nested) {
+      return nested;
+    }
+  }
+
+  return null;
+}
+
+function printRailwaySetupSummary(config) {
+  console.log(pc.bold("\nRailway"));
+  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(`- Bucket: ${pc.bold(config.bucket)}`);
+
+  console.log(pc.bold("\nResources"));
+  if (config.resourceSummary.length === 0) {
+    console.log("- No infrastructure resources were changed");
+  } else {
+    for (const item of config.resourceSummary) {
+      const detail = item.serviceName ? ` (${item.serviceName})` : "";
+      console.log(`- ${pc.bold(item.key)}: ${item.status}${detail}`);
+    }
+  }
+
+  console.log(pc.bold("\nApplication services"));
+  if (config.appServiceSummary.length === 0) {
+    console.log("- No application services were changed");
+  } else {
+    for (const item of config.appServiceSummary) {
+      const detail = item.serviceName ? ` (${item.serviceName})` : "";
+      console.log(`- ${pc.bold(item.key)}: ${item.status}${detail}`);
+    }
+  }
+
+  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}/`);
+    }
+  }
+
+  console.log(pc.bold("\nVariables"));
+  if (config.variableSummary.length === 0) {
+    console.log("- No application variables were updated");
+  } else {
+    for (const item of config.variableSummary) {
+      console.log(`- ${pc.bold(item.serviceName)}: ${item.status} ${item.keys.join(", ")}`);
+    }
+  }
+
+  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`);
+  }
+
+  if (!getRailwayApiAuth()) {
+    console.log(pc.yellow("\nNote: Set RAILWAY_API_TOKEN or RAILWAY_TOKEN to let future runs verify remote services before provisioning."));
+  }
+}
+
 function parseStartArgs(argv) {
   const options = {
     directory: ".",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "create-asaje-go-vue",
-	"version": "0.2.1",
+	"version": "0.2.3",
 	"description": "CLI to scaffold, configure, and run the Asaje Go + Vue boilerplate",
 	"type": "module",
 	"bin": {
@@ -11,6 +11,8 @@
 		"create": "node ./bin/create-asaje-go-vue.js",
 		"start": "node ./bin/asaje.js start .",
 		"doctor": "node ./bin/asaje.js doctor ..",
+		"setup-railway": "node ./bin/asaje.js setup-railway .. --yes",
+		"sync-railway-env": "node ./bin/asaje.js sync-railway-env .. --yes",
 		"publish:check": "node ./bin/asaje.js publish .",
 		"check": "node --check ./bin/create-asaje-go-vue.js && node --check ./bin/asaje.js",
 		"pack:dry-run": "npm pack --dry-run"