attio 0.0.1-experimental.20250402.1 → 0.0.1-experimental.20250403

package/lib/api/keychain.js

@@ -1,3 +1,5 @@
+import { hardExit } from "./hard-exit.js";
+const TEST_TOKEN = "TEST";
 let keytar = null;
 if (process.env.NODE_ENV !== "test") {
     try {
@@ -11,20 +13,40 @@ const SERVICE_NAME = "attio-cli";
 const ACCOUNT_NAME = "developer";
 export async function saveAuthToken(token) {
     if (!keytar) {
-        return;
+        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");
     }
-    await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, token);
 }
 export async function loadAuthToken() {
+    if (process.env.NODE_ENV === "test") {
+        return TEST_TOKEN;
+    }
     if (!keytar) {
-        return "TEST";
+        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");
     }
-    const token = await keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
-    return token || null;
 }
 export async function deleteAuthToken() {
     if (!keytar) {
-        return true;
+        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");
     }
-    return await keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
 }

package/lib/api/start-upload.js

@@ -1,18 +1,11 @@
 import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
+import { apiFetch } from "./api-fetch.js";
 const startUploadSchema = z.object({
-    app_dev_version_id: z.string(),
-    app_dev_version_bundle_id: z.string(),
-    client_bundle_upload_url: z.string(),
-    server_bundle_upload_url: z.string(),
+    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 async function startUpload({ token, appId, devVersionId, }) {
-    const response = await fetch(`${API}/apps/${appId}/dev-versions/${devVersionId}/bundles`, {
-        method: "POST",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return startUploadSchema.parse(await response.json());
+export async function startUpload({ appId, devVersionId, }) {
+    return await apiFetch("starting upload", `apps/${appId}/dev-versions/${devVersionId}/bundles`, { method: "POST" }, startUploadSchema);
 }

package/lib/api/whoami.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
+import { apiFetch } from "./api-fetch.js";
 import { APP } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
 const whoamiSchema = z.object({
     user: z.object({
         id: z.string(),
@@ -11,11 +10,6 @@ const whoamiSchema = z.object({
         }),
     }),
 });
-export async function whoami({ token }) {
-    const response = await fetch(`${APP}/api/auth/whoami`, {
-        method: "GET",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return whoamiSchema.parse(await response.json()).user;
+export async function whoami() {
+    return (await apiFetch("fetching current user", `${APP}/api/auth/whoami`, { method: "GET" }, whoamiSchema)).user;
 }

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

@@ -1,4 +1,3 @@
-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";
@@ -11,7 +10,6 @@ export async function buildJavaScript() {
     }
     catch (error) {
         const errors = errorsAndWarningsSchema.parse(error);
-        clearTerminal();
         errors.errors?.forEach((error) => printJsError(error, "error"));
         errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
         return false;

package/lib/commands/build.js

@@ -1,36 +1,21 @@
 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 { hardExit } from "../api/hard-exit.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 {
+    await spinnerify("Validating TypeScript...", "TypeScript validation passed", async () => {
         const tsValid = await validateTypeScript();
         if (!tsValid) {
-            spinner.error("TypeScript validation failed");
-            process.exit(1);
+            hardExit("TypeScript validation failed");
         }
-        spinner.success("TypeScript validation passed");
-    }
-    catch (error) {
-        spinner.error(`TypeScript validation failed: ${error}`);
-        process.exit(1);
-    }
-    spinner.start("Building JavaScript...");
-    try {
+    });
+    await spinnerify("Building JavaScript...", "Build completed successfully", async () => {
         const jsBuilt = await buildJavaScript();
         if (!jsBuilt) {
-            spinner.error("JavaScript build failed");
-            process.exit(1);
+            hardExit("JavaScript build failed");
         }
-        spinner.success("Build completed successfully");
-        process.exit(0);
-    }
-    catch (error) {
-        spinner.error(`JavaScript build failed: ${error}`);
-        process.exit(1);
-    }
+    });
 });

package/lib/commands/dev/boot.js

@@ -1,26 +1,22 @@
-import { ensureAuthed } from "../../api/ensure-authed.js";
-import { loadEnv } from "../../util/load-env.js";
 import { getAppSlugFromPackageJson } from "../../api/get-app-slug-from-package-json.js";
 import { loadAttioCliPackageJson } from "../../util/load-attio-cli-package-json.js";
 import { createDevVersion } from "../../api/create-dev-version.js";
 import { determineWorkspace } from "../../api/determine-workspace.spinner.js";
 import { getAppInfo } from "../../api/get-app-info.spinner.js";
+import { loadEnv } from "../../util/load-env.js";
 export async function boot({ workspaceSlug }) {
-    const token = await ensureAuthed();
     const appSlug = await getAppSlugFromPackageJson();
-    const appInfo = await getAppInfo({ token, appSlug });
-    const workspace = await determineWorkspace({ token, workspaceSlug });
+    const appInfo = await getAppInfo(appSlug);
+    const workspace = await determineWorkspace(workspaceSlug);
     const environmentVariables = await loadEnv();
     const packageJson = loadAttioCliPackageJson();
     const devVersion = await createDevVersion({
-        token,
         appId: appInfo.app_id,
+        cliVersion: packageJson.version,
         targetWorkspaceId: workspace.workspace_id,
         environmentVariables,
-        cliVersion: packageJson.version,
     });
     return {
-        token,
         appId: appInfo.app_id,
         appSlug,
         devVersionId: devVersion.app_dev_version_id,

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

@@ -1,6 +1,5 @@
 import chokidar from "chokidar";
 import notifier from "node-notifier";
-import { clearTerminal } from "../../util/clear-terminal.js";
 import { errorsAndWarningsSchema } from "../../build.js";
 import { prepareBuildContexts } from "./prepare-build-contexts.js";
 import { printJsError } from "../../util/typescript.js";
@@ -28,7 +27,6 @@ export function buildJavaScript(onSuccess) {
         }
         catch (error) {
             const errors = errorsAndWarningsSchema.parse(error);
-            clearTerminal();
             errors.errors?.forEach((error) => printJsError(error, "error"));
             errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
             notify(errors);

package/lib/commands/dev/bundle-javascript.js

@@ -1,6 +1,5 @@
 import chokidar from "chokidar";
 import notifier from "node-notifier";
-import { clearTerminal } from "../../util/clear-terminal.js";
 import { errorsAndWarningsSchema } from "../../build.js";
 import { prepareBuildContexts } from "./prepare-build-contexts.js";
 import { printJsError } from "../../util/typescript.js";
@@ -17,22 +16,36 @@ export function bundleJavaScript(onSuccess) {
         cwd: process.cwd(),
     });
     let buildContexts;
+    let isBuilding = false;
+    let buildQueued = false;
+    let isDisposing = false;
     async function handleBuild() {
+        if (isBuilding || isDisposing) {
+            buildQueued = true;
+            return;
+        }
+        isBuilding = true;
         try {
             if (!buildContexts) {
                 buildContexts = await prepareBuildContexts("in-memory");
             }
             const results = await Promise.all(buildContexts.map(async (context) => context.rebuild()));
             const bundles = results.map((result) => result.outputFiles[0].text);
-            onSuccess?.(bundles);
+            await onSuccess?.(bundles);
         }
         catch (error) {
             const errors = errorsAndWarningsSchema.parse(error);
-            clearTerminal();
             errors.errors?.forEach((error) => printJsError(error, "error"));
             errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
             notify(errors);
         }
+        finally {
+            isBuilding = false;
+            if (buildQueued && !isDisposing) {
+                buildQueued = false;
+                handleBuild();
+            }
+        }
     }
     watcher.on("ready", () => {
         handleBuild();
@@ -43,7 +56,31 @@ export function bundleJavaScript(onSuccess) {
         });
     });
     return async () => {
-        await Promise.all(buildContexts?.map(async (context) => context.dispose()) ?? []);
+        isDisposing = true;
+        if (isBuilding) {
+            await new Promise((resolve) => {
+                const checkBuild = setInterval(() => {
+                    if (!isBuilding) {
+                        clearInterval(checkBuild);
+                        resolve(undefined);
+                    }
+                }, 10);
+            });
+        }
         await watcher.close();
+        if (buildContexts) {
+            for (const context of buildContexts) {
+                try {
+                    await Promise.race([
+                        context.dispose(),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error("Context disposal timeout")), 1_000)),
+                    ]);
+                }
+                catch (e) {
+                    process.stderr.write(`Error disposing build context: ${e}\n`);
+                }
+            }
+            buildContexts = undefined;
+        }
     };
 }

package/lib/commands/dev/graphql-code-gen.js

@@ -4,6 +4,7 @@ import { parse } from "graphql";
 import { findNodeModulesPath } from "../../util/find-node-modules-path.js";
 import { generateOperations } from "../../graphql/generate-operations.js";
 import { GraphQLError } from "../../graphql/graphql-error.js";
+import { hardExit } from "../../api/hard-exit.js";
 export function graphqlCodeGen(onSuccess) {
     const watcher = chokidar.watch(["**/*.graphql", "**/*.gql"], {
         ignored: ["**/node_modules/**", "**/dist/**"],
@@ -13,7 +14,7 @@ export function graphqlCodeGen(onSuccess) {
         try {
             const schemaPath = await findNodeModulesPath(["schema.graphql"]);
             if (!schemaPath) {
-                throw new Error("No schema.graphql found in node_modules");
+                hardExit("No schema.graphql found in node_modules");
             }
             const schema = parse(readFileSync(schemaPath, "utf8"));
             await generateOperations(".", schema);
@@ -24,7 +25,7 @@ export function graphqlCodeGen(onSuccess) {
                 process.stderr.write(error.toString());
             }
             else {
-                throw error;
+                hardExit(error instanceof Error ? error.message : "GraphQL code generation failed");
             }
         }
     }

package/lib/commands/dev/onboarding.js

@@ -5,8 +5,8 @@ import { APP } from "../../env.js";
 function prompt() {
     process.stdout.write(`\n\n🚨 IMPORTANT: You will need to install your app in your workspace. Press "i" to open the app settings page, and then click "Install".\n\n`);
 }
-export function onboarding({ token, appId, appSlug, workspace, }) {
-    const haveInstallation = async () => (await fetchInstallation({ token, appId, workspaceId: workspace.workspace_id })) !== null;
+export function onboarding({ appId, appSlug, workspace, }) {
+    const haveInstallation = async () => (await fetchInstallation({ appId, workspaceId: workspace.workspace_id })) !== null;
     const cleanup = listenForKey("i", () => {
         open(`${APP}/${workspace.slug}/settings/apps/${appSlug}`);
     });

package/lib/commands/dev/upload.js

@@ -1,59 +1,27 @@
 import notifier from "node-notifier";
 import { startUpload } from "../../api/start-upload.js";
 import { completeBundleUpload } from "../../api/complete-bundle-upload.js";
-import { Spinner } from "../../util/spinner.js";
-export async function upload({ token, contents, devVersionId, appId, }) {
-    const spinner = new Spinner().start("Uploading...");
-    try {
+import { spinnerify } from "../../util/spinner.js";
+import { uploadBundle } from "../../util/upload-bundle.js";
+export async function upload({ contents, devVersionId, appId, }) {
+    await spinnerify("Uploading...", () => `Upload complete at ${new Date().toLocaleTimeString()}`, async () => {
         const { client_bundle_upload_url, server_bundle_upload_url, app_dev_version_bundle_id: bundleId, } = await startUpload({
-            token,
             appId,
             devVersionId,
         });
         const [clientBundle, serverBundle] = contents;
         await Promise.all([
-            fetch(client_bundle_upload_url, {
-                method: "PUT",
-                body: clientBundle,
-                headers: {
-                    "Content-Type": "text/javascript",
-                    "Content-Length": String(Buffer.from(clientBundle).length),
-                },
-            }),
-            fetch(server_bundle_upload_url, {
-                method: "PUT",
-                body: serverBundle,
-                headers: {
-                    "Content-Type": "text/javascript",
-                    "Content-Length": String(Buffer.from(serverBundle).length),
-                },
-            }),
-        ]).catch((error) => {
-            process.stderr.write(`Upload Error: ${error}`);
-        });
+            uploadBundle(clientBundle, client_bundle_upload_url),
+            uploadBundle(serverBundle, server_bundle_upload_url),
+        ]);
         await completeBundleUpload({
-            token,
             appId,
             devVersionId,
             bundleId,
         });
-        spinner.success(`Upload completed at ${new Date().toLocaleString()}.`);
         notifier.notify({
             title: "Upload Complete",
             message: "New bundle uploaded to Attio",
         });
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            spinner.error(`Upload failed: ${error.message}`);
-            notifier.notify({
-                title: "Upload Failed",
-                message: "Bundle upload to Attio failed",
-            });
-        }
-        throw error;
-    }
-    finally {
-        spinner.stop();
-    }
+    });
 }

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

@@ -2,7 +2,6 @@ import chokidar from "chokidar";
 import notifier from "node-notifier";
 import { getDiagnostics, readConfig, typeScriptErrorSchema, } from "../../util/typescript.js";
 import { printTsError } from "../../util/typescript.js";
-import { clearTerminal } from "../../util/clear-terminal.js";
 import path from "path";
 const notify = (errors) => {
     notifier.notify({
@@ -37,7 +36,6 @@ export function validateTypeScript(onSuccess) {
             }
             const errors = await getDiagnostics(program);
             if (errors.length) {
-                clearTerminal();
                 errors.forEach(printTsError);
                 notify(errors);
             }
@@ -54,7 +52,6 @@ export function validateTypeScript(onSuccess) {
             }
             if (error instanceof Error) {
                 const tsError = typeScriptErrorSchema.parse({ text: error.message });
-                clearTerminal();
                 printTsError(tsError);
                 notify([tsError]);
             }
@@ -63,7 +60,6 @@ export function validateTypeScript(onSuccess) {
     let watcherReady = false;
     watcher.on("ready", () => {
         watcherReady = true;
-        handleValidation();
         watcher.on("all", (event, path) => {
             if (event === "add" || event === "change" || event === "unlink") {
                 handleValidation();

package/lib/commands/dev.js

@@ -14,35 +14,71 @@ export const optionsSchema = z.object({
 });
 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();
         cleanupFunctions.push(cleanupTs);
         const cleanupGraphqlCodeGen = graphqlCodeGen(triggerTs);
         cleanupFunctions.push(cleanupGraphqlCodeGen);
-        const cleanupJs = bundleJavaScript((contents) => {
-            upload({ token, contents, devVersionId, appId });
+        const cleanupJs = bundleJavaScript(async (contents) => {
+            await upload({ contents, devVersionId, appId });
         });
         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

@@ -7,30 +7,28 @@ 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 { hardExit } from "../../api/hard-exit.js";
+export async function createProject({ appSlug, language, appInfo, }) {
+    await spinnerify("Creating project...", "Project created", async () => {
+        if (existsSync(path.join(process.cwd(), appSlug))) {
+            hardExit(`Directory "${appSlug}" already exists`);
+        }
+        if (!canWrite(process.cwd())) {
+            hardExit("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");
         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([
             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`, {
@@ -39,12 +37,5 @@ export async function createProject({ appSlug, language, appInfo, appId, }) {
             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();
-    }
+    });
 }

package/lib/commands/init.js

@@ -1,37 +1,34 @@
 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 { askLanguage } from "./init/ask-language.js";
 import { printLogo } from "../util/print-logo.js";
+import { getAppInfo } from "../api/get-app-info.spinner.js";
 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 appInfo = await getAppInfo(appSlug);
         const language = cliLanguage ?? (await askLanguage());
         await createProject({
             appSlug,
             language,
             appInfo,
-            appId,
         });
         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 "../api/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);
-    });
+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);
 });