@dbos-inc/dbos-cloud 0.8.41-preview → 0.8.43-preview

package/Gruntfile.js

@@ -0,0 +1,9 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+var nbgv = require('nerdbank-gitversioning')
+
+module.exports = function (grunt) {
+    grunt.registerTask('setversion', function () {
+        var done = this.async();
+        nbgv.setPackageVersion().then(() => done());
+    });
+};

package/applications/delete-app.ts

@@ -0,0 +1,36 @@
+import axios from "axios";
+import { GlobalLogger } from "../../../src/telemetry/logs";
+import { getCloudCredentials } from "../cloudutils";
+import path from "node:path";
+
+export async function deleteApp(host: string): Promise<number> {
+  const logger = new GlobalLogger();
+  const userCredentials = getCloudCredentials();
+  const bearerToken = "Bearer " + userCredentials.token;
+
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const packageJson = require(path.join(process.cwd(), 'package.json')) as { name: string };
+  const appName = packageJson.name;
+  logger.info(`Loaded application name from package.json: ${appName}`)
+  logger.info(`Deleting application: ${appName}`)
+
+  try {
+    await axios.delete(`https://${host}/${userCredentials.userName}/application/${appName}`, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: bearerToken,
+      },
+    });
+
+    logger.info(`Successfully deleted application: ${appName}`);
+    return 0;
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.response) {
+      logger.error(`Failed to delete application ${appName}: ${e.response?.data}`);
+      return 1;
+    } else {
+      logger.error(`Failed to delete application ${appName}: ${(e as Error).message}`);
+      return 1;
+    }
+  }
+}

package/applications/deploy-app-code.ts

