@wasp.sh/wasp-cli-darwin-arm64-unknown 0.20.0

package/data/packages/deploy/dist/providers/fly/commands/deploy/deploy.js

@@ -0,0 +1,88 @@
+import { $, cd, fs } from "zx";
+import { buildClient } from "../../../../common/clientApp.js";
+import { getFullCommandName } from "../../../../common/commander.js";
+import { displayWaspRocketImage, waspSays, } from "../../../../common/terminal.js";
+import { ensureWaspProjectIsBuilt } from "../../../../common/waspBuild.js";
+import { getClientBuildDir, getServerBuildDir, } from "../../../../common/waspProject.js";
+import { createDeploymentInstructions, } from "../../DeploymentInstructions.js";
+import { getFlyAppUrl } from "../../flyAppUrl.js";
+import { secretExists } from "../../flyCli.js";
+import { flySetupCommand } from "../../index.js";
+import { clientTomlExistsInProject, copyLocalClientTomlToProject, copyLocalServerTomlToProject, copyProjectClientTomlLocally, copyProjectServerTomlLocally, getInferredBasenameFromClientToml, getInferredBasenameFromServerToml, getTomlFilePaths, serverTomlExistsInProject, } from "../../tomlFile.js";
+export async function deploy(cmdOptions) {
+    waspSays("Deploying your Wasp app to Fly.io!");
+    await ensureWaspProjectIsBuilt(cmdOptions);
+    const tomlFilePaths = getTomlFilePaths(cmdOptions);
+    // NOTE: Below, it would be nice if we could store the client, server, and DB names somewhere.
+    // For now we just rely on the suffix naming convention and infer from toml files.
+    if (!serverTomlExistsInProject(tomlFilePaths)) {
+        waspSays(`${tomlFilePaths.serverTomlPath} missing. Skipping server deploy. Perhaps you need to run "${getFullCommandName(flySetupCommand)}" first?`);
+    }
+    else if (cmdOptions.skipServer) {
+        waspSays("Skipping server deploy due to CLI option.");
+    }
+    else {
+        const inferredBaseName = getInferredBasenameFromServerToml(tomlFilePaths);
+        const deploymentInstructions = createDeploymentInstructions({
+            baseName: inferredBaseName,
+            cmdOptions,
+            tomlFilePaths,
+        });
+        await deployServer(deploymentInstructions, cmdOptions);
+    }
+    if (!clientTomlExistsInProject(tomlFilePaths)) {
+        waspSays(`${tomlFilePaths.clientTomlPath} missing. Skipping client deploy. Perhaps you need to run "${getFullCommandName(flySetupCommand)}" first?`);
+    }
+    else if (cmdOptions.skipClient) {
+        waspSays("Skipping client deploy due to CLI option.");
+    }
+    else {
+        const inferredBaseName = getInferredBasenameFromClientToml(tomlFilePaths);
+        const deploymentInstructions = createDeploymentInstructions({
+            baseName: inferredBaseName,
+            cmdOptions,
+            tomlFilePaths,
+        });
+        await deployClient(deploymentInstructions, cmdOptions);
+    }
+}
+async function deployServer(deploymentInstructions, { buildLocally }) {
+    waspSays("Deploying your server now...");
+    cd(getServerBuildDir(deploymentInstructions.cmdOptions.waspProjectDir));
+    copyProjectServerTomlLocally(deploymentInstructions.tomlFilePaths);
+    // Make sure we have a DATABASE_URL present. If not, they need to create/attach their DB first.
+    const databaseUrlSet = await secretExists("DATABASE_URL");
+    if (!databaseUrlSet) {
+        throw new Error("Your server app does not have a DATABASE_URL secret set. Perhaps you need to create or attach your database?");
+    }
+    const deployArgs = [buildLocally ? "--local-only" : "--remote-only"];
+    await $ `flyctl deploy ${deployArgs}`;
+    // NOTE: Deploy is not expected to update the toml file, but doing this just in case.
+    // However, if it does and we fail to copy it back, we would be in an inconsistent state.
+    // TOOD: Consider how to best handle this situation across all operations.
+    copyLocalServerTomlToProject(deploymentInstructions.tomlFilePaths);
+    waspSays("Server has been deployed!");
+}
+async function deployClient(deploymentInstructions, { buildLocally }) {
+    waspSays("Deploying your client now...");
+    cd(getClientBuildDir(deploymentInstructions.cmdOptions.waspProjectDir));
+    copyProjectClientTomlLocally(deploymentInstructions.tomlFilePaths);
+    const serverFlyAppUrl = getFlyAppUrl(deploymentInstructions.serverFlyAppName);
+    await buildClient(serverFlyAppUrl, deploymentInstructions.cmdOptions);
+    // Creates the necessary Dockerfile for deploying static websites to Fly.io.
+    // Adds dummy .dockerignore to supress CLI question.
+    // Ref: https://fly.io/docs/languages-and-frameworks/static/
+    const dockerfileContents = `
+		FROM pierrezemb/gostatic
+		CMD [ "-fallback", "index.html" ]
+		COPY ./build/ /srv/http/
+	`;
+    fs.writeFileSync("Dockerfile", dockerfileContents);
+    fs.writeFileSync(".dockerignore", "");
+    const deployArgs = [buildLocally ? "--local-only" : "--remote-only"];
+    await $ `flyctl deploy ${deployArgs}`;
+    copyLocalClientTomlToProject(deploymentInstructions.tomlFilePaths);
+    displayWaspRocketImage();
+    waspSays(`Client has been deployed! Your Wasp app is accessible at: ${getFlyAppUrl(deploymentInstructions.clientFlyAppName)}`);
+}
+//# sourceMappingURL=deploy.js.map

