attio 0.0.1-experimental.20250403 → 0.0.1-experimental.20250408

package/lib/commands/version/create.js

@@ -1,51 +1,101 @@
 import { Command } from "commander";
 import chalk from "chalk";
 import { spinnerify } from "../../util/spinner.js";
-import { buildJavaScript } from "../dev/build-javascript.js";
-import { createVersion } from "../../api/create-version.js";
-import { completeProdBundleUpload } from "../../api/complete-prod-bundle-upload.js";
-import { loadAttioCliPackageJson } from "../../util/load-attio-cli-package-json.js";
+import { loadAttioCliVersion, printCliVersionError } from "../../util/load-attio-cli-version.js";
 import { uploadBundle } from "../../util/upload-bundle.js";
-import { getVersions } from "../../api/get-versions.spinner.js";
-import { getAppInfo } from "../../api/get-app-info.spinner.js";
-import { getAppSlugFromPackageJson } from "../../api/get-app-slug-from-package-json.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 () => {
-    const appSlug = await getAppSlugFromPackageJson();
-    const appInfo = await getAppInfo(appSlug);
-    const [clientBundle, serverBundle] = await spinnerify("Bundling JavaScript...", "Bundling complete", async () => {
-        return await new Promise((resolve) => {
-            const cleanup = buildJavaScript((bundles) => {
-                cleanup();
-                resolve(bundles);
-            });
-        });
-    });
-    const versions = await getVersions(appInfo);
-    const version = await spinnerify("Uploading...", "Upload complete", async () => {
-        const packageJson = loadAttioCliPackageJson();
-        const version = await createVersion({
+    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: versions.length === 0
                 ? 1
                 : Math.max(...versions.map((version) => version.major), 1),
-            cliVersion: packageJson.version,
+            cliVersion,
         });
-        await Promise.all([
-            uploadBundle(clientBundle, version.client_bundle_upload_url),
-            uploadBundle(serverBundle, version.server_bundle_upload_url),
+        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),
         ]);
-        return version;
-    });
-    await spinnerify("Signing bundles...", "Bundles signed", async () => {
-        await completeProdBundleUpload({
-            appId: appInfo.app_id,
-            major: version.major,
-            minor: version.minor,
-            bundleId: version.app_prod_version_bundle_id,
-        });
+        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);
+    }
+    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,17 +1,34 @@
 import { Command } from "commander";
-import { getAppInfo } from "../../api/get-app-info.spinner.js";
-import { getAppSlugFromPackageJson } from "../../api/get-app-slug-from-package-json.js";
-import { getVersions } from "../../api/get-versions.spinner.js";
+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 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 appSlug = await getAppSlugFromPackageJson();
-    const appInfo = await getAppInfo(appSlug);
-    const versions = await getVersions(appInfo);
+    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);

package/lib/commands/whoami.js

@@ -1,6 +1,8 @@
 import { Command } from "commander";
-import { whoami as whoamiApi } from "../api/whoami.js";
-import { loadAuthToken } from "../api/keychain.js";
+import { loadAuthToken } from "../auth/keychain.js";
+import { API } from "../api/api.js";
+import { isErrored } from "@attio/fetchable";
+import { printFetcherError } from "../api/fetcher.js";
 export const whoami = new Command()
     .name("whoami")
     .description("Identify the current user")
@@ -10,7 +12,13 @@ export const whoami = new Command()
         process.stdout.write("🔒 Not logged in.\n");
         process.exit(0);
     }
-    const user = await whoamiApi();
-    process.stdout.write(`👤 ${user.name.full} (${user.email_address})\n`);
+    const result = await API.whoami();
+    if (isErrored(result)) {
+        const { fetcherError } = result.error;
+        printFetcherError("Error fetching user", fetcherError);
+        process.exit(1);
+    }
+    const { name, email_address } = result.value;
+    process.stdout.write(`👤 ${name.full} (${email_address})\n`);
     process.exit(0);
 });

package/lib/spinners/determine-workspace.spinner.js

