attio 0.0.1-experimental.20251031.1 → 0.0.1-experimental.20251104.2

package/lib/api/fetcher.js

@@ -1,69 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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")}`;

package/lib/auth/auth.js

@@ -1,174 +0,0 @@
-import { createHash, randomBytes } from "crypto";
-import { serve } from "@hono/node-server";
-import { Hono } from "hono";
-import open from "open";
-import { complete, errored, isErrored } from "@attio/fetchable-npm";
-import { api } from "../api/api.js";
-import { APP } from "../env.js";
-import { printFetcherError, printKeychainError } from "../print-errors.js";
-import { findAvailablePort } from "../util/find-available-port.js";
-import { getKeychain } from "./keychain.js";
-const MAX_TIMEOUT = 2_147_483_647;
-class AuthenticatorImpl {
-    clientId = "f881c6f1-82d7-48a5-a581-649596167845";
-    isRefreshingToken = false;
-    refreshTimeout = null;
-    async ensureAuthed() {
-        const existingTokenResult = await getKeychain().load();
-        if (isErrored(existingTokenResult)) {
-            return this.promptToAuthenticate();
-        }
-        const existingToken = existingTokenResult.value;
-        if (existingToken === null || existingToken.expires_at < Date.now()) {
-            return this.promptToAuthenticate();
-        }
-        this.scheduleRefresh(existingToken);
-        return complete(existingToken.access_token);
-    }
-    async promptToAuthenticate() {
-        if (process.env.NODE_ENV !== "test") {
-            process.stdout.write("You need to log in with Attio. Press Enter to continue...\n\n");
-            await new Promise((resolve) => process.stdin.once("data", resolve));
-        }
-        return this.authenticate();
-    }
-    async authenticate() {
-        const existingTokenResult = await getKeychain().load();
-        if (isErrored(existingTokenResult)) {
-            return existingTokenResult;
-        }
-        const existingToken = existingTokenResult.value;
-        if (existingToken !== null && existingToken.expires_at > Date.now()) {
-            return complete(existingToken.access_token);
-        }
-        const verifier = randomBytes(32);
-        const verifierString = verifier.toString("base64url");
-        const hash = createHash("sha256");
-        hash.update(verifier);
-        const challenge = hash.digest();
-        const challengeString = challenge.toString("base64url");
-        const state = randomBytes(32).toString("base64url");
-        const port = await findAvailablePort(3000, 65000);
-        const redirectUri = `http://localhost:${port}`;
-        let resolveAsyncResult;
-        const asyncResult = new Promise((resolve) => {
-            resolveAsyncResult = resolve;
-        });
-        const app = new Hono();
-        let serverRef;
-        app.get("/", async (c) => {
-            const query = c.req.query();
-            const receivedCode = query.authorization_code;
-            const receivedState = query.state;
-            if (receivedState !== state) {
-                resolveAsyncResult(errored({ code: "OAUTH_STATE_MISMATCH" }));
-            }
-            if (!receivedCode) {
-                resolveAsyncResult(errored({ code: "NO_AUTHORIZATION_CODE" }));
-            }
-            const tokenResult = await api.exchangeToken({
-                receivedCode,
-                verifierString,
-                redirectUri,
-                clientId: this.clientId,
-            });
-            setTimeout(() => {
-                serverRef.close();
-                resolveAsyncResult(tokenResult);
-            }, 1_000);
-            return c.html(`
-        <html>
-          <body>
-            <script>window.location.href = '${APP}/authorized';</script>
-          </body>
-        </html>
-      `);
-        });
-        serverRef = serve({
-            fetch: app.fetch,
-            port,
-        });
-        try {
-            const authUrl = new URL(`${APP}/oidc/authorize`);
-            authUrl.searchParams.append("scope", "openid offline_access");
-            authUrl.searchParams.append("response_type", "code");
-            authUrl.searchParams.append("client_id", this.clientId);
-            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 tokenResult = await asyncResult;
-            if (isErrored(tokenResult)) {
-                return tokenResult;
-            }
-            const token = tokenResult.value;
-            process.stdout.write("🔑 Saving new token to keychain\n");
-            const keychainToken = {
-                access_token: token.access_token,
-                refresh_token: token.refresh_token,
-                token_type: token.token_type,
-                expires_at: Date.now() + token.expires_in * 1000,
-            };
-            const saveResult = await getKeychain().save(keychainToken);
-            if (isErrored(saveResult)) {
-                return saveResult;
-            }
-            this.scheduleRefresh(keychainToken);
-            return complete(token.access_token);
-        }
-        finally {
-            serverRef.close();
-        }
-    }
-    scheduleRefresh(token) {
-        if (this.refreshTimeout !== null) {
-            clearTimeout(this.refreshTimeout);
-        }
-        const delay = Math.min(Math.max(0, (token.expires_at - Date.now()) / 10), MAX_TIMEOUT);
-        this.refreshTimeout = setTimeout(async () => {
-            if (this.isRefreshingToken) {
-                return;
-            }
-            this.isRefreshingToken = true;
-            try {
-                await this.refreshToken(token);
-            }
-            finally {
-                this.isRefreshingToken = false;
-                this.refreshTimeout = null;
-            }
-        }, delay);
-    }
-    async refreshToken(token) {
-        const refreshTokenResult = await api.refreshToken({
-            refreshToken: token.refresh_token,
-            clientId: this.clientId,
-        });
-        if (isErrored(refreshTokenResult)) {
-            printFetcherError("Error refreshing token", refreshTokenResult.error);
-            return;
-        }
-        const refreshedToken = refreshTokenResult.value;
-        const keychainToken = {
-            access_token: refreshedToken.access_token,
-            refresh_token: refreshedToken.refresh_token,
-            token_type: refreshedToken.token_type,
-            expires_at: Date.now() + refreshedToken.expires_in * 1000,
-        };
-        const saveResult = await getKeychain().save(keychainToken);
-        if (isErrored(saveResult)) {
-            printKeychainError(saveResult.error);
-            return;
-        }
-        this.scheduleRefresh(keychainToken);
-    }
-    async logout() {
-        if (this.refreshTimeout !== null) {
-            clearTimeout(this.refreshTimeout);
-            this.refreshTimeout = null;
-        }
-        await getKeychain().delete();
-    }
-}
-export const authenticator = new AuthenticatorImpl();

