attio 0.0.1-experimental.20250402 → 0.0.1-experimental.20250403

package/lib/api/api-fetch.js

@@ -0,0 +1,32 @@
+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/auth.js

@@ -4,8 +4,10 @@ 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 } from "./keychain.js";
+import { loadAuthToken, saveAuthToken, deleteAuthToken } from "./keychain.js";
 import { z } from "zod";
+import { whoami } from "./whoami.js";
+import { hardExit } from "./hard-exit.js";
 const CLIENT_ID = "f881c6f1-82d7-48a5-a581-649596167845";
 const tokenResponseSchema = z.object({
     access_token: z.string(),
@@ -20,23 +22,37 @@ async function exchangeCodeForToken(code, codeVerifier, redirectUri) {
     params.append("client_id", CLIENT_ID);
     params.append("redirect_uri", redirectUri);
     params.append("code_verifier", codeVerifier);
-    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();
-        throw new Error(`Token exchange failed: ${response.status} ${errorText}`);
+    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)}`);
     }
-    return tokenResponseSchema.parse(await response.json());
 }
 export async function auth() {
-    const existingToken = await loadAuthToken();
-    if (existingToken) {
-        return existingToken;
+    const existingTokenResult = await loadAuthToken();
+    if (existingTokenResult !== null) {
+        const user = await whoami();
+        if (user !== null) {
+            return existingTokenResult;
+        }
+        await deleteAuthToken();
     }
     const verifier = randomBytes(32);
     const verifierString = verifier.toString("base64url");
@@ -48,70 +64,56 @@ export async function auth() {
     const port = await findAvailablePort(3000, 65000);
     const redirectUri = `http://localhost:${port}`;
     let resolveToken;
-    let rejectToken;
-    const tokenPromise = new Promise((resolve, reject) => {
+    const tokenPromise = new Promise((resolve) => {
         resolveToken = resolve;
-        rejectToken = reject;
     });
     const app = new Hono();
     let serverRef;
     app.get("/", async (c) => {
-        try {
-            const query = c.req.query();
-            const receivedCode = query.authorization_code;
-            const receivedState = query.state;
-            if (receivedState !== state) {
-                throw new Error("State mismatch - possible CSRF attack");
-            }
-            if (!receivedCode) {
-                throw new Error("No authorization code received");
-            }
-            const tokenResponse = await exchangeCodeForToken(receivedCode, verifierString, redirectUri);
-            setTimeout(() => {
-                serverRef.close();
-            }, 1000);
-            resolveToken(tokenResponse.access_token);
-            return c.html(`
-        <html>
-          <body>
-            <script>window.location.href = '${APP}/authorized';</script>
-          </body>
-        </html>
-      `);
+        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");
         }
-        catch (error) {
-            rejectToken(error instanceof Error ? error : new Error(String(error)));
-            return c.html(`
+        const tokenResult = await exchangeCodeForToken(receivedCode, verifierString, redirectUri);
+        setTimeout(() => {
+            serverRef.close();
+        }, 1000);
+        resolveToken(tokenResult.access_token);
+        return c.html(`
         <html>
           <body>
-            <h1>Authentication Failed</h1>
-            <p>Error: ${error instanceof Error ? error.message : String(error)}</p>
-            <p>Please close this window and try again.</p>
+            <script>window.location.href = '${APP}/authorized';</script>
           </body>
         </html>
       `);
-        }
     });
     serverRef = serve({
         fetch: app.fetch,
         port,
     });
-    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());
     try {
-        const accessToken = await tokenPromise;
-        await saveAuthToken(accessToken);
-        return accessToken;
+        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;
     }
-    catch (error) {
+    finally {
         serverRef.close();
-        throw error;
     }
 }

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

@@ -1,21 +1,8 @@
 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 completeBundleUploadSchema = z.object({
     success: z.literal(true),
 });
-export async function completeBundleUpload({ token, appId, devVersionId, bundleId, }) {
-    const response = await fetch(`${API}/apps/${appId}/dev-versions/${devVersionId}/bundles/${bundleId}/complete`, {
-        method: "POST",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    const json = await response.json();
-    try {
-        return completeBundleUploadSchema.parse(json).success;
-    }
-    catch {
-        throw new Error(JSON.stringify(json));
-    }
+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,21 +1,8 @@
 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 completeBundleUploadSchema = z.object({
     success: z.literal(true),
 });
-export async function completeProdBundleUpload({ token, appId, bundleId, major, minor, }) {
-    const response = await fetch(`${API}/apps/${appId}/prod-versions/${major}/${minor}/bundles/${bundleId}/complete`, {
-        method: "POST",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    const json = await response.json();
-    try {
-        return completeBundleUploadSchema.parse(json).success;
-    }
-    catch {
-        throw new Error(JSON.stringify(json));
-    }
+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;
 }

package/lib/api/create-dev-version.js

@@ -1,22 +1,17 @@
 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 createDevVersionSchema = z.object({
     app_id: z.string(),
     app_dev_version_id: z.string(),
 });
-export async function createDevVersion({ token, appId, targetWorkspaceId, environmentVariables, cliVersion, }) {
-    const response = await fetch(`${API}/apps/${appId}/dev-versions`, {
+export async function createDevVersion({ appId, cliVersion, targetWorkspaceId, environmentVariables, }) {
+    return await apiFetch("creating dev version", `apps/${appId}/dev-versions`, {
         method: "POST",
-        headers: makeHeaders(token),
         body: JSON.stringify({
             major: 1,
             target_workspace_id: targetWorkspaceId,
             environment_variables: environmentVariables,
             cli_version: cliVersion,
         }),
-    });
-    await handleError(response);
-    return createDevVersionSchema.parse(await response.json());
+    }, createDevVersionSchema);
 }

package/lib/api/create-version.js

@@ -1,7 +1,5 @@
 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 createVersionSchema = z.object({
     app_id: z.string(),
     major: z.number(),
@@ -10,15 +8,12 @@ const createVersionSchema = z.object({
     client_bundle_upload_url: z.string(),
     server_bundle_upload_url: z.string(),
 });
-export async function createVersion({ token, appId, major, cliVersion, }) {
-    const response = await fetch(`${API}/apps/${appId}/prod-versions`, {
+export async function createVersion({ appId, major, cliVersion, }) {
+    return await apiFetch("creating version", `apps/${appId}/prod-versions`, {
         method: "POST",
-        headers: makeHeaders(token),
         body: JSON.stringify({
             major,
             cli_version: cliVersion,
         }),
-    });
-    await handleError(response);
-    return createVersionSchema.parse(await response.json());
+    }, createVersionSchema);
 }

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

@@ -1,39 +1,32 @@
 import { select } from "@inquirer/prompts";
 import { fetchWorkspaces } from "./fetch-workspaces.js";
 import { APP } from "../env.js";
-import { Spinner } from "../util/spinner.js";
-export async function determineWorkspace({ token, workspaceSlug, }) {
-    const spinner = new Spinner();
-    spinner.start("Loading workspaces...");
-    try {
-        const workspaces = await fetchWorkspaces({ token });
-        spinner.success("Workspaces loaded");
-        const workspace = workspaces.find((workspace) => workspace.slug === workspaceSlug);
-        if (workspace) {
-            spinner.success(`Using workspace: ${workspace.name}`);
-            return workspace;
-        }
-        if (workspaces.length === 0) {
-            throw new Error(`You are not the admin of any workspaces. Either request permission from an existing workspace or create your own.
+import { spinnerify } from "../util/spinner.js";
+import { hardExit } from "./hard-exit.js";
+export async function determineWorkspace(workspaceSlug) {
+    const workspaces = await spinnerify("Loading workspaces...", "Workspaces loaded", fetchWorkspaces);
+    const workspace = workspaces.find((workspace) => workspace.slug === workspaceSlug);
+    if (workspace) {
+        process.stdout.write(`Using workspace: ${workspace.name}`);
+        return workspace;
+    }
+    if (workspaces.length === 0) {
+        hardExit(`You are not the admin of any workspaces. Either request permission from an existing workspace or create your own.
 
 ${APP}/welcome/workspace-details
                     `);
-        }
-        if (workspaces.length === 1) {
-            spinner.success(`Using workspace: ${workspaces[0].name}`);
-            return workspaces[0];
-        }
-        const choice = await select({
-            message: "Choose a workspace",
-            choices: workspaces.map((workspace) => ({
-                name: workspace.name,
-                value: workspace,
-            })),
-        });
-        spinner.success(`Using workspace: ${choice.name}`);
-        return choice;
     }
-    finally {
-        spinner.stop();
+    if (workspaces.length === 1) {
+        process.stdout.write(`Using workspace: ${workspaces[0].name}`);
+        return 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 choice;
 }

package/lib/api/ensure-authed.js

@@ -1,31 +1,14 @@
 import { auth as authApi } from "./auth.js";
 import { deleteAuthToken, loadAuthToken } from "./keychain.js";
-import { whoami } from "./whoami.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();
-            });
-        });
+        await new Promise((resolve) => process.stdin.once("data", resolve));
     }
     return await authApi();
 }
 export async function ensureAuthed() {
-    let token = await loadAuthToken();
-    if (!token) {
-        token = await auth();
-    }
-    try {
-        const user = await whoami({ token });
-        if (!user) {
-            token = await auth();
-        }
-    }
-    catch (error) {
-        return await auth();
-    }
-    return token;
+    const token = await loadAuthToken();
+    return token ?? (await auth());
 }

package/lib/api/fetch-app-info.js

@@ -1,26 +1,20 @@
 import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const isTest = process.env.NODE_ENV === "test";
-const appSchema = z.object({
-    app: z
-        .object({
+import { apiFetch } from "./api-fetch.js";
+const appInfoSchema = z.object({
+    app: z.object({
         app_id: z.string().uuid(),
         title: z.string(),
-    })
-        .nullable(),
+    }),
 });
-export async function fetchAppInfo({ token, appSlug, }) {
-    if (isTest) {
-        return {
-            app_id: "test-id",
-            title: "Test App",
-        };
+const TEST_APP_INFO = appInfoSchema.parse({
+    app: {
+        app_id: "0cbafb09-2ef7-473c-a048-08a5d190a395",
+        title: "Test App",
+    },
+});
+export async function fetchAppInfo(appSlug) {
+    if (process.env.NODE_ENV === "test") {
+        return TEST_APP_INFO.app;
     }
-    const response = await fetch(`${API}/apps/by-slug/${appSlug}`, {
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return appSchema.parse(await response.json()).app;
+    return (await apiFetch("fetching app info", `apps/by-slug/${appSlug}`, { method: "GET" }, appInfoSchema)).app;
 }

package/lib/api/fetch-installation.js

@@ -1,20 +1,9 @@
 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 installationSchema = z.object({
-    workspace_slug: z.string(),
-    workspace_id: z.string().uuid(),
-    app_id: z.string().uuid(),
-    installation_id: z.string().uuid(),
+    app_id: z.string(),
+    workspace_id: z.string(),
 });
-export async function fetchInstallation({ token, appId, workspaceId, }) {
-    const response = await fetch(`${API}/apps/${appId}/workspace/${workspaceId}/dev-installation`, {
-        method: "GET",
-        headers: makeHeaders(token),
-    });
-    if (response.status === 404)
-        return null;
-    await handleError(response);
-    return installationSchema.parse(await response.json());
+export async function fetchInstallation({ appId, workspaceId, }) {
+    return await apiFetch("fetching installation", `apps/${appId}/workspace/${workspaceId}/dev-installation`, { method: "GET" }, installationSchema, "null-on-404");
 }

package/lib/api/fetch-versions.js

@@ -1,25 +1,17 @@
 import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const prodVersionSchema = z.object({
-    app_id: z.string(),
+import { apiFetch } from "./api-fetch.js";
+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(),
-    created_at: z.string(),
-    updated_at: z.string(),
-    accurate_at: z.string(),
+    publication_status: z.enum(["private", "in_review", "published", "rejected"]),
 });
-const fetchVersionsSchema = z.object({
-    app_prod_versions: z.array(prodVersionSchema),
+const versionsSchema = z.object({
+    app_prod_versions: z.array(versionSchema),
 });
-export async function fetchVersions({ token, appId, }) {
-    const response = await fetch(`${API}/apps/${appId}/prod-versions`, {
-        method: "GET",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return fetchVersionsSchema.parse(await response.json()).app_prod_versions;
+export async function fetchVersions(appId) {
+    return (await apiFetch("fetching versions", `apps/${appId}/prod-versions`, { method: "GET" }, versionsSchema)).app_prod_versions;
 }

package/lib/api/fetch-workspaces.js

@@ -1,7 +1,5 @@
 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 isTest = process.env.NODE_ENV === "test";
 const workspaceResponseSchema = z.object({
     workspace_id: z.string().uuid(),
@@ -9,25 +7,19 @@ const workspaceResponseSchema = z.object({
     name: z.string(),
     logo_url: z.string().nullable(),
 });
+const TEST_WORKSPACE = workspaceResponseSchema.parse({
+    workspace_id: "a85e3bcf-a9a2-4df9-9e92-e708bf98d238",
+    slug: "test-slug",
+    name: "Test Workspace",
+    logo_url: null,
+});
 const listDevWorkspacesResponseSchema = z.object({
     workspaces: z.array(workspaceResponseSchema),
     accurate_at: z.string().datetime(),
 });
-export async function fetchWorkspaces({ token }) {
+export async function fetchWorkspaces() {
     if (isTest) {
-        return [
-            {
-                workspace_id: "test-id",
-                slug: "test-slug",
-                name: "Test Workspace",
-                logo_url: null,
-            },
-        ];
+        return [TEST_WORKSPACE];
     }
-    const response = await fetch(`${API}/dev-workspaces`, {
-        method: "GET",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return listDevWorkspacesResponseSchema.parse(await response.json()).workspaces;
+    return (await apiFetch("fetching workspaces", "dev-workspaces", { method: "GET" }, listDevWorkspacesResponseSchema)).workspaces;
 }

package/lib/api/get-app-info.spinner.js

@@ -1,18 +1,7 @@
 import { fetchAppInfo } from "./fetch-app-info.js";
-import { Spinner } from "../util/spinner.js";
-export async function getAppInfo({ token, appSlug, }) {
-    const spinner = new Spinner();
-    spinner.start("Loading app information...");
-    try {
-        const appInfo = await fetchAppInfo({ token, appSlug });
-        if (appInfo === null) {
-            spinner.error("App not found");
-            throw new Error("App not found");
-        }
-        spinner.success(`App found: ${appInfo.title}`);
-        return appInfo;
-    }
-    finally {
-        spinner.stop();
-    }
+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);
+    });
 }

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

@@ -1,6 +1,7 @@
 import { readFileSync } from "fs";
 import { join } from "path";
 import { z } from "zod";
+import { hardExit } from "./hard-exit.js";
 const packageJsonSchema = z.object({
     name: z.string({
         required_error: "No name field found in package.json",
@@ -13,14 +14,14 @@ export async function getAppSlugFromPackageJson() {
         const packageJsonRaw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
         const result = packageJsonSchema.safeParse(packageJsonRaw);
         if (!result.success) {
-            throw new Error(result.error.issues[0]?.message || "Malformed package.json");
+            return hardExit(result.error.issues[0]?.message || "Malformed package.json");
         }
         return result.data.name;
     }
     catch (error) {
         if (error instanceof SyntaxError) {
-            throw new Error("Invalid JSON in package.json");
+            return hardExit("Invalid JSON in package.json");
         }
-        throw new Error("Failed to read package.json");
+        return hardExit("Failed to read package.json");
     }
 }

package/lib/api/get-versions.spinner.js

@@ -1,21 +1,7 @@
 import { fetchVersions } from "./fetch-versions.js";
-import { Spinner } from "../util/spinner.js";
-export async function getVersions({ token, appInfo, }) {
-    const spinner = new Spinner();
-    try {
-        spinner.start("Loading versions...");
-        const versions = await fetchVersions({
-            token,
-            appId: appInfo.app_id,
-        });
-        spinner.success("Versions loaded");
-        return versions;
-    }
-    catch (error) {
-        spinner.error("Error loading versions");
-        throw error;
-    }
-    finally {
-        spinner.stop();
-    }
+import { spinnerify } from "../util/spinner.js";
+export async function getVersions(appInfo) {
+    return await spinnerify("Loading versions...", "Versions loaded", async () => {
+        return await fetchVersions(appInfo.app_id);
+    });
 }

package/lib/api/hard-exit.js

@@ -0,0 +1,6 @@
+import chalk from "chalk";
+import process from "process";
+export function hardExit(message) {
+    process.stderr.write(chalk.red("✖ " + message) + "\n");
+    process.exit(1);
+}