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

package/lib/api/api.js

@@ -0,0 +1,98 @@
+import { Fetcher } from "./fetcher.js";
+import { APP } from "../env.js";
+import { isErrored, complete, errored } from "@attio/fetchable";
+import { whoamiSchema, listDevWorkspacesResponseSchema, createVersionSchema, appInfoSchema, completeBundleUploadSchema, startUploadSchema, createDevVersionSchema, installationSchema, versionsSchema, TEST_WORKSPACES, TEST_APP_INFO, } from "./schemas.js";
+class CliApi {
+    _fetcher;
+    constructor() {
+        this._fetcher = new Fetcher();
+    }
+    async whoami() {
+        const result = await this._fetcher.get(`${APP}/api/auth/whoami`, whoamiSchema);
+        if (isErrored(result)) {
+            return errored({ code: "WHOAMI_ERROR", fetcherError: result.error });
+        }
+        return complete(result.value.user);
+    }
+    async fetchWorkspaces() {
+        if (process.env.NODE_ENV === "test") {
+            return complete(TEST_WORKSPACES);
+        }
+        const result = await this._fetcher.get("/dev-workspaces", listDevWorkspacesResponseSchema);
+        if (isErrored(result)) {
+            return errored({ code: "FETCH_WORKSPACES_ERROR", fetcherError: result.error });
+        }
+        return complete(result.value.workspaces);
+    }
+    async createVersion({ appId, major, cliVersion, }) {
+        const result = await this._fetcher.post(`/apps/${appId}/prod-versions`, {
+            major,
+            cli_version: cliVersion,
+        }, createVersionSchema);
+        if (isErrored(result)) {
+            return errored({ code: "CREATE_VERSION_ERROR", fetcherError: result.error });
+        }
+        return result;
+    }
+    async fetchAppInfo(appSlug) {
+        if (process.env.NODE_ENV === "test") {
+            return complete(TEST_APP_INFO.app);
+        }
+        const result = await this._fetcher.get(`/apps/by-slug/${appSlug}`, appInfoSchema);
+        if (isErrored(result)) {
+            return errored({ code: "FETCH_APP_INFO_ERROR", fetcherError: result.error });
+        }
+        return complete(result.value.app);
+    }
+    async completeBundleUpload({ appId, devVersionId, bundleId, }) {
+        const result = await this._fetcher.post(`/apps/${appId}/dev-versions/${devVersionId}/bundles/${bundleId}/complete`, {}, completeBundleUploadSchema);
+        if (isErrored(result)) {
+            return errored({ code: "COMPLETE_BUNDLE_UPLOAD_ERROR", fetcherError: result.error });
+        }
+        return complete(undefined);
+    }
+    async completeProdBundleUpload({ appId, bundleId, major, minor, }) {
+        const result = await this._fetcher.post(`/apps/${appId}/prod-versions/${major}/${minor}/bundles/${bundleId}/complete`, {}, completeBundleUploadSchema);
+        if (isErrored(result)) {
+            return errored({ code: "COMPLETE_PROD_BUNDLE_UPLOAD_ERROR", fetcherError: result.error });
+        }
+        return complete(undefined);
+    }
+    async startUpload({ appId, devVersionId, }) {
+        const result = await this._fetcher.post(`/apps/${appId}/dev-versions/${devVersionId}/bundles`, {}, startUploadSchema);
+        if (isErrored(result)) {
+            return errored({ code: "START_UPLOAD_ERROR", fetcherError: result.error });
+        }
+        return result;
+    }
+    async createDevVersion({ appId, cliVersion, targetWorkspaceId, environmentVariables, }) {
+        const result = await this._fetcher.post(`/apps/${appId}/dev-versions`, {
+            major: 1,
+            target_workspace_id: targetWorkspaceId,
+            environment_variables: environmentVariables,
+            cli_version: cliVersion,
+        }, createDevVersionSchema);
+        if (isErrored(result)) {
+            return errored({ code: "CREATE_DEV_VERSION_ERROR", fetcherError: result.error });
+        }
+        return result;
+    }
+    async fetchInstallation({ appId, workspaceId, }) {
+        const result = await this._fetcher.get(`/apps/${appId}/workspace/${workspaceId}/dev-installation`, installationSchema);
+        if (isErrored(result)) {
+            if (result.error.code === "HTTP_ERROR" && result.error.status === 404) {
+                return complete(null);
+            }
+            return errored({ code: "FETCH_INSTALLATION_ERROR", fetcherError: result.error });
+        }
+        return result;
+    }
+    async fetchVersions(appId) {
+        const result = await this._fetcher.get(`/apps/${appId}/prod-versions`, versionsSchema);
+        if (isErrored(result)) {
+            return errored({ code: "FETCH_VERSIONS_ERROR", fetcherError: result.error });
+        }
+        return complete(result.value.app_prod_versions);
+    }
+}
+export const API = new CliApi();