@@ -0,0 +1,159 @@
+import axios from "axios";
+import { execSync } from "child_process";
+import { writeFileSync, existsSync } from 'fs';
+import { GlobalLogger } from "../../../src/telemetry/logs";
+import { getCloudCredentials, runCommand } from "../cloudutils";
+import { createDirectory, readFileSync, sleep } from "../../../src/utils";
+import path from "path";
+import { Application } from "./types";
+
+const deployDirectoryName = "dbos_deploy";
+
+type DeployOutput = {
+  ApplicationName: string;
+  ApplicationVersion: string;
+}
+
+export async function deployAppCode(host: string, docker: boolean): Promise<number> {
+  const logger = new GlobalLogger();
+  const userCredentials = getCloudCredentials();
+  const bearerToken = "Bearer " + userCredentials.token;
+
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const packageJson = require(path.join(process.cwd(), 'package.json')) as { name: string };
+  const appName = packageJson.name;
+  logger.info(`Loaded application name from package.json: ${appName}`)
+
+  createDirectory(deployDirectoryName);
+
+  // Verify that package-lock.json exists
+  if (!existsSync(path.join(process.cwd(), 'package-lock.json'))) {
+    logger.error("package-lock.json not found. Please run 'npm install' before deploying.")
+    return 1;
+  }
+
+  if (docker) {
+    // Build the application inside a Docker container using the same base image as our cloud setup
+    logger.info(`Building ${appName} using Docker`)
+    const dockerSuccess = await buildAppInDocker(appName);
+    if (!dockerSuccess) {
+      return 1;
+    }
+  } else {
+    // Zip the current directory and deploy from there. Requires app to have already been built. Only for testing.
+    execSync(`zip -ry ${deployDirectoryName}/${appName}.zip ./* -x ${deployDirectoryName}/* > /dev/null`);
+  }
+
+  try {
+    const zipData = readFileSync(`${deployDirectoryName}/${appName}.zip`, "base64");
+
+    // Submit the deploy request
+    logger.info(`Submitting deploy request for ${appName}`)
+    const response = await axios.post(
+      `https://${host}/${userCredentials.userName}/application/${appName}`,
+      {
+        application_archive: zipData,
+      },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: bearerToken,
+        },
+      }
+    );
+    const deployOutput = response.data as DeployOutput;
+    logger.info(`Submitted deploy request for ${appName}. Assigned version: ${deployOutput.ApplicationVersion}`);
+
+    // Wait for the application to become available
+    let count = 0
+    let applicationAvailable = false
+    while (!applicationAvailable) {
+      count += 1
+      if (count % 5 === 0) {
+        logger.info(`Waiting for ${appName} with version ${deployOutput.ApplicationVersion} to be available`);
+        if (count > 20) {
+          logger.info(`If ${appName} takes too long to become available, check its logs at...`);
+        }
+      }
+
+      // Retrieve the application status, check if it is "AVAILABLE"
+      const list = await axios.get(
+        `https://${host}/${userCredentials.userName}/application`,
+        {
+          headers: {
+            Authorization: bearerToken,
+          },
+        }
+      );
+      const applications: Application[] = list.data as Application[];
+      for (const application of applications) {
+        if (application.Name === appName && application.Status === "AVAILABLE") {
+          applicationAvailable = true
+        }
+      }
+      await sleep(1000)
+    }
+    logger.info(`Application ${appName} successfuly deployed`)
+    logger.info(`Access your application at https://${host}/${userCredentials.userName}/application/${appName}`)
+    return 0;
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.response) {
+      logger.error(`Failed to deploy application ${appName}: ${e.response?.data}`);
+      return 1;
+    } else {
+      logger.error(`Failed to deploy application ${appName}: ${(e as Error).message}`);
+      return 1;
+    }
+  }
+}
+
+async function buildAppInDocker(appName: string): Promise<boolean> {
+  const logger = new GlobalLogger();
+
+  // Verify Docker is running
+  try {
+    execSync(`docker > /dev/null 2>&1`)
+  } catch (e) {
+    logger.error("Docker not available.  To deploy, please start the Docker daemon and make the `docker` command runnable without sudo.")
+    return false
+  }
+
+  const dockerFileName = `${deployDirectoryName}/Dockerfile.dbos`;
+  const containerName = `dbos-builder-${appName}`;
+
+  // Dockerfile content
+  const dockerFileContent = `
+FROM node:lts-bookworm-slim
+RUN apt update
+RUN apt install -y zip
+WORKDIR /app
+COPY . .
+RUN npm clean-install
+RUN npm run build
+RUN npm prune --omit=dev
+RUN zip -ry ${appName}.zip ./* -x "${appName}.zip" -x "${deployDirectoryName}/*" > /dev/null
+`;
+  const dockerIgnoreContent = `
+node_modules/
+${deployDirectoryName}/
+dist/
+`;
+  try {
+    // Write the Dockerfile and .dockerignore
+    writeFileSync(dockerFileName, dockerFileContent);
+    writeFileSync(`${deployDirectoryName}/Dockerfile.dbos.dockerignore`, dockerIgnoreContent);
+    // Build the Docker image.  As build takes a long time, use runCommand to stream its output to stdout.
+    await runCommand('docker', ['build', '-t', appName, '-f', dockerFileName, '.'])
+    // Run the container
+    execSync(`docker run -d --name ${containerName} ${appName}`);
+    // Copy the archive from the container to the local deploy directory
+    execSync(`docker cp ${containerName}:/app/${appName}.zip ${deployDirectoryName}/${appName}.zip`);
+    // Stop and remove the container
+    execSync(`docker stop ${containerName}`);
+    execSync(`docker rm ${containerName}`);
+    return true;
+  } catch (e) {
+    logger.error(`Failed to build application ${appName}: ${(e as Error).message}`);
+    return false;
+  }
+}

package/applications/get-app-logs.ts