package/data/packages/deploy/dist/providers/fly/commands/launch/LaunchCmdOptions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LaunchCmdOptions.js.map

package/data/packages/deploy/dist/providers/fly/commands/launch/launch.js

@@ -0,0 +1,17 @@
+import { waspSays } from "../../../../common/terminal.js";
+import { clientTomlExistsInProject, getTomlFilePaths, serverTomlExistsInProject, } from "../../tomlFile.js";
+import { createDb } from "../createDb/createDb.js";
+import { deploy } from "../deploy/deploy.js";
+import { setup } from "../setup/setup.js";
+export async function launch(basename, region, cmdOptions) {
+    waspSays("Launching your Wasp app to Fly.io!");
+    const tomlFilePaths = getTomlFilePaths(cmdOptions);
+    if (serverTomlExistsInProject(tomlFilePaths) ||
+        clientTomlExistsInProject(tomlFilePaths)) {
+        throw new Error("You already have Fly toml files. The launch command is intended to be run one time on a new Fly project. Please try a different command.");
+    }
+    await setup(basename, region, cmdOptions);
+    await createDb(region, cmdOptions);
+    await deploy(cmdOptions);
+}
+//# sourceMappingURL=launch.js.map

package/data/packages/deploy/dist/providers/fly/commands/setup/SetupCmdOptions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SetupCmdOptions.js.map

package/data/packages/deploy/dist/providers/fly/commands/setup/setup.js

