attio 0.0.1-experimental.20250324.1 → 0.0.1-experimental.20250325.1

package/lib/api/fetch-versions.js

@@ -15,22 +15,6 @@ const prodVersionSchema = z.object({
 const fetchVersionsSchema = z.object({
     app_prod_versions: z.array(prodVersionSchema),
 });
-function onlyPublishableVersions(versions) {
-    const publishedVersions = versions.filter((v) => v.is_published);
-    if (publishedVersions.length === 0)
-        return versions.filter((v) => !v.is_published);
-    const highestPublishedVersion = publishedVersions.reduce((highest, current) => {
-        if (current.major > highest.major ||
-            (current.major === highest.major && current.minor > highest.minor)) {
-            return current;
-        }
-        return highest;
-    });
-    return versions.filter((v) => !v.is_published &&
-        (v.major > highestPublishedVersion.major ||
-            (v.major === highestPublishedVersion.major &&
-                v.minor > highestPublishedVersion.minor)));
-}
 export async function fetchVersions({ token, appId, }) {
     const response = await fetch(`${API}/apps/${appId}/prod-versions`, {
         method: "GET",
@@ -39,11 +23,3 @@ export async function fetchVersions({ token, appId, }) {
     await handleError(response);
     return fetchVersionsSchema.parse(await response.json()).app_prod_versions;
 }
-export async function fetchPublishableVersions({ token, devSlug, appId, }) {
-    const versions = await fetchVersions({ token, devSlug, appId });
-    return onlyPublishableVersions(versions);
-}
-export async function fetchUnpublishedVersions({ token, devSlug, appId, }) {
-    const versions = await fetchVersions({ token, devSlug, appId });
-    return versions.filter((v) => !v.is_published);
-}

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

@@ -11,14 +11,14 @@ const appSchema = z.object({
     })
         .nullable(),
 });
-export async function getAppInfo({ token, developerSlug, appSlug, }) {
+export async function getAppInfo({ token, appSlug, }) {
     if (isTest) {
         return {
             app_id: "test-id",
             title: "Test App",
         };
     }
-    const response = await fetch(`${API}/developer-accounts/${developerSlug}/apps/by-slug/${appSlug}`, {
+    const response = await fetch(`${API}/apps/by-slug/${appSlug}`, {
         headers: makeHeaders(token),
     });
     await handleError(response);

package/lib/commands/dev.js

@@ -4,13 +4,19 @@ import { z } from "zod";
 import { devMachine } from "../machines/dev-machine.js";
 export const optionsSchema = z.object({
     dev: z.boolean().default(false),
+    workspace: z.string().optional(),
 });
 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", "The slug of the workspace to use"))
     .action((unparsedOptions) => {
     const options = optionsSchema.parse(unparsedOptions);
-    const actor = createActor(devMachine);
+    const actor = createActor(devMachine, {
+        input: {
+            workspaceSlug: options.workspace,
+        },
+    });
     if (options.dev) {
         actor.subscribe((state) => {
             console.log("state:", state.value);

package/lib/commands/version/list.js

@@ -3,19 +3,18 @@ import { fetchVersions } from "../../api/fetch-versions.js";
 import Table from "cli-table3";
 import chalk from "chalk";
 import formatDate from "date-fns/format/index.js";
-import { loadAppId } from "../../api/load-app-id.js";
-import { loadDevSlug } from "../../api/load-dev-slug.js";
 import { ensureAuthed } from "../../api/ensure-authed.js";
+import { getAppSlugFromPackageJson, fetchAppInfo } from "../../machines/actors.js";
 export const versionList = new Command("list")
     .description("List all versions of your Attio app")
     .alias("ls")
     .action(async () => {
     const token = await ensureAuthed();
-    const [appId, devSlug] = await Promise.all([loadAppId(), loadDevSlug()]);
+    const appSlug = await getAppSlugFromPackageJson();
+    const appInfo = await fetchAppInfo({ token, appSlug });
     const versions = await fetchVersions({
         token,
-        devSlug,
-        appId,
+        appId: appInfo.app_id,
     });
     const table = new Table({
         head: ["Version", "Published", "Installations", "Created"].map((h) => chalk.bold(h)),

package/lib/machines/actions.js

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import { textGradient } from "../util/text-gradient.js";
 import { attioLogoAndName } from "../attio-logo.js";
 export const showError = (_, params) => process.stderr.write(`${chalk.red("✖ " + params.error)}\n`);
+export const showActorError = (_, params) => process.stderr.write(`${chalk.red("✖ " + params.error)}\n`);
 export const printLogo = () => {
     process.stdout.write(`\n${textGradient(attioLogoAndName, "#ff5f6d", "#ffc371")}\n\n`);
 };

package/lib/machines/actors.js

@@ -1,51 +1,75 @@
 import { fetchVersions as fetchVersionsApi } from "../api/fetch-versions.js";
 import { input as inputPrompt, password as passwordPrompt, select as selectPrompt, confirm as confirmPrompt, } from "@inquirer/prompts";
 import { fromCallback, fromPromise } from "xstate";
-import { loadAppConfigFile } from "../util/app-config.js";
-import { loadDeveloperConfig as loadDeveloperConfigFile } from "../util/load-developer-config.js";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
 import Spinner from "tiny-spinner";
+import { getAppInfo } from "../api/get-app-info.js";
 import { ensureAuthed } from "../api/ensure-authed.js";
-export const loadDeveloperConfig = fromCallback(({ sendBack }) => {
-    const load = async () => {
-        const config = await loadDeveloperConfigFile();
-        if (typeof config === "string") {
-            sendBack({ type: "No Developer Config", configError: config });
-            return;
-        }
-        const token = await ensureAuthed();
-        sendBack({
-            type: "Developer Config Loaded",
-            token,
-            slug: config.developer_slug,
-        });
-    };
-    load();
+import { fetchWorkspaces } from "../api/fetch-workspaces.js";
+import { APP } from "../env.js";
+export const authenticate = fromPromise(ensureAuthed);
+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 const loadAppConfig = fromCallback(({ sendBack }) => {
-    const config = loadAppConfigFile();
-    if (typeof config === "string") {
-        sendBack({ type: "Error", error: config });
-        return;
+export const getAppSlugFromPackageJson = async () => {
+    try {
+        const packageJsonPath = join(process.cwd(), "package.json");
+        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 result.data.name;
     }
-    sendBack({ type: "App Config Loaded", config });
-});
-export const fetchVersions = fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, }, }) => {
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error("Invalid JSON in package.json");
+        }
+        throw new Error("Failed to read package.json");
+    }
+};
+export const loadAppSlug = fromPromise(getAppSlugFromPackageJson);
+export const fetchVersions = fromPromise(async ({ input: { token, appInfo } }) => {
     const spinner = new Spinner();
-    spinner.start("Loading versions...");
-    const getVersions = async () => {
+    try {
+        spinner.start("Loading versions...");
         const versions = await fetchVersionsApi({
             token,
-            devSlug,
-            appId: config.id,
+            appId: appInfo.app_id,
         });
         spinner.success("Versions loaded");
-        sendBack({ type: "Versions Fetched", versions });
-    };
-    getVersions().catch((error) => {
+        return versions;
+    }
+    catch (error) {
         spinner.error("Error loading versions");
-        sendBack({ type: "Error", error: error.message });
-    });
+        throw error;
+    }
+    finally {
+        spinner.stop();
+    }
 });
+export async function fetchAppInfo({ token, appSlug, }) {
+    const spinner = new Spinner();
+    spinner.start("Loading app information...");
+    try {
+        const appInfo = await getAppInfo({ 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();
+    }
+}
+export const loadAppInfo = fromPromise(async ({ input: { token, appSlug } }) => await fetchAppInfo({ token, appSlug }));
 export const ask = fromPromise(async ({ input }) => await inputPrompt(input));
 export const askPassword = fromPromise(async ({ input }) => await passwordPrompt(input));
 export const askWithChoices = fromPromise(async ({ input, }) => await selectPrompt(input));
@@ -62,3 +86,39 @@ export const fromCallbackWithErrorHandling = (callback) => fromCallback((...args
         });
     }
 });
+export const determineWorkspace = fromPromise(async ({ input: { 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;
+        }
+        const hasAdmin = workspaces.some((workspace) => workspace.access_level === "admin");
+        if (!hasAdmin) {
+            throw new Error(`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 selectPrompt({
+            message: "Choose a workspace",
+            choices: workspaces.map((workspace) => ({
+                name: workspace.name,
+                value: workspace,
+            })),
+        });
+        spinner.success(`Using workspace: ${choice.name}`);
+        return choice;
+    }
+    finally {
+        spinner.stop();
+    }
+});

package/lib/machines/create-version-machine.js

@@ -1,13 +1,10 @@
-import { assign, setup, fromCallback } from "xstate";
+import { assign, setup, fromPromise } from "xstate";
 import chalk from "chalk";
 import { completeProdBundleUpload } from "../api/complete-prod-bundle-upload.js";
 import { createVersion } from "../api/create-version.js";
-import { emptyConfig } from "../schema.js";
-import { updateAppConfig } from "../util/app-config.js";
-import { askWithTypedChoices, loadAppConfig, loadDeveloperConfig, confirm, fetchVersions, } from "./actors.js";
+import { authenticate, confirm, fetchVersions, loadAppInfo, loadAppSlug } from "./actors.js";
 import { jsMachine } from "./js-machine.js";
-import { printInstallInstructions } from "../util/print-install-instructions.js";
-import { showError, printLogo } from "./actions.js";
+import { printLogo, showActorError } from "./actions.js";
 import Spinner from "tiny-spinner";
 import { loadAttioCliPackageJson } from "../util/load-attio-cli-package-json.js";
 export const connectionTypes = [
@@ -33,38 +30,38 @@ export const createVersionMachine = setup({
     actors: {
         confirm,
         fetchVersions,
-        askForUpgradeType: askWithTypedChoices(),
         javascript: jsMachine,
-        createVersion: fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, upgradeType, }, }) => {
-            const add = async () => {
-                const spinner = new Spinner();
-                spinner.start("Creating version...");
-                try {
-                    const packageJson = loadAttioCliPackageJson();
-                    if (typeof packageJson === "string")
-                        throw packageJson;
-                    const res = await createVersion({
-                        token,
-                        devSlug,
-                        appId: config.id,
-                        major: upgradeType === "initial" ? 1 : config.major,
-                        cliVersion: packageJson.version,
-                    });
-                    spinner.success("Version created");
-                    sendBack({ type: "Version Created", version: res });
-                }
-                catch (error) {
-                    spinner.error("Error creating version");
-                    sendBack({ type: "Error", error: error.message });
-                }
-            };
-            add();
+        createVersion: fromPromise(async ({ input: { token, appInfo, upgradeType, versions } }) => {
+            const spinner = new Spinner();
+            spinner.start("Creating version...");
+            try {
+                const packageJson = loadAttioCliPackageJson();
+                if (typeof packageJson === "string")
+                    throw packageJson;
+                const major = Math.max(...versions.map((version) => version.major), 1);
+                const version = await createVersion({
+                    token,
+                    appId: appInfo.app_id,
+                    major: upgradeType === "initial" ? 1 : major,
+                    cliVersion: packageJson.version,
+                });
+                spinner.success("Version created");
+                return version;
+            }
+            catch (error) {
+                spinner.error("Error creating version");
+                throw error;
+            }
+            finally {
+                spinner.stop();
+            }
         }),
-        loadDeveloperConfig,
-        loadAppConfig,
-        upload: fromCallback(({ sendBack, input: { developer: { token, slug: developerSlug }, jsContents, version: { app_id: appId, client_bundle_upload_url, server_bundle_upload_url, major, minor, app_prod_version_bundle_id: bundleId, }, }, }) => {
+        authenticate,
+        loadAppInfo,
+        loadAppSlug: loadAppSlug,
+        upload: fromPromise(async ({ input: { token, jsContents, version: { app_id: appId, client_bundle_upload_url, server_bundle_upload_url, major, minor, app_prod_version_bundle_id: bundleId, }, }, }) => {
             const uploadSpinner = new Spinner();
-            const upload = async () => {
+            try {
                 uploadSpinner.start("Uploading...");
                 const [clientBundle, serverBundle] = jsContents;
                 await Promise.all([
@@ -85,36 +82,31 @@ export const createVersionMachine = setup({
                         },
                     }),
                 ]);
-                uploadSpinner.success("Uploading complete");
+                uploadSpinner.success("Upload complete");
                 const signSpinner = new Spinner();
                 signSpinner.start("Signing bundles...");
                 await completeProdBundleUpload({
                     token,
-                    developerSlug,
                     appId,
                     major,
                     minor,
                     bundleId,
                 });
                 signSpinner.success("Bundles signed");
-                updateAppConfig((config) => ({
-                    ...config,
-                    major,
-                    minor,
-                }));
                 process.stdout.write(`\nVersion ${chalk.green(`${major}.${minor}`)} created!\n\n`);
-                sendBack({ type: "Upload Complete" });
-            };
-            upload().catch((error) => {
+            }
+            catch (error) {
                 uploadSpinner.error("Upload failed");
-                sendBack({ type: "Error", error: error.message });
-            });
+                throw error;
+            }
+            finally {
+                uploadSpinner.stop();
+            }
         }),
     },
     actions: {
         printLogo,
-        showError,
-        showConfigInstructions: ({ context }) => printInstallInstructions(context.configError),
+        showActorError,
         startBundlingSpinner: () => {
             bundlingSpinner.start("Bundling JavaScript...");
         },
@@ -124,96 +116,71 @@ export const createVersionMachine = setup({
         errorBundlingSpinner: () => {
             bundlingSpinner.error("Bundling failed");
         },
-        clearError: assign({
-            error: () => undefined,
-        }),
         setUpgradeType: assign({
             upgradeType: (_, params) => params.output,
         }),
-        setError: assign({
-            error: (_, params) => params.error,
-        }),
         setVersions: assign({
-            versions: (_, params) => params.versions,
-        }),
-        setDeveloperConfig: assign({
-            developer: (_, params) => params,
-        }),
-        setConfigError: assign({
-            configError: (_, params) => params.configError,
+            versions: (_, params) => params.output,
         }),
         setJsContents: assign({
             jsContents: (_, params) => params.contents,
         }),
         setVersion: assign({
-            version: (_, params) => params.version,
+            version: (_, params) => params.output,
         }),
-        setAppConfig: assign({
-            config: (_, params) => params.config,
+        setToken: assign({
+            token: (_, params) => params.output,
+        }),
+        setAppSlug: assign({
+            appSlug: (_, params) => params.output,
+        }),
+        setAppInfo: assign({
+            appInfo: (_, params) => params.output,
         }),
     },
 }).createMachine({
     context: {
-        developer: { slug: "", token: "" },
-        config: emptyConfig,
+        token: "",
+        appSlug: "",
         upgradeType: "minor",
         versions: [],
     },
     id: "Create Version Machine",
     states: {
-        "Loading Developer Config": {
+        "Authenticate": {
             invoke: {
-                src: "loadDeveloperConfig",
-            },
-            on: {
-                "Developer Config Loaded": {
-                    target: "Loading App Config",
-                    actions: { type: "setDeveloperConfig", params: ({ event }) => event },
+                src: "authenticate",
+                onDone: {
+                    target: "Loading App Slug",
+                    actions: { type: "setToken", params: ({ event }) => event },
                 },
-                "No Developer Config": {
-                    target: "Show config instructions",
-                    actions: { type: "setConfigError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Show config instructions": {
-            type: "final",
-            entry: "showConfigInstructions",
-        },
-        "Loading App Config": {
-            invoke: {
-                src: "loadAppConfig",
-            },
-            on: {
-                "Error": {
+                onError: {
                     target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-                "App Config Loaded": {
-                    target: "JavaScript",
-                    actions: { type: "setAppConfig", params: ({ event }) => event },
-                    reenter: true,
+                    actions: { type: "showActorError", params: ({ event }) => event },
                 },
             },
         },
         "Error": {
             type: "final",
-            entry: { type: "showError", params: ({ context }) => ({ error: context.error }) },
         },
         "Creating version": {
             invoke: {
                 src: "createVersion",
-                input: ({ context }) => context,
-            },
-            on: {
-                "Error": {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-                "Version Created": {
+                input: ({ context }) => ({
+                    token: context.token,
+                    appSlug: context.appSlug,
+                    upgradeType: context.upgradeType,
+                    appInfo: context.appInfo,
+                    versions: context.versions,
+                }),
+                onDone: {
                     target: "Uploading",
                     actions: { type: "setVersion", params: ({ event }) => event },
                 },
+                onError: {
+                    target: "Error",
+                    actions: { type: "showActorError", params: ({ event }) => event },
+                },
             },
         },
         "Success": {
@@ -253,20 +220,14 @@ export const createVersionMachine = setup({
             invoke: {
                 src: "upload",
                 input: ({ context }) => ({
+                    token: context.token,
                     version: context.version,
-                    developer: context.developer,
                     jsContents: context.jsContents,
                 }),
-            },
-            on: {
-                "Upload Complete": {
-                    target: "Success",
-                    reenter: true,
-                },
-                "Error": {
+                onDone: "Success",
+                onError: {
                     target: "Error",
-                    reenter: true,
-                    actions: { type: "setError", params: ({ event }) => event },
+                    actions: { type: "showActorError", params: ({ event }) => event },
                 },
             },
         },
@@ -296,20 +257,52 @@ export const createVersionMachine = setup({
         "Fetching Versions": {
             invoke: {
                 src: "fetchVersions",
-                input: ({ context }) => context,
-            },
-            on: {
-                "Versions Fetched": {
+                input: ({ context }) => ({
+                    token: context.token,
+                    appInfo: context.appInfo,
+                }),
+                onDone: {
                     target: "Determine if first version",
-                    actions: { type: "setVersions", params: ({ event }) => event },
+                    actions: {
+                        type: "setVersions",
+                        params: ({ event }) => event,
+                    },
+                },
+                onError: {
+                    target: "Error",
+                    actions: { type: "showActorError", params: ({ event }) => event },
+                },
+            },
+        },
+        "Loading App Slug": {
+            invoke: {
+                src: "loadAppSlug",
+                onDone: {
+                    target: "Loading App Info",
+                    actions: { type: "setAppSlug", params: ({ event }) => event },
+                    reenter: true,
+                },
+                onError: {
+                    target: "Error",
+                    actions: { type: "showActorError", params: ({ event }) => event },
+                },
+            },
+        },
+        "Loading App Info": {
+            invoke: {
+                src: "loadAppInfo",
+                input: ({ context }) => context,
+                onDone: {
+                    target: "JavaScript",
+                    actions: { type: "setAppInfo", params: ({ event }) => event },
                 },
-                "Error": {
+                onError: {
                     target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
+                    actions: { type: "showActorError", params: ({ event }) => event },
                 },
             },
         },
     },
-    initial: "Loading Developer Config",
+    initial: "Authenticate",
     entry: "printLogo",
 });