@@ -0,0 +1,36 @@
+import axios from "axios";
+import { GlobalLogger } from "../../../src/telemetry/logs";
+import { getCloudCredentials } from "../cloudutils";
+import path from "node:path";
+
+export async function getAppLogs(host: string): Promise<number> {
+  const logger = new GlobalLogger();
+  const userCredentials = getCloudCredentials();
+  const bearerToken = "Bearer " + userCredentials.token;
+
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const packageJson = require(path.join(process.cwd(), 'package.json')) as { name: string };
+  const appName = packageJson.name;
+  logger.info(`Retrieving logs for application: ${appName}`)
+
+  try {
+    const res = await axios.get(`https://${host}/${userCredentials.userName}/logs/application/${appName}`, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: bearerToken,
+      },
+    });
+
+    logger.info(`Successfully retrieved logs of application: ${appName}`);
+    logger.info(res.data)
+    return 0;
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.response) {
+      logger.error(`Failed to retrieve logs of application ${appName}: ${e.response?.data}`);
+      return 1;
+    } else {
+      logger.error(`Failed to retrieve logs of application ${appName}: ${(e as Error).message}`);
+      return 1;
+    }
+  }
+}

package/applications/index.ts

@@ -0,0 +1,7 @@
+export { registerApp } from './register-app';
+export { listApps } from './list-apps';
+export { deleteApp } from './delete-app';
+export { deployAppCode } from './deploy-app-code';
+export { getAppLogs } from './get-app-logs';
+export { updateApp } from './update-app';
+

package/applications/list-apps.ts

@@ -0,0 +1,41 @@
+import axios from "axios";
+import { GlobalLogger } from "../../../src/telemetry/logs";
+import { getCloudCredentials } from "../cloudutils";
+import { Application } from "./types";
+
+export async function listApps(host: string): Promise<number> {
+  const logger = new GlobalLogger();
+  const userCredentials = getCloudCredentials();
+  const bearerToken = "Bearer " + userCredentials.token;
+
+  try {
+    const list = await axios.get(
+      `https://${host}/${userCredentials.userName}/application`,
+      {
+        headers: {
+          Authorization: bearerToken,
+        },
+      }
+    );
+    const data: Application[] = list.data as Application[];
+    if (data.length === 0) {
+      logger.info("No applications found");
+      return 1;
+    }
+    const formattedData: Application[] = []
+    for (const application of data) {
+      formattedData.push({ "Name": application.Name, "ID": application.ID, "Version": application.Version, "DatabaseName": application.DatabaseName, "MaxVMs": application.MaxVMs, "Status": application.Status });
+    }
+    logger.info(`Listing applications for ${userCredentials.userName}`)
+    console.log(JSON.stringify(formattedData));
+    return 0;
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.response) {
+      logger.error(`Failed to list applications: ${e.response?.data}`);
+      return 1;
+    } else {
+      logger.error(`Failed to list applications: ${(e as Error).message}`);
+      return 1;
+    }
+  }
+}

package/applications/register-app.ts

@@ -0,0 +1,45 @@
+import axios from "axios";
+import { GlobalLogger } from "../../../src/telemetry/logs";
+import { getCloudCredentials } from "../cloudutils";
+import path from "node:path";
+
+export async function registerApp(dbname: string, host: string, machines: number): Promise<number> {
+  const logger = new GlobalLogger();
+  const userCredentials = getCloudCredentials();
+  const bearerToken = "Bearer " + userCredentials.token;
+
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const packageJson = require(path.join(process.cwd(), 'package.json')) as { name: string };
+  const appName = packageJson.name;
+  logger.info(`Loaded application name from package.json: ${appName}`)
+  logger.info(`Registering application: ${appName}`)
+
+  try {
+    const register = await axios.put(
+      `https://${host}/${userCredentials.userName}/application`,
+      {
+        name: appName,
+        database: dbname,
+        max_vms: machines,
+      },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: bearerToken,
+        },
+      }
+    );
+    const uuid = register.data as string;
+    logger.info(`Successfully registered: ${appName}`);
+    logger.info(`${appName} ID: ${uuid}`);
+    return 0;
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.response) {
+      logger.error(`Failed to register application ${appName}: ${e.response?.data}`);
+      return 1;
+    } else {
+      logger.error(`Failed to register application ${appName}: ${(e as Error).message}`);
+      return 1;
+    }
+  }
+}

package/applications/types.ts

@@ -0,0 +1,8 @@
+export type Application = {
+  Name: string;
+  ID: string;
+  DatabaseName: string;
+  Status: string;
+  Version: string;
+  MaxVMs: string;
+};