@@ -0,0 +1,58 @@
+import { select } from "@inquirer/prompts";
+import { APP } from "../env.js";
+import { spinnerify } from "../util/spinner.js";
+import { API } from "../api/api.js";
+import { isErrored, complete, errored } from "@attio/fetchable";
+import { printFetcherError } from "../api/fetcher.js";
+export async function determineWorkspace(workspaceSlug) {
+    const workspacesResult = await spinnerify("Loading workspaces...", "Workspaces loaded", async () => await API.fetchWorkspaces());
+    if (isErrored(workspacesResult)) {
+        return workspacesResult;
+    }
+    const workspaces = workspacesResult.value;
+    const workspace = workspaces.find((workspace) => workspace.slug === workspaceSlug);
+    if (workspace) {
+        process.stdout.write(`Using workspace: ${workspace.name}`);
+        return complete(workspace);
+    }
+    if (workspaceSlug) {
+        return errored({ code: "NO_WORKSPACE_FOUND", workspaceSlug });
+    }
+    if (workspaces.length === 0) {
+        return errored({ code: "NO_WORKSPACES_FOUND" });
+    }
+    if (workspaces.length === 1) {
+        process.stdout.write(`Using workspace: ${workspaces[0].name}`);
+        return complete(workspaces[0]);
+    }
+    const choice = await select({
+        message: "Choose a workspace",
+        choices: workspaces.map((workspace) => ({
+            name: workspace.name,
+            value: workspace,
+        })),
+    });
+    process.stdout.write(`Using workspace: ${choice.name}`);
+    return complete(choice);
+}
+export function printDetermineWorkspaceError(error) {
+    switch (error.code) {
+        case "FETCH_WORKSPACES_ERROR":
+            printFetcherError("Error fetching workspaces", error.fetcherError);
+            break;
+        case "NO_WORKSPACE_FOUND":
+            process.stderr.write(`You are not the admin any workspace with the slug "${error.workspaceSlug}". Either request permission from "${error.workspaceSlug}" or create your own.
+
+${APP}/welcome/workspace-details
+                    `);
+            break;
+        case "NO_WORKSPACES_FOUND":
+            process.stderr.write(`You are not the admin of any workspaces. Either request permission from an existing workspace or create your own.
+
+${APP}/welcome/workspace-details
+                    `);
+            break;
+        default:
+            return error;
+    }
+}

package/lib/{api → spinners}/get-app-info.spinner.js

@@ -1,7 +1,7 @@
-import { fetchAppInfo } from "./fetch-app-info.js";
+import { API } from "../api/api.js";
 import { spinnerify } from "../util/spinner.js";
 export async function getAppInfo(appSlug) {
     return await spinnerify("Loading app information...", (app) => `App found: ${app.title}`, async () => {
-        return await fetchAppInfo(appSlug);
+        return await API.fetchAppInfo(appSlug);
     });
 }

package/lib/spinners/get-app-slug-from-package-json.js

@@ -0,0 +1,46 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+import { complete, errored } from "@attio/fetchable";
+import chalk from "chalk";
+const packageJsonSchema = z.object({
+    name: z.string({
+        required_error: "No name field found in package.json",
+        invalid_type_error: `"name" must be a string in package.json`,
+    }),
+});
+export async function getAppSlugFromPackageJson() {
+    try {
+        const packageJsonPath = join(process.cwd(), "package.json");
+        const packageJsonRaw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        const result = packageJsonSchema.safeParse(packageJsonRaw);
+        if (!result.success) {
+            return errored({ code: "MALFORMED_PACKAGE_JSON", error: result.error.issues[0]?.message });
+        }
+        return complete(result.data.name);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            return errored({ code: "INVALID_JSON", error });
+        }
+        return errored({ code: "FILE_SYSTEM_ERROR", error });
+    }
+}
+export function printPackageJsonError({ code, error }) {
+    switch (code) {
+        case "MALFORMED_PACKAGE_JSON":
+            if (error) {
+                process.stderr.write(`${chalk.red("✖ ")}Malformed package.json: ${error}\n`);
+            }
+            else {
+                process.stderr.write(`${chalk.red("✖ ")}Malformed package.json\n`);
+            }
+            break;
+        case "FILE_SYSTEM_ERROR":
+            process.stderr.write(`${chalk.red("✖ ")}Failed to read package.json\n`);
+            break;
+        case "INVALID_JSON":
+            process.stderr.write(`${chalk.red("✖ ")}Invalid JSON in package.json: ${error}\n`);
+            break;
+    }
+}

