attio 0.0.1-experimental.20250402.1 → 0.0.1-experimental.20250407

package/lib/commands/whoami.js

@@ -1,20 +1,24 @@
 import { Command } from "commander";
-import { auth as authApi } from "../api/auth.js";
-import { whoami as whoamiApi } from "../api/whoami.js";
-export const whoami = new Command("whoami")
+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")
     .action(async () => {
-    const token = await authApi();
-    if (!token) {
+    const tokenResult = await loadAuthToken();
+    if (!tokenResult) {
         process.stdout.write("🔒 Not logged in.\n");
         process.exit(0);
     }
-    try {
-        const user = await whoamiApi({ token });
-        process.stdout.write(`👤 ${user.name.full} (${user.email_address})\n`);
-    }
-    catch (error) {
-        process.stderr.write(`❌ User lookup failed\n\n${error}\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/spinners/get-app-info.spinner.js

@@ -0,0 +1,7 @@
+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 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/spinners/get-versions.spinner.js

@@ -0,0 +1,5 @@
+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 () => await API.fetchVersions(appInfo.app_id));
+}

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

@@ -1,33 +1,56 @@
 import { promises as fs } from "fs";
 import path from "path";
-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 {
-        throw new Error(`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 {
-            throw new Error(`Failed to copy "${srcPath}" to "${destPath}"`);
-        }
+        return complete(undefined);
     }));
-};
+    if (isErrored(results)) {
+        return results;
+    }
+    return complete(undefined);
+}

package/lib/util/create-directory.js

@@ -1,19 +1,27 @@
-import { accessSync, constants, existsSync, mkdirSync } from "fs";
+import { constants, promises as fs } from "fs";
 import { join } from "path";
-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)) {
-        throw new Error(`The directory '${name}' already exists.`);
-    }
-    else {
-        try {
-            accessSync(currentDir, constants.W_OK);
-            mkdirSync(newPath);
-            return newPath;
-        }
-        catch {
-            throw new Error(`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,4 +1,5 @@
 import net from "net";
+import { hardExit } from "./hard-exit.js";
 async function isPortAvailable(port) {
     return new Promise((resolve) => {
         const portTester = net.createConnection(port, "127.0.0.1");
@@ -32,5 +33,5 @@ export async function findAvailablePort(startPort, maxAttempts = 100) {
             return port;
         }
     }
-    throw new Error(`Could not find an available port after ${maxAttempts} attempts`);
+    hardExit(`Could not find an available port after ${maxAttempts} attempts`);
 }

package/lib/util/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);
+}

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,6 +1,7 @@
 import chalk from "chalk";
+import { isComplete } from "@attio/fetchable";
 const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-export class Spinner {
+class Spinner {
     frameIndex = 0;
     stopped = false;
     interval = null;
@@ -44,3 +45,17 @@ export class Spinner {
         return this.stop(`${chalk.yellow("⚠")} ${message}`);
     }
 }
+export async function spinnerify(busyMessage, successMessage, fn) {
+    const spinner = new Spinner();
+    spinner.start(busyMessage);
+    try {
+        const result = await fn();
+        if (isComplete(result)) {
+            spinner.success(typeof successMessage === "string" ? successMessage : successMessage(result.value));
+        }
+        return result;
+    }
+    finally {
+        spinner.stop();
+    }
+}

package/lib/util/upload-bundle.js

@@ -0,0 +1,17 @@
+import { complete, errored } from "@attio/fetchable";
+export async function uploadBundle(bundle, uploadUrl) {
+    try {
+        await fetch(uploadUrl, {
+            method: "PUT",
+            body: bundle,
+            headers: {
+                "Content-Type": "text/javascript",
+                "Content-Length": String(Buffer.from(bundle).length),
+            },
+        });
+        return complete(undefined);
+    }
+    catch (error) {
+        return errored({ code: "BUNDLE_UPLOAD_ERROR", error, uploadUrl });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20250402.1",
+  "version": "0.0.1-experimental.20250407",
   "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",

package/lib/api/auth.js

@@ -1,117 +0,0 @@
-import { Hono } from "hono";
-import { serve } from "@hono/node-server";
-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 { z } from "zod";
-const CLIENT_ID = "f881c6f1-82d7-48a5-a581-649596167845";
-const tokenResponseSchema = z.object({
-    access_token: z.string(),
-    token_type: z.string(),
-    expires_in: z.number(),
-});
-async function exchangeCodeForToken(code, codeVerifier, redirectUri) {
-    const tokenUrl = `${APP}/oidc/token`;
-    const params = new URLSearchParams();
-    params.append("grant_type", "authorization_code");
-    params.append("code", code);
-    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}`);
-    }
-    return tokenResponseSchema.parse(await response.json());
-}
-export async function auth() {
-    const existingToken = await loadAuthToken();
-    if (existingToken) {
-        return existingToken;
-    }
-    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 resolveToken;
-    let rejectToken;
-    const tokenPromise = new Promise((resolve, reject) => {
-        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>
-      `);
-        }
-        catch (error) {
-            rejectToken(error instanceof Error ? error : new Error(String(error)));
-            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>
-          </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;
-    }
-    catch (error) {
-        serverRef.close();
-        throw error;
-    }
-}

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

@@ -1,21 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.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));
-    }
-}

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

@@ -1,21 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.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));
-    }
-}

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

@@ -1,22 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.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`, {
-        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());
-}

package/lib/api/create-version.js

@@ -1,24 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const createVersionSchema = z.object({
-    app_id: z.string(),
-    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 async function createVersion({ token, appId, major, cliVersion, }) {
-    const response = await fetch(`${API}/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());
-}