package/applications/update-app.ts

@@ -0,0 +1,47 @@
+import axios from "axios";
+import { GlobalLogger } from "../../../src/telemetry/logs";
+import { getCloudCredentials } from "../cloudutils";
+import { Application } from "./types";
+import path from "node:path";
+
+export async function updateApp(host: string, machines: number): Promise<number> {
+  const logger =  new GlobalLogger();
+  const userCredentials = getCloudCredentials();
+  const bearerToken = "Bearer " + userCredentials.token;
+  
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const packageJson = require(path.join(process.cwd(), 'package.json')) as { name: string };
+  const appName = packageJson.name;
+  logger.info(`Loaded application name from package.json: ${appName}`)
+  logger.info(`Updating application: ${appName}`)
+
+  try {
+    logger.info(`Updating application ${appName} to ${machines} machines`);
+    const update = await axios.patch(
+      `https://${host}/${userCredentials.userName}/application/${appName}`,
+      {
+        name: appName,
+        max_vms: machines
+      },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: bearerToken,
+        },
+      }
+    );
+    const application: Application = update.data as Application;
+    logger.info(`Successfully updated: ${application.Name}`);
+    console.log(JSON.stringify({ "Name": application.Name, "ID": application.ID, "Version": application.Version, "MaxVMs": application.MaxVMs }));
+    return 0;
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.response) {
+      logger.error(`Failed to update application ${appName}: ${e.response?.data}`);
+      return 1;
+    } else {
+      (e as Error).message = `Failed to update application ${appName}: ${(e as Error).message}`;
+      logger.error(e);
+      return 1;
+    }
+  }
+}

package/cloudutils.ts

@@ -0,0 +1,42 @@
+import { DBOSCloudCredentials, dbosEnvPath } from "./login";
+import fs from "fs";
+import { spawn, StdioOptions } from 'child_process';
+import { GlobalLogger } from "../../src/telemetry/logs";
+
+export function getCloudCredentials(): DBOSCloudCredentials {
+  const logger = new GlobalLogger();
+  if (!credentialsExist()) {
+    logger.error("Error: not logged in")
+    process.exit(1)
+  }
+  const userCredentials = JSON.parse(fs.readFileSync(`./${dbosEnvPath}/credentials`).toString("utf-8")) as DBOSCloudCredentials;
+  return {
+    userName: userCredentials.userName,
+    token: userCredentials.token.replace(/\r|\n/g, ""), // Trim the trailing /r /n.
+  };
+}
+
+export function credentialsExist(): boolean {
+  return fs.existsSync(`./${dbosEnvPath}/credentials`);
+}
+
+// Run a command, streaming its output to stdout
+export function runCommand(command: string, args: string[] = []): Promise<number> {
+  return new Promise((resolve, reject) => {
+      const stdio: StdioOptions = 'inherit';
+
+      const process = spawn(command, args, { stdio });
+
+      process.on('close', (code) => {
+          if (code === 0) {
+              resolve(code);
+          } else {
+              reject(new Error(`Command "${command}" exited with code ${code}`));
+          }
+      });
+
+      process.on('error', (error) => {
+          reject(error);
+      });
+  });
+}

package/login.ts