package/lib/auth/keychain.js

@@ -1,108 +0,0 @@
-import { z } from "zod";
-import { complete, errored, isErrored } from "@attio/fetchable-npm";
-const authTokenSchema = z.object({
-    access_token: z.string(),
-    refresh_token: z.string(),
-    token_type: z.literal("Bearer"),
-    expires_at: z.number(),
-});
-class KeytarKeychain {
-    SERVICE_NAME = "attio-cli";
-    ACCOUNT_NAME = "developer";
-    keytarPromise;
-    constructor() {
-        this.keytarPromise = import("keytar").then((module) => module.default);
-    }
-    async save(token) {
-        const keytar = await this.keytarPromise;
-        try {
-            await keytar.setPassword(this.SERVICE_NAME, this.ACCOUNT_NAME, JSON.stringify(token));
-            return complete(undefined);
-        }
-        catch (error) {
-            return errored({
-                code: "SAVE_KEYCHAIN_ERROR",
-                error,
-            });
-        }
-    }
-    async load() {
-        const keytar = await this.keytarPromise;
-        let unparsedToken = null;
-        try {
-            unparsedToken = await keytar.getPassword(this.SERVICE_NAME, this.ACCOUNT_NAME);
-        }
-        catch (error) {
-            return errored({ code: "LOAD_KEYCHAIN_ERROR", error });
-        }
-        if (unparsedToken === null) {
-            return complete(null);
-        }
-        let jsonToken;
-        try {
-            jsonToken = JSON.parse(unparsedToken);
-        }
-        catch {
-            const deleteResult = await this.delete();
-            if (isErrored(deleteResult)) {
-                return errored({ code: "LOAD_KEYCHAIN_ERROR", error: deleteResult.error });
-            }
-            console.debug("Wiped keychain entry due to invalid JSON");
-            return complete(null);
-        }
-        const parsedToken = authTokenSchema.safeParse(jsonToken);
-        if (!parsedToken.success) {
-            const deleteResult = await this.delete();
-            if (isErrored(deleteResult)) {
-                return errored({ code: "LOAD_KEYCHAIN_ERROR", error: deleteResult.error });
-            }
-            console.debug("Wiped keychain entry due to schema mismatch");
-            return complete(null);
-        }
-        if (parsedToken.data.expires_at < Date.now() + 60_000 * 5) {
-            const deleteResult = await this.delete();
-            if (isErrored(deleteResult)) {
-                return errored({ code: "LOAD_KEYCHAIN_ERROR", error: deleteResult.error });
-            }
-            return complete(null);
-        }
-        return complete(parsedToken.data);
-    }
-    async delete() {
-        const keytar = await this.keytarPromise;
-        try {
-            await keytar.deletePassword(this.SERVICE_NAME, this.ACCOUNT_NAME);
-            return complete(undefined);
-        }
-        catch (error) {
-            return errored({
-                code: "DELETE_KEYCHAIN_ERROR",
-                error,
-            });
-        }
-    }
-}
-class TestKeychain {
-    TEST_TOKEN = {
-        access_token: "TEST",
-        refresh_token: "TEST",
-        token_type: "Bearer",
-        expires_at: Number.MAX_SAFE_INTEGER,
-    };
-    async save(_token) {
-        return complete(undefined);
-    }
-    async load() {
-        return complete(this.TEST_TOKEN);
-    }
-    async delete() {
-        return complete(undefined);
-    }
-}
-let keychain = null;
-export const getKeychain = () => {
-    if (keychain === null) {
-        keychain = process.env.NODE_ENV === "test" ? new TestKeychain() : new KeytarKeychain();
-    }
-    return keychain;
-};

