attio 0.0.1-experimental.20251104.4 → 0.0.1-experimental.20251105.1

package/README.md

@@ -1,3 +1,9 @@
 # Attio App SDK CLI
 
 ## ⚠️ This package is experimental and not yet ready for use. ⚠️
+
+## Usage
+
+```bash
+npx attio
+```

package/lib/api/api.js

@@ -0,0 +1,183 @@
+import { complete, errored, isErrored } from "@attio/fetchable-npm";
+import { APP } from "../env.js";
+import { SDK_VERSION } from "../sdk-version.js";
+import { Fetcher } from "./fetcher.js";
+import { ablyAuthResponseSchema, appInfoSchema, completeBundleUploadSchema, createDevVersionSchema, createVersionSchema, installationSchema, listDevWorkspacesResponseSchema, startUploadSchema, TEST_APP_INFO, TEST_WORKSPACES, tokenResponseSchema, versionsSchema, whoamiSchema, } from "./schemas.js";
+class ApiImpl {
+    _fetcher;
+    constructor() {
+        this._fetcher = new Fetcher();
+    }
+    async whoami() {
+        const result = await this._fetcher.get({
+            path: `${APP}/api/auth/whoami`,
+            schema: whoamiSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "WHOAMI_ERROR", error: 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({
+            path: "/dev-workspaces",
+            schema: listDevWorkspacesResponseSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "FETCH_WORKSPACES_ERROR", error: result.error });
+        }
+        return complete(result.value.workspaces);
+    }
+    async createVersion({ appId, major, cliVersion, }) {
+        const result = await this._fetcher.post({
+            path: `/apps/${appId}/prod-versions`,
+            body: {
+                major,
+                cli_version: cliVersion,
+                sdk_version: SDK_VERSION,
+            },
+            schema: createVersionSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "CREATE_VERSION_ERROR", error: 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({
+            path: `/apps/by-slug/${appSlug}`,
+            schema: appInfoSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "FETCH_APP_INFO_ERROR", error: result.error });
+        }
+        return complete(result.value.app);
+    }
+    async completeBundleUpload({ appId, devVersionId, bundleId, }) {
+        const result = await this._fetcher.post({
+            path: `/apps/${appId}/dev-versions/${devVersionId}/bundles/${bundleId}/complete`,
+            body: {},
+            schema: completeBundleUploadSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "COMPLETE_BUNDLE_UPLOAD_ERROR", error: result.error });
+        }
+        return complete(undefined);
+    }
+    async completeProdBundleUpload({ appId, bundleId, major, minor, }) {
+        const result = await this._fetcher.post({
+            path: `/apps/${appId}/prod-versions/${major}/${minor}/bundles/${bundleId}/complete`,
+            body: {},
+            schema: completeBundleUploadSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "COMPLETE_PROD_BUNDLE_UPLOAD_ERROR", error: result.error });
+        }
+        return complete(undefined);
+    }
+    async startUpload({ appId, devVersionId, }) {
+        const result = await this._fetcher.post({
+            path: `/apps/${appId}/dev-versions/${devVersionId}/bundles`,
+            body: {
+                sdk_version: SDK_VERSION,
+            },
+            schema: startUploadSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "START_UPLOAD_ERROR", error: result.error });
+        }
+        return result;
+    }
+    async createDevVersion({ appId, cliVersion, targetWorkspaceId, environmentVariables, }) {
+        const result = await this._fetcher.post({
+            path: `/apps/${appId}/dev-versions`,
+            body: {
+                major: 1,
+                target_workspace_id: targetWorkspaceId,
+                environment_variables: environmentVariables,
+                cli_version: cliVersion,
+            },
+            schema: createDevVersionSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "CREATE_DEV_VERSION_ERROR", error: result.error });
+        }
+        return result;
+    }
+    async fetchInstallation({ appId, workspaceId, }) {
+        const result = await this._fetcher.get({
+            path: `/apps/${appId}/workspace/${workspaceId}/dev-installation`,
+            schema: installationSchema,
+        });
+        if (isErrored(result)) {
+            if (result.error.code === "HTTP_ERROR" && result.error.status === 404) {
+                return complete(null);
+            }
+            return errored({ code: "FETCH_INSTALLATION_ERROR", error: result.error });
+        }
+        return result;
+    }
+    async fetchVersions(appId) {
+        const result = await this._fetcher.get({
+            path: `/apps/${appId}/prod-versions`,
+            schema: versionsSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "FETCH_VERSIONS_ERROR", error: result.error });
+        }
+        return complete(result.value.app_prod_versions);
+    }
+    async exchangeToken({ receivedCode, verifierString, redirectUri, clientId, }) {
+        const params = new URLSearchParams();
+        params.append("grant_type", "authorization_code");
+        params.append("code", receivedCode);
+        params.append("client_id", clientId);
+        params.append("redirect_uri", redirectUri);
+        params.append("code_verifier", verifierString);
+        const result = await this._fetcher.post({
+            path: `${APP}/oidc/token`,
+            body: params,
+            schema: tokenResponseSchema,
+            authenticated: "Not Authenticated",
+        });
+        if (isErrored(result)) {
+            return errored({ code: "GET_TOKEN_ERROR", error: result.error });
+        }
+        return result;
+    }
+    async refreshToken({ refreshToken, clientId, }) {
+        const params = new URLSearchParams();
+        params.append("grant_type", "refresh_token");
+        params.append("refresh_token", refreshToken);
+        params.append("client_id", clientId);
+        const result = await this._fetcher.post({
+            path: `${APP}/oidc/token`,
+            body: params,
+            schema: tokenResponseSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "REFRESH_TOKEN_ERROR", error: result.error });
+        }
+        return result;
+    }
+    async authenticateAbly(tokenParams) {
+        const result = await this._fetcher.post({
+            path: "/integrations/ably/auth",
+            body: {
+                token_params: tokenParams,
+            },
+            schema: ablyAuthResponseSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "ABLY_AUTHENTICATION_ERROR", error: result.error });
+        }
+        return result;
+    }
+}
+export const api = new ApiImpl();