package/lib/{api → spinners}/get-versions.spinner.js

@@ -1,7 +1,5 @@
-import { fetchVersions } from "./fetch-versions.js";
 import { spinnerify } from "../util/spinner.js";
+import { API } from "../api/api.js";
 export async function getVersions(appInfo) {
-    return await spinnerify("Loading versions...", "Versions loaded", async () => {
-        return await fetchVersions(appInfo.app_id);
-    });
+    return await spinnerify("Loading versions...", "Versions loaded", async () => await API.fetchVersions(appInfo.app_id));
 }

package/lib/util/copy-with-replace.js

@@ -1,34 +1,56 @@
 import { promises as fs } from "fs";
 import path from "path";
-import { hardExit } from "../api/hard-exit.js";
-export const copyWithTransform = async (srcDir, destDir, transform) => {
+import { combineAsync, complete, errored, isErrored } from "@attio/fetchable";
+export async function copyWithTransform(srcDir, destDir, transform) {
     try {
         await fs.mkdir(destDir, { recursive: true });
     }
     catch {
-        hardExit(`Failed to create "${destDir}".`);
+        return errored({ code: "FAILED_TO_CREATE_DIRECTORY", directory: destDir });
     }
-    const entries = await fs.readdir(srcDir, { withFileTypes: true });
-    await Promise.all(entries.map(async (entry) => {
+    let entries;
+    try {
+        entries = await fs.readdir(srcDir, { withFileTypes: true });
+    }
+    catch {
+        return errored({ code: "FAILED_TO_LIST_FILES", directory: srcDir });
+    }
+    const results = await combineAsync(entries.map(async (entry) => {
         const srcPath = path.join(srcDir, entry.name);
         const destPath = path.join(destDir, entry.name);
-        try {
-            if (entry.isDirectory()) {
-                await copyWithTransform(srcPath, destPath, transform);
-            }
-            else if (entry.isFile()) {
-                if (/\.(jpg|jpeg|png|gif|svg|webp|ico)$/i.test(entry.name)) {
+        if (entry.isDirectory()) {
+            return await copyWithTransform(srcPath, destPath, transform);
+        }
+        else if (entry.isFile()) {
+            if (/\.(jpg|jpeg|png|gif|svg|webp|ico)$/i.test(entry.name)) {
+                try {
                     await fs.copyFile(srcPath, destPath);
                 }
-                else {
-                    let content = await fs.readFile(srcPath, "utf8");
-                    content = transform(content);
+                catch {
+                    return errored({ code: "FAILED_TO_COPY_FILE", src: srcPath, dest: destPath });
+                }
+            }
+            else {
+                let content;
+                try {
+                    content = await fs.readFile(srcPath, "utf8");
+                }
+                catch {
+                    return errored({ code: "FAILED_TO_READ_FILE", path: srcPath });
+                }
+                content = transform(content);
+                try {
                     await fs.writeFile(destPath, content, "utf8");
                 }
+                catch {
+                    return errored({ code: "FAILED_TO_WRITE_FILE", path: destPath });
+                }
             }
         }
-        catch {
-            hardExit(`Failed to copy "${srcPath}" to "${destPath}"`);
-        }
+        return complete(undefined);
     }));
-};
+    if (isErrored(results)) {
+        return results;
+    }
+    return complete(undefined);
+}

package/lib/util/create-directory.js

@@ -1,20 +1,27 @@
-import { accessSync, constants, existsSync, mkdirSync } from "fs";
+import { constants, promises as fs } from "fs";
 import { join } from "path";
-import { hardExit } from "../api/hard-exit.js";
-export const createDirectory = (name) => {
+import { complete, errored } from "@attio/fetchable";
+export const createDirectory = async (name) => {
     const currentDir = process.cwd();
     const newPath = join(currentDir, name);
-    if (existsSync(newPath)) {
-        hardExit(`The directory '${name}' already exists.`);
-    }
-    else {
-        try {
-            accessSync(currentDir, constants.W_OK);
-            mkdirSync(newPath);
-            return newPath;
-        }
-        catch {
-            hardExit(`Write access to create the directory "${name}" in the current directory is denied.`);
+    try {
+        if (await fs
+            .access(newPath)
+            .then(() => true)
+            .catch(() => false)) {
+            return errored({
+                code: "DIRECTORY_ALREADY_EXISTS",
+                path: newPath,
+            });
         }
+        await fs.access(currentDir, constants.W_OK);
+        await fs.mkdir(newPath);
+        return complete(newPath);
+    }
+    catch {
+        return errored({
+            code: "WRITE_ACCESS_DENIED",
+            directory: name,
+        });
     }
 };

package/lib/util/find-available-port.js

@@ -1,5 +1,5 @@
 import net from "net";
-import { hardExit } from "../api/hard-exit.js";
+import { hardExit } from "./hard-exit.js";
 async function isPortAvailable(port) {
     return new Promise((resolve) => {
         const portTester = net.createConnection(port, "127.0.0.1");

package/lib/util/load-attio-cli-version.js

@@ -0,0 +1,86 @@
+import { readFileSync } from "fs";
+import { findUpSync } from "find-up-simple";
+import { z } from "zod";
+import { fileURLToPath } from "url";
+import { errored, complete } from "@attio/fetchable";
+import chalk from "chalk";
+const FILE_NAME = "package.json";
+const packageJsonSchema = z.object({
+    name: z.literal("attio"),
+    version: z.string({
+        required_error: "No CLI version found",
+        invalid_type_error: "CLI version must be a string in package.json",
+    }),
+});
+let packageJson;
+export function loadAttioCliVersion() {
+    if (packageJson === undefined) {
+        const cwd = fileURLToPath(import.meta.url);
+        const packageJsonPath = findUpSync(FILE_NAME, { cwd });
+        if (packageJsonPath === undefined) {
+            return errored({
+                code: "UNABLE_TO_FIND_PACKAGE_JSON",
+                directory: cwd,
+            });
+        }
+        let contents;
+        try {
+            contents = readFileSync(packageJsonPath, "utf8");
+        }
+        catch (error) {
+            return errored({
+                code: "UNABLE_TO_READ_PACKAGE_JSON",
+                error,
+            });
+        }
+        let json;
+        try {
+            json = JSON.parse(contents);
+        }
+        catch (error) {
+            return errored({
+                code: "UNABLE_TO_PARSE_PACKAGE_JSON",
+                error,
+            });
+        }
+        const result = packageJsonSchema.safeParse(json);
+        if (!result.success) {
+            return errored({
+                code: "INVALID_PACKAGE_JSON",
+                error: result.error,
+            });
+        }
+        packageJson = result.data;
+    }
+    const { version } = packageJson;
+    if (!version) {
+        return errored({
+            code: "NO_CLI_VERSION_FOUND",
+        });
+    }
+    return complete(version);
+}
+export function printCliVersionError({ error }) {
+    switch (error.code) {
+        case "UNABLE_TO_FIND_PACKAGE_JSON":
+            process.stderr.write(`${chalk.red("✖ ")}Failed to find package.json in ${error.directory}\n`);
+            break;
+        case "UNABLE_TO_READ_PACKAGE_JSON":
+            process.stderr.write(`${chalk.red("✖ ")}Failed to read package.json: ${error.error}\n`);
+            break;
+        case "UNABLE_TO_PARSE_PACKAGE_JSON":
+            process.stderr.write(`${chalk.red("✖ ")}Failed to parse package.json: ${error.error}\n`);
+            break;
+        case "INVALID_PACKAGE_JSON":
+            process.stderr.write(`${chalk.red("✖ ")}Invalid package.json: ${error.error}\n`);
+            break;
+        case "ERROR_LOADING_PACKAGE_JSON":
+            process.stderr.write(`${chalk.red("✖ ")}Error loading package.json: ${error.error}\n`);
+            break;
+        case "NO_CLI_VERSION_FOUND":
+            process.stderr.write(`${chalk.red("✖ ")}No CLI version found in attio's package.json\n`);
+            break;
+        default:
+            return error;
+    }
+}

package/lib/util/spinner.js

@@ -1,4 +1,5 @@
 import chalk from "chalk";
+import { isComplete } from "@attio/fetchable";
 const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 class Spinner {
     frameIndex = 0;
@@ -49,7 +50,9 @@ export async function spinnerify(busyMessage, successMessage, fn) {
     spinner.start(busyMessage);
     try {
         const result = await fn();
-        spinner.success(typeof successMessage === "string" ? successMessage : successMessage(result));
+        if (isComplete(result)) {
+            spinner.success(typeof successMessage === "string" ? successMessage : successMessage(result.value));
+        }
         return result;
     }
     finally {

package/lib/util/upload-bundle.js

@@ -1,4 +1,4 @@
-import { hardExit } from "../api/hard-exit.js";
+import { complete, errored } from "@attio/fetchable";
 export async function uploadBundle(bundle, uploadUrl) {
     try {
         await fetch(uploadUrl, {
@@ -9,8 +9,9 @@ export async function uploadBundle(bundle, uploadUrl) {
                 "Content-Length": String(Buffer.from(bundle).length),
             },
         });
+        return complete(undefined);
     }
     catch (error) {
-        hardExit(`Failed to upload bundle: ${error}`);
+        return errored({ code: "BUNDLE_UPLOAD_ERROR", error, uploadUrl });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20250403",
+  "version": "0.0.1-experimental.20250408",
   "bin": "lib/attio.js",
   "type": "module",
   "files": [
@@ -31,6 +31,7 @@
     }
   },
   "dependencies": {
+    "@attio/fetchable": "0.0.1-experimental.4",
     "@babel/code-frame": "7.24.7",
     "@fal-works/esbuild-plugin-global-externals": "^2.1.2",
     "@graphql-codegen/core": "4.0.2",
@@ -54,6 +55,7 @@
     "keytar": "^7.9.0",
     "node-notifier": "^10.0.1",
     "open": "^7.0.0",
+    "prettier": "^3.4.1",
     "stdin-blocker": "^2.0.0",
     "tiny-cursor": "^2.0.0",
     "tmp-promise": "^3.0.3",

package/lib/api/api-fetch.js

@@ -1,32 +0,0 @@
-import { API } from "../env.js";
-import { ensureAuthed } from "./ensure-authed.js";
-import { hardExit } from "./hard-exit.js";
-export async function apiFetch(verb, path, fetchOptions, schema, allowNull = "error-on-404") {
-    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) {
-            if (response.status === 404 && allowNull === "null-on-404") {
-                return null;
-            }
-            const errorText = await response.text();
-            return hardExit(`Error ${verb}: ${response.status} ${errorText}`);
-        }
-        const data = await response.json();
-        const result = schema.safeParse(data);
-        if (!result.success) {
-            return hardExit(`Invalid response ${verb}: ${result.error.message}`);
-        }
-        return result.data;
-    }
-    catch (error) {
-        return hardExit(`Error ${verb}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/lib/api/complete-bundle-upload.js

@@ -1,8 +0,0 @@
-import { z } from "zod";
-import { apiFetch } from "./api-fetch.js";
-const completeBundleUploadSchema = z.object({
-    success: z.literal(true),
-});
-export async function completeBundleUpload({ appId, devVersionId, bundleId, }) {
-    return (await apiFetch("completing bundle upload", `apps/${appId}/dev-versions/${devVersionId}/bundles/${bundleId}/complete`, { method: "POST" }, completeBundleUploadSchema)).success;
-}

package/lib/api/complete-prod-bundle-upload.js

@@ -1,8 +0,0 @@
-import { z } from "zod";
-import { apiFetch } from "./api-fetch.js";
-const completeBundleUploadSchema = z.object({
-    success: z.literal(true),
-});
-export async function completeProdBundleUpload({ appId, bundleId, major, minor, }) {
-    return (await apiFetch("completing production bundle upload", `apps/${appId}/prod-versions/${major}/${minor}/bundles/${bundleId}/complete`, { method: "POST" }, completeBundleUploadSchema)).success;
-}