@@ -0,0 +1,122 @@
+import { GlobalLogger } from "../../src/telemetry/logs";
+import axios from "axios";
+import { sleep } from "../../src/utils";
+import jwt, { JwtPayload } from 'jsonwebtoken';
+import jwksClient from 'jwks-rsa';
+import { execSync } from "child_process";
+import fs from "fs";
+
+export const dbosEnvPath = ".dbos";
+export const DBOSClientID = 'G38fLmVErczEo9ioCFjVIHea6yd0qMZu'
+export const DBOSCloudIdentifier = 'dbos-cloud-api'
+
+export interface DBOSCloudCredentials {
+  token: string;
+  userName: string;
+}
+
+interface DeviceCodeResponse {
+  device_code: string;
+  user_code: string;
+  verification_uri: string;
+  verification_uri_complete: string;
+  expires_in: number;
+  interval: number;
+}
+
+interface TokenResponse {
+  access_token: string;
+  token_type: string;
+  expires_in: number;
+}
+
+const client = jwksClient({
+  jwksUri: 'https://dbos-inc.us.auth0.com/.well-known/jwks.json'
+});
+
+async function getSigningKey(kid: string): Promise<string> {
+  const key = await client.getSigningKey(kid);
+  return key.getPublicKey();
+}
+
+async function verifyToken(token: string): Promise<JwtPayload> {
+  const decoded = jwt.decode(token, { complete: true });
+
+  if (!decoded || typeof decoded === 'string' || !decoded.header.kid) {
+    throw new Error('Invalid token');
+  }
+
+  const signingKey = await getSigningKey(decoded.header.kid);
+
+  return new Promise((resolve, reject) => {
+    jwt.verify(token, signingKey, { algorithms: ['RS256'] }, (err, verifiedToken) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(verifiedToken as JwtPayload);
+      }
+    });
+  });
+}
+
+export async function login(username: string): Promise<number> {
+  const logger = new GlobalLogger();
+  logger.info(`Logging in!`);
+
+  const deviceCodeRequest = {
+    method: 'POST',
+    url: 'https://dbos-inc.us.auth0.com/oauth/device/code',
+    headers: { 'content-type': 'application/x-www-form-urlencoded' },
+    data: { client_id: DBOSClientID, scope: 'sub', audience: DBOSCloudIdentifier }
+  };
+  let deviceCodeResponse: DeviceCodeResponse | undefined;
+  try {
+    const response = await axios.request(deviceCodeRequest);
+    deviceCodeResponse = response.data as DeviceCodeResponse;
+  } catch (e) {
+    (e as Error).message = `failed to log in: ${(e as Error).message}`;
+    logger.error(e);
+  }
+  if (!deviceCodeResponse) {
+    return 1;
+  }
+  console.log(`Login URL: ${deviceCodeResponse.verification_uri_complete}`);
+
+  const tokenRequest = {
+    method: 'POST',
+    url: 'https://dbos-inc.us.auth0.com/oauth/token',
+    headers: { 'content-type': 'application/x-www-form-urlencoded' },
+    data: new URLSearchParams({
+      grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+      device_code: deviceCodeResponse.device_code,
+      client_id: DBOSClientID
+    })
+  };
+  let tokenResponse: TokenResponse | undefined;
+  let elapsedTimeSec = 0;
+  while (elapsedTimeSec < deviceCodeResponse.expires_in) {
+    try {
+      await sleep(deviceCodeResponse.interval * 1000)
+      elapsedTimeSec += deviceCodeResponse.interval;
+      const response = await axios.request(tokenRequest);
+      tokenResponse = response.data as TokenResponse;
+      break;
+    } catch (e) {
+      logger.info(`Waiting for login...`);
+    }
+  }
+  if (!tokenResponse) {
+    return 1;
+  }
+
+  await verifyToken(tokenResponse.access_token);
+  const credentials: DBOSCloudCredentials = {
+    token: tokenResponse.access_token,
+    userName: username,
+  };
+  execSync(`mkdir -p ${dbosEnvPath}`);
+  fs.writeFileSync(`${dbosEnvPath}/credentials`, JSON.stringify(credentials), "utf-8");
+  logger.info(`Successfully logged in as user: ${credentials.userName}`);
+  logger.info(`You can view your credentials in: ./${dbosEnvPath}/credentials`);
+  return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbos-inc/dbos-cloud",
-  "version": "0.8.41-preview",
+  "version": "0.8.43-preview",
   "description": "Tool for performing application deployment to DBOS cloud",
   "license": "MIT",
   "repository": {

package/register.ts

@@ -0,0 +1,35 @@
+import axios from "axios";
+import { GlobalLogger } from "../../src/telemetry/logs";
+import { getCloudCredentials } from "./cloudutils";
+
+export async function registerUser(username: string, host: string): Promise<number> {
+  const userCredentials = getCloudCredentials();
+  const bearerToken = "Bearer " + userCredentials.token;
+  const userName = userCredentials.userName;
+  const logger = new GlobalLogger();
+  try {
+    // First, register the user.
+    const register = await axios.put(
+      `https://${host}/user`,
+      {
+        name: userName,
+      },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: bearerToken,
+        },
+      }
+    );
+    const userUUID = register.data as string;
+    logger.info(`Registered user ${userName}, UUID: ${userUUID}`);
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.response) {
+      logger.error(`Failed to register user ${userName}: ${e.response.data}`);
+    } else {
+      logger.error(`Failed to register user ${userName}: ${(e as Error).message}`);
+    }
+    return 1;
+  }
+  return 0;
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+/* Visit https://aka.ms/tsconfig to read more about this file */
+{
+  "compilerOptions": {
+    "target": "esnext",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "experimentalDecorators": true,                      /* Enable experimental support for legacy experimental decorators. */
+    "emitDecoratorMetadata": true,                       /* Emit design-type metadata for decorated declarations in source files. */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "declaration": true,                                 /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    "declarationMap": true,                              /* Create sourcemaps for d.ts files. */
+    "sourceMap": true,                                   /* Create source map files for emitted JavaScript files. */
+    "outDir": "./dist",                                  /* Specify an output folder for all emitted files. */
+    "newLine": "lf",                                     /* Set the newline character for emitting files. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    "skipLibCheck": true,                                /* Skip type checking all .d.ts files. */
+    "paths": {
+      "../../src/telemetry/*": ["../../src/telemetry/*"],
+      "../../src/utils": ["../../src/utils"],
+      "../../src/user_database": ["../../src/user_database"],
+      "../../src/system_database": ["../../src/system_database"],
+      "../../src/dbos-runtime/*": ["../../src/dbos-runtime/*"]
+    }
+  },
+  "include": [                                         /* Specifies an array of filenames or patterns to include in the program. */
+    ".",
+    "applications"
+  ],
+ /* "references": [{"path": "../.."}]*/
+}

