attio 0.0.1-experimental.20250402.1 → 0.0.1-experimental.20250407

package/lib/commands/dev.js

@@ -8,41 +8,123 @@ import { bundleJavaScript } from "./dev/bundle-javascript.js";
 import { boot } from "./dev/boot.js";
 import { onboarding } from "./dev/onboarding.js";
 import { graphqlServer } from "./dev/graphql-server.js";
-import { upload } from "./dev/upload.js";
+import { printUploadError, upload } from "./dev/upload.js";
+import { isErrored } from "@attio/fetchable";
+import { printJsError, printTsError } from "../util/typescript.js";
+import { printBuildContextError, } from "./dev/prepare-build-contexts.js";
+import notifier from "node-notifier";
+const notifyTsErrors = (errors) => {
+    notifier.notify({
+        title: `TypeScript Error${errors.length === 1 ? "" : "s"}`,
+        message: `There ${errors.length === 1 ? "was one error" : `were ${errors.length} errors`} in your TypeScript code`,
+    });
+};
+const notifyJsErrors = (errors) => {
+    const totalErrors = (errors.errors?.length || 0) + (errors.warnings?.length || 0);
+    notifier.notify({
+        title: `JavaScript ${totalErrors === 1 ? "Error" : "Errors"}`,
+        message: `There ${totalErrors === 1 ? "was one error" : `were ${totalErrors} errors`} in your JavaScript code`,
+    });
+};
 export const optionsSchema = z.object({
     workspace: z.string().optional(),
 });
 export const dev = new Command("dev")
     .description("Develop your Attio app")