package/lib/api/fetcher.js

@@ -0,0 +1,69 @@
+import { complete, errored, isErrored } from "@attio/fetchable-npm";
+import { authenticator } from "../auth/auth.js";
+import { API } from "../env.js";
+export class Fetcher {
+    async _fetch({ path, fetchOptions, schema, authenticated, }) {
+        const tokenResult = authenticated === "Authenticated" ? await authenticator.ensureAuthed() : complete(null);
+        if (isErrored(tokenResult)) {
+            return errored({
+                code: "UNAUTHORIZED",
+                error: tokenResult.error,
+            });
+        }
+        const token = tokenResult.value;
+        try {
+            const response = await fetch(path.startsWith("https") ? path : `${API}${path}`, {
+                ...fetchOptions,
+                headers: {
+                    "x-attio-platform": "developer-cli",
+                    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                    "Content-Type": "application/json",
+                    ...fetchOptions.headers,
+                },
+            });
+            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, headers = {}, authenticated = "Authenticated", }) {
+        return this._fetch({ path, fetchOptions: { method: "GET", headers }, schema, authenticated });
+    }
+    async post({ path, body, schema, headers = {}, authenticated = "Authenticated", }) {
+        return this._fetch({
+            path,
+            fetchOptions: {
+                method: "POST",
+                body: body instanceof URLSearchParams ? body.toString() : JSON.stringify(body),
+                headers: {
+                    "Content-Type": body instanceof URLSearchParams
+                        ? "application/x-www-form-urlencoded"
+                        : "application/json",
+                    ...headers,
+                },
+            },
+            schema,
+            authenticated,
+        });
+    }
+}

package/lib/api/schemas.js

@@ -0,0 +1,89 @@
+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),
+});
+export const tokenResponseSchema = z.object({
+    access_token: z.string(),
+    token_type: z.literal("Bearer"),
+    refresh_token: z.string(),
+    expires_in: z.number(),
+});
+export const ablyAuthResponseSchema = z.object({
+    capability: z.string(),
+    clientId: z.string().optional(),
+    expires: z.number(),
+    issued: z.number(),
+    token: z.string(),
+});

package/lib/attio-logo.js

@@ -0,0 +1,24 @@
+export const attioLogo = `
+     ▟██▛╲       
+    ▟██▛  ╲      
+   ▟██▛   ╱      
+  ▟██▛   ╱       
+ ▟██▛   ╱   ▟█▛╲ 
+🬇██▛   ╱   ▟█▛  ╲
+ ▜█▙  ╱   🬇██▙  ╱
+  ▜█▙╱      ▜█▙╱ 
+`;
+export const attioName = `
+
+
+             ▟     ▟   ██
+            ██    ██
+   ▟███▙▟ ████████████ ██  ▟███▙ 
+  ▟█   ██   ██    ██   ██  █   █
+  ██   ██   ██    ██   ██  █   █
+  ▜████▛█   ▜███  ▜███ ██  ▜███▛
+`;
+export const attioLogoAndName = `${attioLogo
+    .split("\n")
+    .map((line, i) => i < attioLogo.split("\n").length - 1 ? `${line}    ${attioName.split("\n")[i] || ""}` : line)
+    .join("\n")}`;