package/lib/api/fetcher.js

@@ -0,0 +1,65 @@
+import { complete, errored } from "@attio/fetchable";
+import { API } from "../env.js";
+import { ensureAuthed } from "../auth/ensure-authed.js";
+import chalk from "chalk";
+export class Fetcher {
+    async _fetch(path, fetchOptions, schema) {
+        const token = await ensureAuthed();
+        try {
+            const response = await fetch(path.startsWith("https") ? path : `${API}${path}`, {
+                ...fetchOptions,
+                headers: {
+                    "x-attio-platform": "developer-cli",
+                    "Authorization": `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return errored({
+                    code: "HTTP_ERROR",
+                    status: response.status,
+                    message: errorText,
+                });
+            }
+            const data = await response.json();
+            const result = schema.safeParse(data);
+            if (!result.success) {
+                return errored({
+                    code: "INVALID_RESPONSE",
+                    message: result.error.message,
+                });
+            }
+            return complete(result.data);
+        }
+        catch (error) {
+            return errored({
+                code: "NETWORK_ERROR",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async get(path, schema) {
+        return this._fetch(path, { method: "GET" }, schema);
+    }
+    async post(path, body, schema) {
+        return this._fetch(path, {
+            method: "POST",
+            body: JSON.stringify(body),
+        }, schema);
+    }
+}
+export function printFetcherError(message, error) {
+    process.stderr.write(`${chalk.red("✖ ")}${message}\n`);
+    switch (error.code) {
+        case "HTTP_ERROR":
+            process.stderr.write(`HTTP Error (${error.status}): ${error.message}\n`);
+            break;
+        case "INVALID_RESPONSE":
+            process.stderr.write(`Invalid response: ${error.message}\n`);
+            break;
+        case "NETWORK_ERROR":
+            process.stderr.write(`Network error: ${error.message}\n`);
+            break;
+    }
+}

package/lib/api/schemas.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export const whoamiSchema = z.object({
+    user: z.object({
+        id: z.string(),
+        email_address: z.string(),
+        name: z.object({
+            full: z.string(),
+        }),
+    }),
+});
+export const workspaceResponseSchema = z.object({
+    workspace_id: z.string().uuid(),
+    slug: z.string(),
+    name: z.string(),
+    logo_url: z.string().nullable(),
+});
+export const TEST_WORKSPACES = [
+    workspaceResponseSchema.parse({
+        workspace_id: "a85e3bcf-a9a2-4df9-9e92-e708bf98d238",
+        slug: "test-slug",
+        name: "Test Workspace",
+        logo_url: null,
+    }),
+];
+export const listDevWorkspacesResponseSchema = z.object({
+    workspaces: z.array(workspaceResponseSchema),
+});
+export const createVersionSchema = z.object({
+    app_id: z.string().uuid(),
+    major: z.number(),
+    minor: z.number(),
+    app_prod_version_bundle_id: z.string(),
+    client_bundle_upload_url: z.string(),
+    server_bundle_upload_url: z.string(),
+});
+export const appInfoSchema = z.object({
+    app: z.object({
+        app_id: z.string().uuid(),
+        title: z.string(),
+    }),
+});
+export const TEST_APP_INFO = appInfoSchema.parse({
+    app: {
+        app_id: "0cbafb09-2ef7-473c-a048-08a5d190a395",
+        title: "Test App",
+    },
+});
+export const completeBundleUploadSchema = z.object({
+    success: z.literal(true),
+});
+export const startUploadSchema = z.object({
+    app_dev_version_id: z.string().uuid(),
+    app_dev_version_bundle_id: z.string().uuid(),
+    client_bundle_upload_url: z.string().url(),
+    server_bundle_upload_url: z.string().url(),
+});
+export const createDevVersionSchema = z.object({
+    app_id: z.string().uuid(),
+    app_dev_version_id: z.string(),
+});
+export const installationSchema = z.object({
+    app_id: z.string().uuid(),
+    workspace_id: z.string(),
+});
+export const versionSchema = z.object({
+    major: z.number(),
+    minor: z.number(),
+    created_at: z.string(),
+    released_at: z.string().nullable().optional(),
+    is_published: z.boolean(),
+    num_installations: z.number(),
+    publication_status: z.enum(["private", "in_review", "published", "rejected"]),
+});
+export const versionsSchema = z.object({
+    app_prod_versions: z.array(versionSchema),
+});

package/lib/auth/auth.js

@@ -0,0 +1,121 @@
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { randomBytes, createHash } from "crypto";
+import open from "open";
+import { APP } from "../env.js";
+import { findAvailablePort } from "../util/find-available-port.js";
+import { loadAuthToken, saveAuthToken, deleteAuthToken } from "./keychain.js";
+import { z } from "zod";
+import { hardExit } from "../util/hard-exit.js";
+import { API } from "../api/api.js";
+import { isComplete } from "@attio/fetchable";
+const CLIENT_ID = "f881c6f1-82d7-48a5-a581-649596167845";
+const tokenResponseSchema = z.object({
+    access_token: z.string(),
+    token_type: z.string(),
+    expires_in: z.number(),
+});
+async function exchangeCodeForToken(code, codeVerifier, redirectUri) {
+    const tokenUrl = `${APP}/oidc/token`;
+    const params = new URLSearchParams();
+    params.append("grant_type", "authorization_code");
+    params.append("code", code);
+    params.append("client_id", CLIENT_ID);
+    params.append("redirect_uri", redirectUri);
+    params.append("code_verifier", codeVerifier);
+    try {
+        const response = await fetch(tokenUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            return hardExit(`Failed to exchange code for token: ${errorText} (status: ${response.status})`);
+        }
+        const data = await response.json();
+        const result = tokenResponseSchema.safeParse(data);
+        if (!result.success) {
+            return hardExit("Invalid token response");
+        }
+        return result.data;
+    }
+    catch (error) {
+        return hardExit(`Failed to exchange code for token: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function auth() {
+    const existingTokenResult = await loadAuthToken();
+    if (existingTokenResult !== null) {
+        const userResult = await API.whoami();
+        const user = isComplete(userResult) ? userResult.value : null;
+        if (user !== null) {
+            return existingTokenResult;
+        }
+        await deleteAuthToken();
+    }
+    const verifier = randomBytes(32);
+    const verifierString = verifier.toString("base64url");
+    const hash = createHash("sha256");
+    hash.update(verifier);
+    const challenge = hash.digest();
+    const challengeString = challenge.toString("base64url");
+    const state = randomBytes(32).toString("base64url");
+    const port = await findAvailablePort(3000, 65000);
+    const redirectUri = `http://localhost:${port}`;
+    let resolveToken;
+    const tokenPromise = new Promise((resolve) => {
+        resolveToken = resolve;
+    });
+    const app = new Hono();
+    let serverRef;
+    app.get("/", async (c) => {
+        const query = c.req.query();
+        const receivedCode = query.authorization_code;
+        const receivedState = query.state;
+        if (receivedState !== state) {
+            hardExit("State mismatch - possible CSRF attack");
+        }
+        if (!receivedCode) {
+            hardExit("No authorization code received");
+        }
+        const tokenResult = await exchangeCodeForToken(receivedCode, verifierString, redirectUri);
+        setTimeout(() => {
+            serverRef.close();
+        }, 1000);
+        resolveToken(tokenResult.access_token);
+        return c.html(`
+        <html>
+          <body>
+            <script>window.location.href = '${APP}/authorized';</script>
+          </body>
+        </html>
+      `);
+    });
+    serverRef = serve({
+        fetch: app.fetch,
+        port,
+    });
+    try {
+        const authUrl = new URL(`${APP}/oidc/authorize`);
+        authUrl.searchParams.append("scope", "openid");
+        authUrl.searchParams.append("response_type", "code");
+        authUrl.searchParams.append("client_id", CLIENT_ID);
+        authUrl.searchParams.append("redirect_uri", redirectUri);
+        authUrl.searchParams.append("state", state);
+        authUrl.searchParams.append("code_challenge", challengeString);
+        authUrl.searchParams.append("code_challenge_method", "S256");
+        await open(authUrl.toString());
+        const token = await tokenPromise;
+        if (token) {
+            process.stdout.write("🔑 Saving new token to keychain\n");
+            await saveAuthToken(token);
+        }
+        return token;
+    }
+    finally {
+        serverRef.close();
+    }
+}

package/lib/auth/ensure-authed.js

@@ -0,0 +1,14 @@
+import { auth as authApi } from "./auth.js";
+import { deleteAuthToken, loadAuthToken } from "./keychain.js";
+async function auth() {
+    await deleteAuthToken();
+    if (process.env.NODE_ENV !== "test") {
+        process.stdout.write("You need to log in with Attio. Press Enter to continue...\n\n");
+        await new Promise((resolve) => process.stdin.once("data", resolve));
+    }
+    return await authApi();
+}
+export async function ensureAuthed() {
+    const token = await loadAuthToken();
+    return token ?? (await auth());
+}

package/lib/auth/keychain.js

@@ -0,0 +1,52 @@
+import { hardExit } from "../util/hard-exit.js";
+const TEST_TOKEN = "TEST";
+let keytar = null;
+if (process.env.NODE_ENV !== "test") {
+    try {
+        keytar = (await import("keytar")).default;
+    }
+    catch (e) {
+        console.warn("Keychain functionality not available");
+    }
+}
+const SERVICE_NAME = "attio-cli";
+const ACCOUNT_NAME = "developer";
+export async function saveAuthToken(token) {
+    if (!keytar) {
+        return hardExit("Keychain functionality not available");
+    }
+    try {
+        await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, token);
+    }
+    catch (error) {
+        return hardExit(error instanceof Error ? error.message : "Failed to save token to keychain");
+    }
+}
+export async function loadAuthToken() {
+    if (process.env.NODE_ENV === "test") {
+        return TEST_TOKEN;
+    }
+    if (!keytar) {
+        return hardExit("Keychain functionality not available");
+    }
+    try {
+        return await keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
+    }
+    catch (error) {
+        return hardExit(error instanceof Error ? error.message : "Failed to load token from keychain");
+    }
+}
+export async function deleteAuthToken() {
+    if (!keytar) {
+        if (process.env.NODE_ENV === "test") {
+            return;
+        }
+        return hardExit("Keychain functionality not available");
+    }
+    try {
+        await keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
+    }
+    catch (error) {
+        return hardExit(error instanceof Error ? error.message : "Failed to delete token from keychain");
+    }
+}

package/lib/build/client/generate-client-entry.js

@@ -1,9 +1,19 @@
 import fs from "fs/promises";
 import path from "path";
-import { findSurfaceExports } from "../../util/find-surface-exports/find-surface-exports.js";
+import { findSurfaceExports, } from "../../util/find-surface-exports/find-surface-exports.js";
+import { errored, complete } from "@attio/fetchable";
 const ASSET_FILE_EXTENSIONS = ["png"];
 export async function generateClientEntry({ srcDirAbsolute, assetsDirAbsolute, }) {
-    const surfaceExports = await findSurfaceExports(srcDirAbsolute);
+    let surfaceExports;
+    try {
+        surfaceExports = await findSurfaceExports(srcDirAbsolute);
+    }
+    catch (error) {
+        return errored({
+            code: "ERROR_FINDING_SURFACE_EXPORTS",
+            error,
+        });
+    }
     let assetFiles;
     try {
         assetFiles = await fs.readdir(assetsDirAbsolute, { recursive: true });
@@ -47,7 +57,7 @@ const assets = [];
 
 registerAssets(assets);
 `;
-    return `
+    return complete(`
 ${importSurfacesJS}
 
 ${importAssetsJS}
@@ -55,5 +65,5 @@ ${importAssetsJS}
 ${registerSurfacesJS}
 
 ${registerAssetsJS}
-`;
+`);
 }

package/lib/build/server/generate-server-entry.js

@@ -1,20 +1,29 @@
 import { glob } from "glob";
 import path from "path";
+import { errored, complete, isErrored, combineAsync } from "@attio/fetchable";
+async function findPaths(dir, pattern) {
+    try {
+        return complete(await glob(`**/*.${pattern}.(js|ts)`, { nodir: true, cwd: dir }));
+    }
+    catch (error) {
+        return errored({
+            code: "ERROR_FINDING_SERVER_FUNCTION_MODULES",
+            dir,
+            pattern,
+            error,
+        });
+    }
+}
 export async function generateServerEntry({ srcDirAbsolute, webhooksDirAbsolute, eventDirAbsolute, log, }) {
-    const [serverFunctionConcretePaths, webhookConcretePaths, eventConcretePaths] = await Promise.all([
-        Promise.all([
-            glob("**/*.server.ts", { nodir: true, cwd: srcDirAbsolute }),
-            glob("**/*.server.js", { nodir: true, cwd: srcDirAbsolute }),
-        ]).then((paths) => paths.flat()),
-        Promise.all([
-            glob("**/*.webhook.ts", { nodir: true, cwd: webhooksDirAbsolute }),
-            glob("**/*.webhook.js", { nodir: true, cwd: webhooksDirAbsolute }),
-        ]).then((paths) => paths.flat()),
-        Promise.all([
-            glob("*.event.ts", { nodir: true, cwd: eventDirAbsolute }),
-            glob("*.event.js", { nodir: true, cwd: eventDirAbsolute }),
-        ]).then((paths) => paths.flat()),
+    const pathsResult = await combineAsync([
+        findPaths(srcDirAbsolute, "server"),
+        findPaths(webhooksDirAbsolute, "webhook"),
+        findPaths(eventDirAbsolute, "event"),
     ]);
+    if (isErrored(pathsResult)) {
+        return pathsResult;
+    }
+    const [serverFunctionConcretePaths, webhookConcretePaths, eventConcretePaths] = pathsResult.value;
     const serverFunctionModules = serverFunctionConcretePaths.map((path) => ({
         path,
         hash: path.replace(/\.(js|ts)$/, ""),
@@ -30,7 +39,7 @@ export async function generateServerEntry({ srcDirAbsolute, webhooksDirAbsolute,
     for (const module of serverFunctionModules) {
         log?.(`🔎 Found server module "${module.path}"`);
     }
-    return `
+    return complete(`
     
         const modules = new Map()
         const webhookModules = new Map()
@@ -118,5 +127,5 @@ export async function generateServerEntry({ srcDirAbsolute, webhooksDirAbsolute,
 
         main()
 
-`;
+`);
 }

package/lib/commands/build/build-javascript.js

@@ -1,24 +1,18 @@
-import { clearTerminal } from "../../util/clear-terminal.js";
-import { prepareBuildContexts } from "../dev/prepare-build-contexts.js";
-import { printJsError } from "../../util/typescript.js";
-import { errorsAndWarningsSchema } from "../../build.js";
+import { prepareBuildContexts, } from "../dev/prepare-build-contexts.js";
+import { combineAsync, complete, isErrored } from "@attio/fetchable";
 export async function buildJavaScript() {
-    let buildContexts;
-    try {
-        buildContexts = await prepareBuildContexts("write-to-disk");
-        await Promise.all(buildContexts.map(async (context) => context.rebuild()));
-        return true;
+    const buildContextsResult = await prepareBuildContexts("write-to-disk");
+    if (isErrored(buildContextsResult)) {
+        return buildContextsResult;
     }
-    catch (error) {
-        const errors = errorsAndWarningsSchema.parse(error);
-        clearTerminal();
-        errors.errors?.forEach((error) => printJsError(error, "error"));
-        errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
-        return false;
+    const buildContexts = buildContextsResult.value;
+    const buildResult = await combineAsync(buildContexts.map(async (context) => context.rebuild()));
+    const disposeResult = await combineAsync(buildContexts.map(async (context) => context.dispose()));
+    if (isErrored(disposeResult)) {
+        return disposeResult;
     }
-    finally {
-        if (buildContexts) {
-            await Promise.all(buildContexts.map(async (context) => context.dispose()));
-        }
+    if (isErrored(buildResult)) {
+        return buildResult;
     }
+    return complete(true);
 }

package/lib/commands/build/validate-typescript.js

@@ -1,30 +1,23 @@
 import path from "path";
-import { getDiagnostics, readConfig, typeScriptErrorSchema, printTsError, } from "../../util/typescript.js";
+import { getDiagnostics, readConfig, typeScriptErrorSchema, } from "../../util/typescript.js";
+import { complete, errored } from "@attio/fetchable";
 export async function validateTypeScript() {
     try {
         const program = await readConfig(path.resolve("tsconfig.json"));
         if (program === "Not a TypeScript project") {
-            return true;
+            return complete(true);
         }
         const errors = await getDiagnostics(program);
         if (errors.length) {
-            errors.forEach(printTsError);
-            return false;
+            return errored({ code: "VALIDATE_TYPE_SCRIPT_ERROR", errors });
         }
-        return true;
+        return complete(true);
     }
     catch (error) {
         if (error instanceof Error) {
             const tsError = typeScriptErrorSchema.parse({ text: error.message });
-            printTsError(tsError);
-            return false;
+            return errored({ code: "VALIDATE_TYPE_SCRIPT_ERROR", errors: [tsError] });
         }
-        if (typeof error === "object" &&
-            error !== null &&
-            "code" in error &&
-            (error.code === "ENOENT" || error.code === "EACCES" || error.code === "EPERM")) {
-            throw error;
-        }
-        return false;
+        return errored({ code: "FILE_SYSTEM_ERROR", error });
     }
 }

package/lib/commands/build.js

@@ -1,36 +1,38 @@
 import { Command } from "commander";
 import { validateTypeScript } from "./build/validate-typescript.js";
 import { buildJavaScript } from "./build/build-javascript.js";
-import { Spinner } from "../util/spinner.js";
+import { spinnerify } from "../util/spinner.js";
+import { isErrored } from "@attio/fetchable";
+import { printJsError, printTsError } from "../util/typescript.js";
+import { printBuildContextError } from "./dev/prepare-build-contexts.js";
 export const build = new Command("build")
     .description("Build your Attio extension locally")
-    .action(async (unparsedOptions) => {
-    const spinner = new Spinner();
-    spinner.start("Validating TypeScript...");
-    try {
-        const tsValid = await validateTypeScript();
-        if (!tsValid) {
-            spinner.error("TypeScript validation failed");
-            process.exit(1);
+    .action(async () => {
+    const tsResult = await spinnerify("Validating TypeScript...", "TypeScript validation passed", validateTypeScript);
+    if (isErrored(tsResult)) {
+        switch (tsResult.error.code) {
+            case "VALIDATE_TYPE_SCRIPT_ERROR":
+                tsResult.error.errors.forEach(printTsError);
+                process.stderr.write("TypeScript validation failed");
+                process.exit(1);
+            case "FILE_SYSTEM_ERROR":
+                process.stderr.write(`TypeScript validation failed due to a file system error: ${tsResult.error.error}`);
+                process.exit(1);
         }
-        spinner.success("TypeScript validation passed");
-    }
-    catch (error) {
-        spinner.error(`TypeScript validation failed: ${error}`);
-        process.exit(1);
     }
-    spinner.start("Building JavaScript...");
-    try {
-        const jsBuilt = await buildJavaScript();
-        if (!jsBuilt) {
-            spinner.error("JavaScript build failed");
+    const jsResult = await spinnerify("Building JavaScript...", "JavaScript build completed successfully", buildJavaScript);
+    if (isErrored(jsResult)) {
+        if (jsResult.error.code === "BUILD_JAVASCRIPT_ERROR") {
+            const { errors, warnings } = jsResult.error;
+            errors.forEach((error) => printJsError(error, "error"));
+            warnings.forEach((warning) => printJsError(warning, "warning"));
+            process.stderr.write("JavaScript build failed");
+            process.exit(1);
+        }
+        else {
+            printBuildContextError(jsResult.error);
+            process.stderr.write("Build context error");
             process.exit(1);
         }
-        spinner.success("Build completed successfully");
-        process.exit(0);
-    }
-    catch (error) {
-        spinner.error(`JavaScript build failed: ${error}`);
-        process.exit(1);
     }
 });