@@ -0,0 +1,141 @@
+import { $, cd, chalk, question } from "zx";
+import { getFullCommandName } from "../../../../common/commander.js";
+import { generateRandomHexString } from "../../../../common/random.js";
+import { waspSays } from "../../../../common/terminal.js";
+import { ensureWaspProjectIsBuilt } from "../../../../common/waspBuild.js";
+import { getClientBuildDir, getServerBuildDir, } from "../../../../common/waspProject.js";
+import { createDeploymentInstructions, } from "../../DeploymentInstructions.js";
+import { getFlyAppUrl } from "../../flyAppUrl.js";
+import { createFlyDbCommand } from "../../index.js";
+import { clientTomlExistsInProject, copyLocalClientTomlToProject, copyLocalServerTomlToProject, deleteLocalToml, doesLocalTomlContainLine, getTomlFilePaths, replaceLineInLocalToml, serverTomlExistsInProject, } from "../../tomlFile.js";
+const internalPortOptionRegex = /internal_port = \d+/g;
+const serverAppPort = 8080;
+const clientAppPort = 8043;
+export async function setup(baseName, region, cmdOptions) {
+    waspSays("Setting up your Wasp app with Fly.io!");
+    await ensureWaspProjectIsBuilt(cmdOptions);
+    const tomlFilePaths = getTomlFilePaths(cmdOptions);
+    const deploymentInstructions = createDeploymentInstructions({
+        baseName,
+        region,
+        cmdOptions,
+        tomlFilePaths,
+    });
+    if (serverTomlExistsInProject(tomlFilePaths)) {
+        waspSays(`${tomlFilePaths.serverTomlPath} exists. Skipping server setup.`);
+    }
+    else {
+        await setupServer(deploymentInstructions);
+    }
+    if (clientTomlExistsInProject(tomlFilePaths)) {
+        waspSays(`${tomlFilePaths.clientTomlPath} exists. Skipping client setup.`);
+    }
+    else {
+        await setupClient(deploymentInstructions);
+    }
+    waspSays(`Don't forget to create your database by running "${getFullCommandName(createFlyDbCommand)}".`);
+}
+async function setupServer(deploymentInstructions) {
+    waspSays(`Setting up server app with name ${deploymentInstructions.serverFlyAppName}`);
+    cd(getServerBuildDir(deploymentInstructions.cmdOptions.waspProjectDir));
+    deleteLocalToml();
+    const launchArgs = [
+        "--name",
+        deploymentInstructions.serverFlyAppName,
+        "--region",
+        deploymentInstructions.region,
+    ];
+    if (deploymentInstructions.cmdOptions.org) {
+        launchArgs.push("--org", deploymentInstructions.cmdOptions.org);
+    }
+    // This creates the fly.toml file, but does not attempt to deploy.
+    await $ `flyctl launch --no-deploy ${launchArgs}`;
+    const minMachinesOptionRegex = /min_machines_running = 0/g;
+    if (!doesLocalTomlContainLine(minMachinesOptionRegex)) {
+        await question(`\n⚠️  There was a possible issue setting up your server app.
+We tried modifying your server fly.toml to set ${chalk.bold("min_machines_running = 1")}, but couldn't find the option ${chalk.bold("min_machines_running")} in the fly.toml.
+
+We advise that you additionaly check what is the value for "minimal number of machines running" on Fly
+for this server app and confirm that it is set to the value you are OK with.
+
+Be aware that if it is set to 0, your server will shut down when there are no requests from the client,
+which might be an issue for you if you have recurring Jobs or some other processes that need to keep
+running on the server even without external input, in which case we advise keeping "minimal number
+of machines running" setting at a number larger than zero.
+
+Contact the Wasp Team at our Discord server if you need help with this: https://discord.gg/rzdnErX
+
+Press any key to continue or Ctrl+C to cancel.`);
+    }
+    else {
+        replaceLineInLocalToml(minMachinesOptionRegex, "min_machines_running = 1");
+    }
+    if (!doesLocalTomlContainLine(internalPortOptionRegex)) {
+        await question(`\n⚠️  There was an issue setting up your server app.
+We tried modifying your server fly.toml to set ${chalk.bold(`internal_port = ${serverAppPort}`)}, but couldn't find the option ${chalk.bold("internal_port")} in the fly.toml.
+
+This means your server app might not be accessible.
+
+Contact the Wasp Team at our Discord server if you need help with this: https://discord.gg/rzdnErX
+
+Press any key to continue or Ctrl+C to cancel.`);
+    }
+    else {
+        replaceLineInLocalToml(internalPortOptionRegex, `internal_port = ${serverAppPort}`);
+    }
+    copyLocalServerTomlToProject(deploymentInstructions.tomlFilePaths);
+    const jwtSecret = generateRandomHexString();
+    const secretsArgs = [
+        `JWT_SECRET=${jwtSecret}`,
+        // NOTE: Normally these would just be envars, but flyctl
+        // doesn't provide a way to set envars that persist to fly.toml.
+        `PORT=${serverAppPort}`,
+        `WASP_WEB_CLIENT_URL=${getFlyAppUrl(deploymentInstructions.clientFlyAppName)}`,
+        `WASP_SERVER_URL=${getFlyAppUrl(deploymentInstructions.serverFlyAppName)}`,
+    ];
+    if (deploymentInstructions.cmdOptions.serverSecret.length > 0) {
+        deploymentInstructions.cmdOptions.serverSecret.forEach((secret) => {
+            secretsArgs.push(secret);
+        });
+    }
+    await $ `flyctl secrets set ${secretsArgs}`;
+    console.log(""); // `flyctl secrets` does not produce it's own newline.
+    waspSays("Server setup complete!");
+}
+async function setupClient(deploymentInstructions) {
+    waspSays(`Setting up client app with name ${deploymentInstructions.clientFlyAppName}`);
+    cd(getClientBuildDir(deploymentInstructions.cmdOptions.waspProjectDir));
+    deleteLocalToml();
+    const launchArgs = [
+        "--name",
+        deploymentInstructions.clientFlyAppName,
+        "--region",
+        deploymentInstructions.region,
+    ];
+    if (deploymentInstructions.cmdOptions.org) {
+        launchArgs.push("--org", deploymentInstructions.cmdOptions.org);
+    }
+    // This creates the fly.toml file, but does not attempt to deploy.
+    await $ `flyctl launch --no-deploy ${launchArgs}`;
+    if (!doesLocalTomlContainLine(internalPortOptionRegex)) {
+        await question(`\n⚠️  There was an issue setting up your client app.
+We tried modifying your client fly.toml to set ${chalk.bold(`internal_port = ${clientAppPort}`)}, but couldn't find the option ${chalk.bold("internal_port")} in the fly.toml.
+
+This means your client app might not be accessible.
+
+Contact the Wasp Team at our Discord server if you need help with this: https://discord.gg/rzdnErX
+
+Press any key to continue or Ctrl+C to cancel.`);
+    }
+    else {
+        // goStatic listens on port 8043 by default, but the default fly.toml
+        // assumes port 8080 (or 3000, depending on flyctl version).
+        replaceLineInLocalToml(internalPortOptionRegex, `internal_port = ${clientAppPort}`);
+    }
+    copyLocalClientTomlToProject(deploymentInstructions.tomlFilePaths);
+    if (deploymentInstructions.cmdOptions.clientSecret.length > 0) {
+        await $ `flyctl secrets set ${deploymentInstructions.cmdOptions.clientSecret}`;
+    }
+    waspSays("Client setup complete!");
+}
+//# sourceMappingURL=setup.js.map