-    .addOption(new Option("--dev", "Run in development mode (additional debugging info)"))
     .addOption(new Option("--workspace <slug>", "The slug of the workspace to use"))
     .action(async (unparsedOptions) => {
     const { workspace: workspaceSlug } = optionsSchema.parse(unparsedOptions);
     const cleanupFunctions = [];
+    let isCleaningUp = false;
+    const cleanup = async () => {
+        if (isCleaningUp)
+            return;
+        isCleaningUp = true;
+        try {
+            for (const cleanup of cleanupFunctions.reverse()) {
+                try {
+                    await Promise.race([
+                        cleanup(),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error("Cleanup timeout")), 2000)),
+                    ]);
+                }
+                catch (error) {
+                    process.stderr.write(chalk.yellow(`Warning during cleanup: ${error}\n`));
+                }
+            }
+        }
+        catch (error) {
+            process.stderr.write(chalk.red(`Error during cleanup: ${error}\n`));
+        }
+    };
     try {
-        const { token, appId, appSlug, workspace, devVersionId } = await boot({ workspaceSlug });
+        const { appId, appSlug, workspace, devVersionId } = await boot({ workspaceSlug });
         const cleanupGraphqlServer = graphqlServer();
         cleanupFunctions.push(cleanupGraphqlServer);
-        const cleanupOnboardingDaemon = onboarding({ token, appId, appSlug, workspace });
+        const cleanupOnboardingDaemon = onboarding({ appId, appSlug, workspace });
         cleanupFunctions.push(cleanupOnboardingDaemon);
-        const [cleanupTs, triggerTs] = validateTypeScript();
+        let haveTsErrors = false;
+        const [cleanupTs, triggerTs] = validateTypeScript(() => {
+            if (haveTsErrors) {
+                process.stdout.write(`${chalk.green("✓")} TypeScript errors fixed\n`);
+                haveTsErrors = false;
+            }
+        }, (errors) => {
+            haveTsErrors = true;
+            errors.forEach(printTsError);
+            notifyTsErrors(errors);
+        });
         cleanupFunctions.push(cleanupTs);
         const cleanupGraphqlCodeGen = graphqlCodeGen(triggerTs);
         cleanupFunctions.push(cleanupGraphqlCodeGen);
-        const cleanupJs = bundleJavaScript((contents) => {
-            upload({ token, contents, devVersionId, appId });
+        let haveJsErrors = false;
+        const cleanupJs = bundleJavaScript(async (contents) => {
+            if (haveJsErrors) {
+                process.stdout.write(`${chalk.green("✓")} JavaScript errors fixed\n`);
+                haveJsErrors = false;
+            }
+            const uploadResult = await upload({ contents, devVersionId, appId });
+            if (isErrored(uploadResult)) {
+                printUploadError(uploadResult.error);
+            }
+        }, async (error) => {
+            haveJsErrors = true;
+            if (error.code === "BUILD_JAVASCRIPT_ERROR") {
+                notifyJsErrors(error);
+                const { errors, warnings } = error;
+                errors.forEach((error) => printJsError(error, "error"));
+                warnings.forEach((warning) => printJsError(warning, "warning"));
+            }
+            else {
+                printBuildContextError(error);
+            }
         });
         cleanupFunctions.push(cleanupJs);
         printMessage("\n👀 Watching for changes...");
-        await new Promise((resolve) => {
-            process.on("SIGINT", async () => {
-                await Promise.all(cleanupFunctions.map(async (cleanup) => cleanup()));
-                resolve(undefined);
-            });
+        process.on("SIGINT", async () => {
+            await cleanup();
+            process.exit(0);
+        });
+        process.on("SIGTERM", async () => {
+            await cleanup();
+            process.exit(0);
+        });
+        process.on("uncaughtException", async (error) => {
+            process.stderr.write(chalk.red(`Uncaught exception: ${error}\n`));
+            await cleanup();
+            process.exit(1);
+        });
+        process.on("unhandledRejection", async (error) => {
+            process.stderr.write(chalk.red(`Unhandled rejection: ${error}\n`));
+            await cleanup();
+            process.exit(1);
+        });
+        await new Promise(() => {
         });
     }
     catch (error) {
-        process.stderr.write(`${chalk.red("✖ " + error)}\n`);
+        process.stderr.write(chalk.red(`✖ ${error}\n`));
+        await cleanup();
         process.exit(1);
     }
 });

package/lib/commands/init/create-project.js

@@ -1,50 +1,68 @@
 import { fileURLToPath } from "url";
 import path from "path";
 import chalk from "chalk";
-import boxen from "boxen";
 import { existsSync } from "fs";
 import { createDirectory } from "../../util/create-directory.js";
 import { canWrite } from "../../util/can-write.js";
 import { copyWithTransform } from "../../util/copy-with-replace.js";
-import { printMessage } from "../../util/print-message.js";
-import { Spinner } from "../../util/spinner.js";
-export async function createProject({ appSlug, language, appInfo, appId, }) {
-    const spinner = new Spinner();
-    if (existsSync(path.join(process.cwd(), appSlug))) {
-        throw new Error(`Directory "${appSlug}" already exists`);
-    }
-    if (!canWrite(process.cwd())) {
-        throw new Error("Write access denied to current directory");
-    }
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const projectDir = createDirectory(appSlug);
-    const templatesDir = path.resolve(__dirname, "../../templates", language);
-    const commonDir = path.resolve(__dirname, "../../templates", "common");
-    spinner.start("Creating project...");
-    try {
+import { spinnerify } from "../../util/spinner.js";
+import { combineAsync, complete, errored, isErrored } from "@attio/fetchable";
+export async function createProject({ appSlug, language, appInfo, }) {
+    return await spinnerify("Creating project...", "Project created", async () => {
+        const cwd = process.cwd();
+        const projectPath = path.join(cwd, appSlug);
+        if (existsSync(projectPath)) {
+            return errored({ code: "DIRECTORY_ALREADY_EXISTS", path: projectPath });
+        }
+        if (!canWrite(cwd)) {
+            return errored({ code: "WRITE_ACCESS_DENIED", directory: cwd });
+        }
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const projectDirResult = await createDirectory(appSlug);
+        if (isErrored(projectDirResult)) {
+            return projectDirResult;
+        }
+        const projectDir = projectDirResult.value;
+        const templatesDir = path.resolve(__dirname, "../../templates", language);
+        const commonDir = path.resolve(__dirname, "../../templates", "common");
         const transform = (contents) => contents
             .replaceAll("title-to-be-replaced", appInfo.title)
-            .replaceAll("id-to-be-replaced", appId)
+            .replaceAll("id-to-be-replaced", appInfo.app_id)
             .replaceAll("slug-to-be-replaced", appSlug);
-        await Promise.all([
+        const results = await combineAsync([
             copyWithTransform(templatesDir, projectDir, transform),
             copyWithTransform(commonDir, projectDir, transform),
         ]);
-        spinner.success("Project created");
-        printMessage("\n" + chalk.green(`SUCCESS!! 🎉 Your app directory has been created.`));
-        printMessage("\nTo get started, run:\n");
-        printMessage(boxen(`cd ${appSlug}\nnpm install\nnpm run dev`, {
-            padding: 1,
-            margin: 1,
-            borderStyle: "round",
-        }) + "\n");
-        printMessage(`(${chalk.yellow("yarn")}, ${chalk.yellow("pnpm")}, and ${chalk.yellow("bun")} also work!)\n`);
-    }
-    catch (error) {
-        spinner.error("Error creating project");
-        throw error;
-    }
-    finally {
-        spinner.stop();
+        if (isErrored(results)) {
+            return results;
+        }
+        return complete(undefined);
+    });
+}
+export function printCreateProjectError(error) {
+    switch (error.code) {
+        case "DIRECTORY_ALREADY_EXISTS":
+            process.stderr.write(chalk.red(`Directory ${error.path} already exists`));
+            break;
+        case "WRITE_ACCESS_DENIED":
+            process.stderr.write(chalk.red(`Write access denied to ${error.directory}`));
+            break;
+        case "FAILED_TO_CREATE_DIRECTORY":
+            process.stderr.write(chalk.red(`Failed to create directory ${error.directory}`));
+            break;
+        case "FAILED_TO_COPY_FILE":
+            process.stderr.write(chalk.red(`Failed to copy file ${error.src} to ${error.dest}`));
+            break;
+        case "FAILED_TO_LIST_FILES":
+            process.stderr.write(chalk.red(`Failed to list files in ${error.directory}`));
+            break;
+        case "FAILED_TO_READ_FILE":
+            process.stderr.write(chalk.red(`Failed to read file ${error.path}`));
+            break;
+        case "FAILED_TO_WRITE_FILE":
+            process.stderr.write(chalk.red(`Failed to write file ${error.path}`));
+            break;
+        default:
+            return error;
     }
 }

package/lib/commands/init.js

@@ -1,37 +1,58 @@
 import { Argument, Command, Option } from "commander";
 import { z } from "zod";
 import chalk from "chalk";
-import { boot } from "./init/boot.js";
-import { createProject } from "./init/create-project.js";
+import { createProject, printCreateProjectError } from "./init/create-project.js";
 import { askLanguage } from "./init/ask-language.js";
 import { printLogo } from "../util/print-logo.js";
+import { getAppInfo } from "../spinners/get-app-info.spinner.js";
+import { printFetcherError } from "../api/fetcher.js";
+import { isErrored } from "@attio/fetchable";
+import boxen from "boxen";
 export const argsSchema = z.string();
 export const optionsSchema = z.object({
     language: z.enum(["javascript", "typescript"]).optional(),
-    workspace: z.string().optional(),
 });
 export const init = new Command("init")
     .description("Initialize a new Attio app")
     .addArgument(new Argument("<app-slug>", "The app slug, chosen in the developer dashboard"))
     .addOption(new Option("--language <language>", "Language").choices(["javascript", "typescript"]))
-    .addOption(new Option("--workspace <slug>", "The slug of the workspace to use"))
     .action(async (unparsedArgs, unparsedOptions) => {
     try {
         printLogo();
         const appSlug = argsSchema.parse(unparsedArgs);
-        const { language: cliLanguage, workspace: workspaceSlug } = optionsSchema.parse(unparsedOptions);
-        const { appId, appInfo } = await boot({ workspaceSlug, appSlug });
+        const { language: cliLanguage } = optionsSchema.parse(unparsedOptions);
+        const appInfoResult = await getAppInfo(appSlug);
+        if (isErrored(appInfoResult)) {
+            printFetcherError("Failed to fetch app info", appInfoResult.error.fetcherError);
+            process.exit(1);
+        }
+        const appInfo = appInfoResult.value;
         const language = cliLanguage ?? (await askLanguage());
-        await createProject({
+        const result = await createProject({
             appSlug,
             language,
             appInfo,
-            appId,
         });
+        if (isErrored(result)) {
+            printCreateProjectError(result.error);
+            process.exit(1);
+        }
+        process.stdout.write(`${chalk.green(`SUCCESS!! 🎉 Your app directory has been created.`)}
+
+To get started, run:
+
+${boxen(`cd ${appSlug}\nnpm install\nnpm run dev`, {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+        })}
+
+(${chalk.yellow("yarn")}, ${chalk.yellow("pnpm")}, and ${chalk.yellow("bun")} also work!)
+`);
         process.exit(0);
     }
     catch (error) {
-        process.stderr.write(`${chalk.red("✖ " + error)}\n`);
+        process.stderr.write(chalk.red("✖ " + String(error)) + "\n");
         process.exit(1);
     }
 });

package/lib/commands/login.js

@@ -1,13 +1,9 @@
 import { Command } from "commander";
-import { auth as authApi } from "../api/auth.js";
-export const login = new Command("login").description("Authenticate with Attio").action(() => {
-    authApi()
-        .then((token) => {
-        process.stdout.write("🔓 Successfully authenticated.\n");
-        process.exit(0);
-    })
-        .catch((error) => {
-        process.stderr.write(`❌ Authentication failed\n\n${error}\n`);
-        process.exit(1);
-    });
+import { auth } from "../auth/auth.js";
+export const login = new Command("login")
+    .description("Authenticate with Attio")
+    .action(async () => {
+    await auth();
+    process.stdout.write("🔓 Successfully authenticated.\n");
+    process.exit(0);
 });

package/lib/commands/logout.js

@@ -1,13 +1,7 @@
 import { Command } from "commander";
-import { deleteAuthToken } from "../api/keychain.js";
-export const logout = new Command("logout").description("Log out from Attio").action(() => {
-    deleteAuthToken()
-        .then(() => {
-        process.stdout.write("🔒 Successfully logged out.\n");
-        process.exit(0);
-    })
-        .catch((error) => {
-        process.stderr.write(`❌ Logout failed\n\n${error}\n`);
-        process.exit(1);
-    });
+import { deleteAuthToken } from "../auth/keychain.js";
+export const logout = new Command("logout").description("Log out from Attio").action(async () => {
+    await deleteAuthToken();
+    process.stdout.write("🔒 Successfully logged out.\n");
+    process.exit(0);
 });

package/lib/commands/version/create/bundle-javascript.js

@@ -0,0 +1,28 @@
+import { complete, isErrored, errored, combineAsync } from "@attio/fetchable";
+import { prepareBuildContexts, } from "../../dev/prepare-build-contexts.js";
+export async function bundleJavaScript() {
+    const buildContextsResult = await prepareBuildContexts("in-memory");
+    if (isErrored(buildContextsResult)) {
+        return errored({
+            code: "ERROR_PREPARING_BUILD_CONTEXT",
+            buildContextError: buildContextsResult.error,
+        });
+    }
+    const buildContexts = buildContextsResult.value;
+    const results = await combineAsync(buildContexts.map(async (context) => await context.rebuild()));
+    if (isErrored(results)) {
+        return errored({
+            code: "ERROR_BUILDING_BUNDLE",
+            error: results.error,
+        });
+    }
+    const bundles = results.value.map((result) => result.outputFiles[0].text);
+    const disposeResults = await combineAsync(buildContexts.map(async (context) => await context.dispose()));
+    if (isErrored(disposeResults)) {
+        return errored({
+            code: "ERROR_DISPOSING_BUILD_CONTEXT",
+            buildContextError: disposeResults.error,
+        });
+    }
+    return complete(bundles);
+}

package/lib/commands/version/create.js

@@ -1,76 +1,101 @@
 import { Command } from "commander";
 import chalk from "chalk";
-import { Spinner } from "../../util/spinner.js";
-import { loadAttioCliPackageJson } from "../../util/load-attio-cli-package-json.js";
-import { createVersion } from "../../api/create-version.js";
-import { fetchVersions } from "../../api/fetch-versions.js";
-import { completeProdBundleUpload } from "../../api/complete-prod-bundle-upload.js";
-import { buildJavaScript } from "../dev/build-javascript.js";
-import { boot } from "./create/boot.js";
+import { spinnerify } from "../../util/spinner.js";
+import { loadAttioCliVersion, printCliVersionError } from "../../util/load-attio-cli-version.js";
+import { uploadBundle } from "../../util/upload-bundle.js";
+import { getVersions } from "../../spinners/get-versions.spinner.js";
+import { getAppInfo } from "../../spinners/get-app-info.spinner.js";
+import { printFetcherError } from "../../api/fetcher.js";
+import { combineAsync, isErrored } from "@attio/fetchable";
+import { getAppSlugFromPackageJson, printPackageJsonError, } from "../../spinners/get-app-slug-from-package-json.js";
+import { bundleJavaScript } from "./create/bundle-javascript.js";
+import { printBuildContextError } from "../dev/prepare-build-contexts.js";
+import { API } from "../../api/api.js";
+import { printJsError } from "../../util/typescript.js";
 export const versionCreate = new Command("create")
     .description("Create a new unpublished version of your Attio app")
     .action(async () => {
-    try {
-        const { token, appInfo } = await boot();
-        const bundlingSpinner = new Spinner();
-        bundlingSpinner.start("Bundling JavaScript...");
-        const [clientBundle, serverBundle] = await new Promise((resolve) => {
-            const cleanup = buildJavaScript((bundles) => {
-                cleanup();
-                bundlingSpinner.success("Bundling complete");
-                resolve(bundles);
-            });
-        });
-        const versions = await fetchVersions({
-            token,
-            appId: appInfo.app_id,
-        });
-        const uploadSpinner = new Spinner();
-        uploadSpinner.start("Uploading...");
-        const packageJson = loadAttioCliPackageJson();
-        if (typeof packageJson === "string")
-            throw packageJson;
-        const major = versions.length === 0 ? 1 : Math.max(...versions.map((version) => version.major), 1);
-        const version = await createVersion({
-            token,
+    const appSlugResult = await getAppSlugFromPackageJson();
+    if (isErrored(appSlugResult)) {
+        printPackageJsonError(appSlugResult.error);
+        process.exit(1);
+    }
+    const appSlug = appSlugResult.value;
+    const appInfoResult = await getAppInfo(appSlug);
+    if (isErrored(appInfoResult)) {
+        printFetcherError("Error loading app info", appInfoResult.error.fetcherError);
+        process.exit(1);
+    }
+    const appInfo = appInfoResult.value;
+    const bundleResult = await spinnerify("Bundling JavaScript...", "Bundling complete", bundleJavaScript);
+    if (isErrored(bundleResult)) {
+        if (bundleResult.error.code === "ERROR_BUILDING_BUNDLE") {
+            const { error } = bundleResult.error;
+            if (error.code === "BUILD_JAVASCRIPT_ERROR") {
+                const { errors, warnings } = error;
+                errors.forEach((error) => printJsError(error, "error"));
+                warnings.forEach((warning) => printJsError(warning, "warning"));
+            }
+            else {
+                printBuildContextError(error);
+            }
+        }
+        else {
+            printBuildContextError(bundleResult.error.buildContextError);
+        }
+        process.exit(1);
+    }
+    const [clientBundle, serverBundle] = bundleResult.value;
+    const versionsResult = await getVersions(appInfo);
+    if (isErrored(versionsResult)) {
+        printFetcherError("Error fetching versions", versionsResult.error.fetcherError);
+        process.exit(1);
+    }
+    const versions = versionsResult.value;
+    const versionResult = await spinnerify("Uploading...", "Upload complete", async () => {
+        const cliVersionResult = loadAttioCliVersion();
+        if (isErrored(cliVersionResult)) {
+            printCliVersionError(cliVersionResult);
+            process.exit(1);
+        }
+        const cliVersion = cliVersionResult.value;
+        const versionResult = await API.createVersion({
             appId: appInfo.app_id,
-            major,
-            cliVersion: packageJson.version,
+            major: versions.length === 0
+                ? 1
+                : Math.max(...versions.map((version) => version.major), 1),
+            cliVersion,
         });
-        await Promise.all([
-            fetch(version.client_bundle_upload_url, {
-                method: "PUT",
-                body: clientBundle,
-                headers: {
-                    "Content-Type": "text/javascript",
-                    "Content-Length": String(Buffer.from(clientBundle).length),
-                },
-            }),
-            fetch(version.server_bundle_upload_url, {
-                method: "PUT",
-                body: serverBundle,
-                headers: {
-                    "Content-Type": "text/javascript",
-                    "Content-Length": String(Buffer.from(serverBundle).length),
-                },
-            }),
+        if (isErrored(versionResult)) {
+            printFetcherError("Error creating version", versionResult.error.fetcherError);
+            process.exit(1);
+        }
+        const { client_bundle_upload_url, server_bundle_upload_url } = versionResult.value;
+        const uploadResult = await combineAsync([
+            uploadBundle(clientBundle, client_bundle_upload_url),
+            uploadBundle(serverBundle, server_bundle_upload_url),
         ]);
-        uploadSpinner.success("Upload complete");
-        const signSpinner = new Spinner();
-        signSpinner.start("Signing bundles...");
-        await completeProdBundleUpload({
-            token,
-            appId: version.app_id,
-            major: version.major,
-            minor: version.minor,
-            bundleId: version.app_prod_version_bundle_id,
-        });
-        signSpinner.success("Bundles signed");
-        process.stdout.write(`\nVersion ${chalk.green(`${version.major}.${version.minor}`)} created!\n\n`);
-        process.exit(0);
+        if (isErrored(uploadResult)) {
+            process.stderr.write(`${chalk.red("✖ ")}Failed to upload bundle to: ${uploadResult.error.uploadUrl}\n`);
+            process.exit(1);
+        }
+        return versionResult;
+    });
+    if (isErrored(versionResult)) {
+        process.stderr.write(`${chalk.red("✖ ")}Failed to create version: ${versionResult.error}\n`);
+        process.exit(1);
     }
-    catch (error) {
-        process.stderr.write(`${chalk.red("✖ " + error)}\n`);
+    const version = versionResult.value;
+    const signingResult = await spinnerify("Signing bundles...", "Bundles signed", async () => await API.completeProdBundleUpload({
+        appId: appInfo.app_id,
+        major: version.major,
+        minor: version.minor,
+        bundleId: version.app_prod_version_bundle_id,
+    }));
+    if (isErrored(signingResult)) {
+        printFetcherError("Error signing bundles", signingResult.error.fetcherError);
         process.exit(1);
     }
+    process.stdout.write(`\nVersion ${chalk.green(`${version.major}.${version.minor}`)} created!\n\n`);
+    process.exit(0);
 });

package/lib/commands/version/list.js

@@ -1,36 +1,64 @@
 import { Command } from "commander";
-import { fetchVersions } from "../../api/fetch-versions.js";
-import Table from "cli-table3";
+import { getAppInfo } from "../../spinners/get-app-info.spinner.js";
+import { getAppSlugFromPackageJson, printPackageJsonError, } from "../../spinners/get-app-slug-from-package-json.js";
+import { getVersions } from "../../spinners/get-versions.spinner.js";
 import chalk from "chalk";
-import formatDate from "date-fns/format/index.js";
-import { ensureAuthed } from "../../api/ensure-authed.js";
-import { getAppSlugFromPackageJson } from "../../api/get-app-slug-from-package-json.js";
-import { getAppInfo } from "../../api/get-app-info.spinner.js";
-export const versionList = new Command("list")
-    .description("List all versions of your Attio app")
-    .alias("ls")
+import Table from "cli-table3";
+import { format as formatDate } from "date-fns";
+import { isErrored } from "@attio/fetchable";
+import { printFetcherError } from "../../api/fetcher.js";
+export const versionList = new Command()
+    .name("list")
+    .description("List all versions of your app")
     .action(async () => {
-    const token = await ensureAuthed();
-    const appSlug = await getAppSlugFromPackageJson();
-    const appInfo = await getAppInfo({ token, appSlug });
-    const versions = await fetchVersions({
-        token,
-        appId: appInfo.app_id,
-    });
+    const appSlugResult = await getAppSlugFromPackageJson();
+    if (isErrored(appSlugResult)) {
+        printPackageJsonError(appSlugResult.error);
+        process.exit(1);
+    }
+    const appSlug = appSlugResult.value;
+    const appInfoResult = await getAppInfo(appSlug);
+    if (isErrored(appInfoResult)) {
+        printFetcherError("Error loading app info", appInfoResult.error.fetcherError);
+        process.exit(1);
+    }
+    const appInfo = appInfoResult.value;
+    const versionsResult = await getVersions(appInfo);
+    if (isErrored(versionsResult)) {
+        printFetcherError("Error loading versions", versionsResult.error.fetcherError);
+        process.exit(1);
+    }
+    const versions = versionsResult.value;
+    if (versions.length === 0) {
+        process.stdout.write("No versions found\n");
+        process.exit(0);
+    }
     const table = new Table({
-        head: ["Version", "Published", "Installations", "Created"].map((h) => chalk.bold(h)),
+        head: ["Version", "Status", "Published", "Installations", "Created"].map((h) => chalk.bold(h)),
         style: {
             head: [],
             border: [],
         },
-        colAligns: ["center", "center", "right", "left"],
+        colAligns: ["center", "left", "center", "right", "left"],
+    });
+    versions.forEach((version) => {
+        const statusColors = {
+            private: chalk.gray,
+            in_review: chalk.yellow,
+            published: chalk.green,
+            rejected: chalk.red,
+        };
+        const formattedStatus = version.publication_status
+            .split("_")
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(" ");
+        table.push([
+            `${version.major}.${version.minor}`,
+            statusColors[version.publication_status](formattedStatus),
+            version.is_published ? "Yes" : "No",
+            version.num_installations.toLocaleString(),
+            formatDate(new Date(version.created_at), "MMM d, yyyy, HH:mm"),
+        ]);
     });
-    table.push(...versions.map((version) => [
-        `${version.major}.${version.minor}`,
-        version.is_published ? "Yes" : "No",
-        version.num_installations.toLocaleString(),
-        formatDate(new Date(version.created_at), "MMMM d, yyyy, HH:mm"),
-    ]));
-    process.stdout.write(table.toString());
-    process.exit(0);
+    process.stdout.write("\n" + table.toString() + "\n");
 });