package/userdb.ts

@@ -0,0 +1,279 @@
+import axios from "axios";
+import { GlobalLogger } from "../../src/telemetry/logs";
+import { getCloudCredentials } from "./cloudutils";
+import { readFileSync, sleep } from "../../src/utils";
+import { ConfigFile, loadConfigFile, dbosConfigFilePath } from "../../src/dbos-runtime/config";
+import { execSync } from "child_process";
+import { UserDatabaseName } from "../../src/user_database";
+import { Client, PoolConfig } from "pg";
+import { ExistenceCheck } from "../../src/system_database";
+import { systemDBSchema } from "../../schemas/system_db_schema";
+import { createUserDBSchema, userDBSchema } from "../../schemas/user_db_schema";
+
+export interface UserDBInstance {
+  readonly DBName: string;
+  readonly Status: string;
+  readonly HostName: string;
+  readonly Port: number;
+}
+
+export async function createUserDb(host: string, dbName: string, adminName: string, adminPassword: string, sync: boolean) {
+  const logger = new GlobalLogger();
+  const userCredentials = getCloudCredentials();
+  const bearerToken = "Bearer " + userCredentials.token;
+
+  try {
+    await axios.post(
+      `https://${host}/${userCredentials.userName}/databases/userdb`,
+      { Name: dbName, AdminName: adminName, AdminPassword: adminPassword },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: bearerToken,
+        },
+      }
+    );
+
+    logger.info(`Successfully started creating database: ${dbName}`);
+
+    if (sync) {
+      let status = "";
+      while (status != "available") {
+        await sleep(30000);
+        const userDBInfo = await getUserDBInfo(host, dbName);
+        logger.info(userDBInfo);
+        status = userDBInfo.Status;
+      }
+    }
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.response) {
+      logger.error(`Error creating database ${dbName}: ${e.response?.data}`);
+    } else {
+      logger.error(`Error creating database ${dbName}: ${(e as Error).message}`);
+    }
+  }
+}
+
+export async function deleteUserDb(host: string, dbName: string) {
+  const logger = new GlobalLogger();
+  const userCredentials = getCloudCredentials();
+  const bearerToken = "Bearer " + userCredentials.token;
+
+  try {
+    await axios.delete(`https://${host}/${userCredentials.userName}/databases/userdb/${dbName}`, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: bearerToken,
+      },
+    });
+    logger.info(`Database deleted: ${dbName}`);
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.response) {
+      logger.error(`Error deleting database ${dbName}: ${e.response?.data}`);
+    } else {
+      logger.error(`Error deleting database ${dbName}: ${(e as Error).message}`);
+    }
+  }
+}
+
+export async function getUserDb(host: string, dbName: string) {
+  const logger = new GlobalLogger();
+
+  try {
+    const userDBInfo = await getUserDBInfo(host, dbName);
+    logger.info(userDBInfo);
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.response) {
+      logger.error(`Error getting database ${dbName}: ${e.response?.data}`);
+    } else {
+      logger.error(`Error getting database ${dbName}: ${(e as Error).message}`);
+    }
+  }
+}
+
+export async function migrate(): Promise<number> {
+  const logger = new GlobalLogger();
+
+  // Read the configuration YAML file
+  const configFile: ConfigFile | undefined = loadConfigFile(dbosConfigFilePath);
+  if (!configFile) {
+    logger.error(`Failed to parse ${dbosConfigFilePath}`);
+    return 1;
+  }
+
+  const userDBName = configFile.database.user_database;
+
+  logger.info(`Creating database ${userDBName} if it does not already exist`);
+  const createDB = `createdb -h ${configFile.database.hostname} -p ${configFile.database.port} ${userDBName} -U ${configFile.database.username} -ew ${userDBName}`;
+  try {
+    process.env.PGPASSWORD = configFile.database.password;
+    const createDBOutput = execSync(createDB, { env: process.env }).toString();
+    if (createDBOutput.includes(`database "${userDBName}" already exists`)) {
+      logger.info(`Database ${userDBName} already exists`);
+    } else {
+      logger.info(createDBOutput);
+    }
+  } catch (e) {
+    if (e instanceof Error) {
+      if (e.message.includes(`database "${userDBName}" already exists`)) {
+        logger.info(`Database ${userDBName} already exists`);
+      } else {
+        logger.error(`Error creating database: ${e.message}`);
+        return 1;
+      }
+    } else {
+      logger.error(e);
+      return 1;
+    }
+  }
+
+  const dbType = configFile.database.user_dbclient || UserDatabaseName.KNEX;
+  const migrationScript = `node_modules/.bin/${dbType}`;
+  const migrationCommands = configFile.database.migrate;
+
+  try {
+    migrationCommands?.forEach((cmd) => {
+      const command = `node ${migrationScript} ${cmd}`;
+      logger.info(`Executing migration command: ${command}`);
+      const migrateCommandOutput = execSync(command).toString();
+      logger.info(migrateCommandOutput);
+    });
+  } catch (e) {
+    logger.error("Error running migration");
+    if (e instanceof Error) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+      const stderr = (e as any).stderr;
+      if (stderr && Buffer.isBuffer(stderr) && stderr.length > 0) {
+        logger.error(`Standard Error: ${stderr.toString().trim()}`);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+      const stdout = (e as any).stdout;
+      if (stdout && Buffer.isBuffer(stdout) && stdout.length > 0) {
+        logger.error(`Standard Output: ${stdout.toString().trim()}`);
+      }
+      if (e.message) {
+        logger.error(e.message);
+      }
+    } else {
+      logger.error(e);
+    }
+    return 1;
+  }
+
+  logger.info("Creating DBOS tables and system database.");
+  try {
+    await createDBOSTables(configFile);
+  } catch (e) {
+    if (e instanceof Error) {
+      logger.error(`Error creating DBOS system database: ${e.message}`);
+    } else {
+      logger.error(e);
+    }
+    return 1;
+  }
+  return 0;
+}
+
+export function rollbackMigration(): number {
+  const logger = new GlobalLogger();
+
+  // read the yaml file
+  const configFile: ConfigFile | undefined = loadConfigFile(dbosConfigFilePath);
+  if (!configFile) {
+    logger.error(`failed to parse ${dbosConfigFilePath}`);
+    return 1;
+  }
+
+  let dbType = configFile.database.user_dbclient;
+  if (dbType == undefined) {
+    dbType = "knex";
+  }
+
+  const rollbackcommands = configFile.database.rollback;
+
+  try {
+    rollbackcommands?.forEach((cmd) => {
+      const command = "npx " + dbType + " " + cmd;
+      logger.info("Executing " + command);
+      execSync(command);
+    });
+  } catch (e) {
+    logger.error("Error rolling back migration. ");
+    return 1;
+  }
+  return 0;
+}
+
+export async function getUserDBInfo(host: string, dbName: string): Promise<UserDBInstance> {
+  const userCredentials = getCloudCredentials();
+  const bearerToken = "Bearer " + userCredentials.token;
+
+  const res = await axios.get(`https://${host}/${userCredentials.userName}/databases/userdb/info/${dbName}`, {
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: bearerToken,
+    },
+  });
+
+  return res.data as UserDBInstance;
+}
+
+// Create DBOS system DB and tables.
+// TODO: replace this with knex to manage schema.
+async function createDBOSTables(configFile: ConfigFile) {
+  const logger = new GlobalLogger();
+
+  const userPoolConfig: PoolConfig = {
+    host: configFile.database.hostname,
+    port: configFile.database.port,
+    user: configFile.database.username,
+    password: configFile.database.password,
+    connectionTimeoutMillis: configFile.database.connectionTimeoutMillis || 3000,
+    database: configFile.database.user_database,
+  };
+
+  if (configFile.database.ssl_ca) {
+    userPoolConfig.ssl = { ca: [readFileSync(configFile.database.ssl_ca)], rejectUnauthorized: true };
+  }
+
+  const systemPoolConfig = { ...userPoolConfig };
+  systemPoolConfig.database = `${userPoolConfig.database}_dbos_sys`;
+
+  const pgUserClient = new Client(userPoolConfig);
+  await pgUserClient.connect();
+
+  // Create DBOS table/schema in user DB.
+  const schemaExists = await pgUserClient.query<ExistenceCheck>(`SELECT EXISTS (SELECT FROM information_schema.schemata WHERE schema_name = 'dbos')`);
+  if (!schemaExists.rows[0].exists) {
+    await pgUserClient.query(createUserDBSchema);
+    await pgUserClient.query(userDBSchema);
+  }
+
+  // Create the DBOS system database.
+  const dbExists = await pgUserClient.query<ExistenceCheck>(`SELECT EXISTS (SELECT FROM pg_database WHERE datname = '${systemPoolConfig.database}')`);
+  if (!dbExists.rows[0].exists) {
+    await pgUserClient.query(`CREATE DATABASE ${systemPoolConfig.database}`);
+  }
+
+  // Load the DBOS system schema.
+  const pgSystemClient = new Client(systemPoolConfig);
+  await pgSystemClient.connect();
+
+  try {
+    const tableExists = await pgSystemClient.query<ExistenceCheck>(`SELECT EXISTS (SELECT FROM information_schema.schemata WHERE schema_name = 'dbos')`);
+    if (!tableExists.rows[0].exists) {
+      await pgSystemClient.query(systemDBSchema);
+    }
+  } catch (e) {
+    const tableExists = await pgSystemClient.query<ExistenceCheck>(`SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_schema = 'dbos' AND table_name = 'operation_outputs')`);
+    if (tableExists.rows[0].exists) {
+      // If the table has been created by someone else. Ignore the error.
+      logger.warn(`System tables creation failed, may conflict with concurrent tasks: ${(e as Error).message}`);
+    } else {
+      throw e;
+    }
+  } finally {
+    await pgSystemClient.end();
+    await pgUserClient.end();
+  }
+}