package/lib/build/workflow-block-modules.js

@@ -1 +0,0 @@
-export {};

package/lib/commands/init/create-project.js

@@ -1,36 +0,0 @@
-import { existsSync } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { complete, errored, isErrored } from "@attio/fetchable-npm";
-import { canWrite } from "../../util/can-write.js";
-import { copyWithTransform } from "../../util/copy-with-replace.js";
-import { createDirectory } from "../../util/create-directory.js";
-import { spinnerify } from "../../util/spinner.js";
-export async function createProject({ appSlug, appInfo, }) {
-    return await spinnerify("Creating project...", "Project created", async () => {
-        const cwd = process.cwd();
-        const projectPath = path.join(cwd, appSlug);
-        if (existsSync(projectPath)) {
-            return errored({ code: "DIRECTORY_ALREADY_EXISTS", path: projectPath });
-        }
-        if (!canWrite(cwd)) {
-            return errored({ code: "WRITE_ACCESS_DENIED", path: cwd });
-        }
-        const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const projectDirResult = await createDirectory(appSlug);
-        if (isErrored(projectDirResult)) {
-            return projectDirResult;
-        }
-        const projectDir = projectDirResult.value;
-        const templateDir = path.resolve(__dirname, "../../template");
-        const transform = (contents) => contents
-            .replaceAll("title-to-be-replaced", appInfo.title)
-            .replaceAll("id-to-be-replaced", appInfo.app_id)
-            .replaceAll("slug-to-be-replaced", appSlug);
-        const result = await copyWithTransform(templateDir, projectDir, transform);
-        if (isErrored(result)) {
-            return result;
-        }
-        return complete(undefined);
-    });
-}

package/lib/constants/settings-files.js

@@ -1,2 +0,0 @@
-export const APP_SETTINGS_FILENAME = "app.settings.ts";
-export const SETTINGS_TYPES_FILENAME = "settings.d.ts";

package/lib/env.js

@@ -1,5 +0,0 @@
-export const IS_DEV = process.env.NODE_ENV === "development";
-const DOMAIN = `attio.${IS_DEV ? "me" : "com"}`;
-export const API = `https://build.${DOMAIN}/api`;
-export const APP_NO_PROTOCOL = `app.${DOMAIN}`;
-export const APP = `https://${APP_NO_PROTOCOL}`;

package/lib/errors.js

@@ -1 +0,0 @@
-export {};