package/data/packages/deploy/dist/providers/fly/flyAppUrl.js

@@ -0,0 +1,4 @@
+export function getFlyAppUrl(flyAppName) {
+    return `https://${flyAppName}.fly.dev`;
+}
+//# sourceMappingURL=flyAppUrl.js.map

package/data/packages/deploy/dist/providers/fly/flyCli.js

@@ -0,0 +1,74 @@
+import { confirm } from "@inquirer/prompts";
+import { $ } from "zx";
+import { getFullCommandName } from "../../common/commander.js";
+import { executeFlyCommand } from "./index.js";
+import { FlyRegionListSchema, FlySecretListSchema, } from "./jsonOutputSchemas.js";
+export async function flyctlExists() {
+    try {
+        await $ `flyctl version`;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isUserLoggedIn() {
+    try {
+        await $ `flyctl auth whoami`;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureUserLoggedIn() {
+    const userLoggedIn = await isUserLoggedIn();
+    if (userLoggedIn) {
+        return;
+    }
+    const wantsToLogin = await confirm({
+        message: "flyctl is not logged into Fly.io. Would you like to log in now?",
+    });
+    if (!wantsToLogin) {
+        throw new Error("Unable to continue without logging in to Fly.io.");
+    }
+    try {
+        await $ `flyctl auth login`;
+    }
+    catch {
+        throw new Error('It seems there was a problem logging in. Please run "flyctl auth login" and try again.');
+    }
+}
+export async function ensureFlyReady() {
+    const doesFlyctlExist = await flyctlExists();
+    if (!doesFlyctlExist) {
+        throw new Error(`The Fly.io CLI is not available on this system.\nPlease install the flyctl here: https://fly.io/docs/hands-on/install-flyctl`);
+    }
+    await ensureUserLoggedIn();
+}
+export async function assertRegionIsValid(region) {
+    const validRegion = await regionExists(region);
+    if (!validRegion) {
+        const flyRegionsCommand = `${getFullCommandName(executeFlyCommand)} platform regions --context server`;
+        throw new Error([
+            `Invalid region code ${region}. Please specify a valid 3 character region id: https://fly.io/docs/reference/regions`,
+            `You can also run "${flyRegionsCommand}".`,
+        ].join("\n"));
+    }
+}
+async function regionExists(regionCode) {
+    const proc = await $ `flyctl platform regions -j`.verbose(false);
+    const regions = FlyRegionListSchema.parse(proc.json());
+    return regions.some((r) => {
+        return r.code === regionCode;
+    });
+}
+export async function secretExists(secretName) {
+    const proc = await $ `flyctl secrets list -j`;
+    const secrets = FlySecretListSchema.parse(proc.json());
+    return secrets.some((s) => {
+        const name = "name" in s ? s.name : s.Name;
+        return name === secretName;
+    });
+}
+//# sourceMappingURL=flyCli.js.map

package/data/packages/deploy/dist/providers/fly/index.js

@@ -0,0 +1,121 @@
+import { Command, Option } from "commander";
+import { assertValidWaspProject, assertWaspProjectDirIsAbsoluteAndPresent, } from "../../common/waspProject.js";
+import { cmd as cmdFn } from "./commands/cmd/cmd.js";
+import { createDb as createDbFn } from "./commands/createDb/createDb.js";
+import { deploy as deployFn } from "./commands/deploy/deploy.js";
+import { launch as launchFn } from "./commands/launch/launch.js";
+import { setup as setupFn } from "./commands/setup/setup.js";
+import { ContextOption } from "./CommonOps.js";
+import { assertRegionIsValid, ensureFlyReady } from "./flyCli.js";
+import { assertFlyTomlDirIsAbsoluteAndPresent } from "./tomlFile.js";
+class FlyCommand extends Command {
+    addBasenameArgument() {
+        return this.argument("<basename>", "base app name to use on Fly.io (must be unique)");
+    }
+    addRegionArgument() {
+        return this.argument("<region>", "3 letter deployment region to use on Fly.io");
+    }
+    addDbOptions() {
+        return this.option("--vm-size <vmSize>", "flyctl postgres create option", "shared-cpu-1x")
+            .option("--initial-cluster-size <initialClusterSize>", "flyctl postgres create option", "1")
+            .option("--volume-size <volumeSize>", "flyctl postgres create option", "1")
+            .option("--db-image <dbImage>", "custom Docker image for the PostgreSQL database");
+    }
+    addLocalBuildOption() {
+        return this.option("--build-locally", "build Docker containers locally instead of remotely", false);
+    }
+    addSecretsOptions() {
+        function collect(value, previous) {
+            return previous.concat([value]);
+        }
+        return this.option("--server-secret <serverSecret>", "secret to set on the server app (of form FOO=BAR)", collect, []).option("--client-secret <clientSecret>", "secret to set on the client app (of form FOO=BAR)", collect, []);
+    }
+}
+const flyLaunchCommand = makeFlyLaunchCommand();
+export const flySetupCommand = makeFlySetupCommand();
+export const createFlyDbCommand = makeCreateFlyDbCommand();
+export const flyDeployCommand = makeFlyDeployCommand();
+export const executeFlyCommand = makeExecuteFlyCommand();
+export function createFlyCommand() {
+    const fly = new Command("fly")
+        .description("Create and deploy Wasp apps on Fly.io")
+        .addCommand(flyLaunchCommand)
+        .addCommand(flySetupCommand)
+        .addCommand(createFlyDbCommand)
+        .addCommand(flyDeployCommand)
+        .addCommand(executeFlyCommand)
+        .allowUnknownOption();
+    // Add global options and hooks to all commands.
+    // Add these hooks before any command-specific ones so they run first.
+    // NOTE: When we add another provider, consider pulling `--wasp-exe` and `--wasp-project-dir`
+    // up as a global option that every provider can use (if possible).
+    fly.commands.forEach((cmd) => {
+        cmd
+            .addOption(new Option("--wasp-exe <path>", "Wasp executable (either on PATH or absolute path)")
+            .hideHelp()
+            .makeOptionMandatory())
+            .addOption(new Option("--wasp-project-dir <dir>", "absolute path to Wasp project dir")
+            .hideHelp()
+            .makeOptionMandatory())
+            .option("--fly-toml-dir <dir>", "absolute path to dir where fly.toml files live")
+            .option("--org <org>", "Fly org to use (with commands that support it)")
+            .hook("preAction", async (cmd) => {
+            const { waspProjectDir, waspExe, flyTomlDir } = cmd.opts();
+            await ensureFlyReady();
+            assertWaspProjectDirIsAbsoluteAndPresent(waspProjectDir);
+            if (flyTomlDir !== undefined) {
+                assertFlyTomlDirIsAbsoluteAndPresent(flyTomlDir);
+            }
+            await assertValidWaspProject(waspProjectDir, waspExe);
+        });
+    });
+    // Add command-specific hooks.
+    flyLaunchCommand.hook("preAction", (_thisCommand, actionCommand) => assertRegionIsValid(actionCommand.args[1]));
+    flySetupCommand.hook("preAction", (_thisCommand, actionCommand) => assertRegionIsValid(actionCommand.args[1]));
+    createFlyDbCommand.hook("preAction", (_thisCommand, actionCommand) => assertRegionIsValid(actionCommand.args[0]));
+    return fly;
+}
+function makeFlyLaunchCommand() {
+    return new FlyCommand("launch")
+        .description("Launch a new app on Fly.io (calls setup, create-db, and deploy)")
+        .addBasenameArgument()
+        .addRegionArgument()
+        .addDbOptions()
+        .addLocalBuildOption()
+        .addSecretsOptions()
+        .action(launchFn);
+}
+function makeFlySetupCommand() {
+    return new FlyCommand("setup")
+        .description("Set up a new app on Fly.io (this does not deploy it)")
+        .addBasenameArgument()
+        .addRegionArgument()
+        .addSecretsOptions()
+        .action(setupFn);
+}
+function makeFlyDeployCommand() {
+    return new FlyCommand("deploy")
+        .description("(Re-)Deploy existing app to Fly.io")
+        .option("--skip-client", "do not deploy the web client")
+        .option("--skip-server", "do not deploy the server")
+        .addLocalBuildOption()
+        .action(deployFn);
+}
+function makeExecuteFlyCommand() {
+    return new FlyCommand("cmd")
+        .description("Run arbitrary flyctl commands for server or client")
+        .argument("<cmd...>", "flyctl command to run in server/client context")
+        .addOption(new Option("--context <context>", "client or server context")
+        .choices(Object.values(ContextOption))
+        .makeOptionMandatory())
+        .action(cmdFn)
+        .allowUnknownOption();
+}
+function makeCreateFlyDbCommand() {
+    return new FlyCommand("create-db")
+        .description("Creates a Postgres DB and attaches it to the server app")
+        .addRegionArgument()
+        .addDbOptions()
+        .action(createDbFn);
+}
+//# sourceMappingURL=index.js.map

package/data/packages/deploy/dist/providers/fly/jsonOutputSchemas.js

@@ -0,0 +1,37 @@
+import * as z from "zod";
+const FlyRegionSchema = z.object({
+    code: z.string(),
+    name: z.string(),
+});
+const FlyRegionSchemaLegacy = z
+    .object({
+    Code: z.string(),
+    Name: z.string(),
+})
+    .transform((data) => ({
+    code: data.Code,
+    name: data.Name,
+}));
+export const FlyRegionListSchema = z.union([
+    // version before flyctl v0.3.121
+    z.array(FlyRegionSchemaLegacy),
+    // version as of flyctl v0.3.121
+    z.array(FlyRegionSchema),
+    // version as of flyctl v0.3.214
+    z
+        .object({
+        Regions: z.array(FlyRegionSchema),
+    })
+        .transform((data) => data.Regions),
+]);
+export const FlySecretListSchema = z.union([
+    // current version
+    z.array(z.object({
+        Name: z.string(),
+    })),
+    // not the output yet, but just in case they update the command in the future
+    z.array(z.object({
+        name: z.string(),
+    })),
+]);
+//# sourceMappingURL=jsonOutputSchemas.js.map

package/data/packages/deploy/dist/providers/fly/tomlFile.js

@@ -0,0 +1,65 @@
+import fs from "fs";
+import path from "node:path";
+import toml from "toml";
+import { assertDirExists, assertDirPathIsAbsolute, } from "../../common/validation.js";
+export function getTomlFilePaths(cmdOptions) {
+    const baseDir = cmdOptions.flyTomlDir || cmdOptions.waspProjectDir;
+    return {
+        serverTomlPath: path.join(baseDir, "fly-server.toml"),
+        clientTomlPath: path.join(baseDir, "fly-client.toml"),
+    };
+}
+export function serverTomlExistsInProject(paths) {
+    return fs.existsSync(paths.serverTomlPath);
+}
+export function copyLocalServerTomlToProject(paths) {
+    fs.copyFileSync("fly.toml", paths.serverTomlPath);
+}
+export function copyProjectServerTomlLocally(paths) {
+    fs.copyFileSync(paths.serverTomlPath, "fly.toml");
+}
+export function clientTomlExistsInProject(paths) {
+    return fs.existsSync(paths.clientTomlPath);
+}
+export function copyLocalClientTomlToProject(paths) {
+    fs.copyFileSync("fly.toml", paths.clientTomlPath);
+}
+export function copyProjectClientTomlLocally(paths) {
+    fs.copyFileSync(paths.clientTomlPath, "fly.toml");
+}
+export function localTomlExists() {
+    return fs.existsSync("fly.toml");
+}
+export function deleteLocalToml() {
+    if (localTomlExists()) {
+        fs.unlinkSync("fly.toml");
+    }
+}
+export function getAppNameFromToml(path) {
+    const content = fs.readFileSync(path, "utf8");
+    const data = toml.parse(content);
+    return data.app;
+}
+export function getInferredBasenameFromServerToml(paths) {
+    const serverFlyAppName = getAppNameFromToml(paths.serverTomlPath);
+    return serverFlyAppName.replace("-server", "");
+}
+export function getInferredBasenameFromClientToml(paths) {
+    const clientFlyAppName = getAppNameFromToml(paths.clientTomlPath);
+    return clientFlyAppName.replace("-client", "");
+}
+export function replaceLineInLocalToml(searchValue, replaceValue) {
+    const content = fs.readFileSync("fly.toml", "utf8");
+    const updatedContent = content.replace(searchValue, replaceValue);
+    fs.writeFileSync("fly.toml", updatedContent);
+}
+export function doesLocalTomlContainLine(searchValue) {
+    const content = fs.readFileSync("fly.toml", "utf8");
+    return content.search(searchValue) !== -1;
+}
+export function assertFlyTomlDirIsAbsoluteAndPresent(flyTomlDirPath) {
+    const dirNameInError = "TOML directory";
+    assertDirPathIsAbsolute(flyTomlDirPath, dirNameInError);
+    assertDirExists(flyTomlDirPath, dirNameInError);
+}
+//# sourceMappingURL=tomlFile.js.map

package/data/packages/deploy/dist/providers/railway/DeploymentInstructions.js

@@ -0,0 +1,11 @@
+import { createRailwayClientServiceName, createRailwayDbServiceName, createRailwayServerServiceName, } from "./railwayService/nameGenerator.js";
+export function createDeploymentInstructions(projectName, cmdOptions) {
+    return Object.freeze({
+        projectName,
+        cmdOptions,
+        clientServiceName: createRailwayClientServiceName(projectName),
+        serverServiceName: createRailwayServerServiceName(projectName),
+        dbServiceName: createRailwayDbServiceName(),
+    });
+}
+//# sourceMappingURL=DeploymentInstructions.js.map

package/data/packages/deploy/dist/providers/railway/brandedTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=brandedTypes.js.map

package/data/packages/deploy/dist/providers/railway/commands/deploy/DeployCmdOptions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DeployCmdOptions.js.map

package/data/packages/deploy/dist/providers/railway/commands/deploy/client.js

@@ -0,0 +1,22 @@
+import { buildClient } from "../../../../common/clientApp.js";
+import { displayWaspRocketImage, waspSays, } from "../../../../common/terminal.js";
+import { clientAppPort, serverAppPort } from "../../ports.js";
+import { generateServiceUrl } from "../../railwayService/url.js";
+import { deployServiceWithStreamingLogs, ServiceDeploymentStatus, } from "./common.js";
+export async function deployClient({ cmdOptions: options, serverServiceName, clientServiceName, }) {
+    waspSays("Deploying your client now...");
+    const serverServiceUrl = await generateServiceUrl(serverServiceName, serverAppPort, options);
+    const clientBuildArtefactsDir = await buildClient(serverServiceUrl, options);
+    const deploymentStatus = await deployServiceWithStreamingLogs({
+        name: clientServiceName,
+        dirToDeploy: clientBuildArtefactsDir,
+    }, options);
+    displayWaspRocketImage();
+    const clientUrl = await generateServiceUrl(clientServiceName, clientAppPort, options);
+    const messages = {
+        [ServiceDeploymentStatus.SUCCESS]: `Client has been deployed! Your Wasp app is accessible at: ${clientUrl}`,
+        [ServiceDeploymentStatus.FAILED_TO_STREAM_LOGS]: `Client deployment started, but failed to stream build logs. Your Wasp app should be accessible at: ${clientUrl}`,
+    };
+    waspSays(messages[deploymentStatus]);
+}
+//# sourceMappingURL=client.js.map

package/data/packages/deploy/dist/providers/railway/commands/deploy/common.js

@@ -0,0 +1,40 @@
+import { ProcessOutput } from "zx";
+import { waspSays } from "../../../../common/terminal.js";
+import { createCommandWithCwd } from "../../../../common/zx.js";
+export var ServiceDeploymentStatus;
+(function (ServiceDeploymentStatus) {
+    ServiceDeploymentStatus["SUCCESS"] = "SUCCESS";
+    ServiceDeploymentStatus["FAILED_TO_STREAM_LOGS"] = "FAILED_TO_STREAM_LOGS";
+})(ServiceDeploymentStatus || (ServiceDeploymentStatus = {}));
+export async function deployServiceWithStreamingLogs(service, options) {
+    try {
+        const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
+        await railwayCli([
+            "up",
+            service.dirToDeploy,
+            "--service",
+            service.name,
+            "--no-gitignore",
+            // This option fixes a Railway CLI quirk to package the
+            // service directory as the root of the deployment.
+            "--path-as-root",
+            // This option enables service build logs streaming.
+            "--ci",
+        ]);
+        return ServiceDeploymentStatus.SUCCESS;
+    }
+    catch (e) {
+        if (isFailedToStreamLogsError(e)) {
+            // The deployment most likely didn't fail, we only failed to stream the logs.
+            // This can happen with the Railway CLI, and the deployment might still be successful.
+            waspSays(`Failed to stream build log for service "${service.name}". This sometimes happens with the Railway CLI. Please check the Railway dashboard for build logs.`);
+            return ServiceDeploymentStatus.FAILED_TO_STREAM_LOGS;
+        }
+        throw new Error(`Error deploying service "${service.name}", please check the command output.`);
+    }
+}
+function isFailedToStreamLogsError(error) {
+    return (error instanceof ProcessOutput &&
+        error.stderr.includes("Failed to stream build log"));
+}
+//# sourceMappingURL=common.js.map