attio 0.0.1-experimental.20250324 → 0.0.1-experimental.20250325

package/lib/machines/dev-machine.js

@@ -6,8 +6,6 @@ import { completeBundleUpload } from "../api/complete-bundle-upload.js";
 import { createDevVersion } from "../api/create-dev-version.js";
 import { startGraphqlServer } from "../api/start-graphql-server.js";
 import { startUpload } from "../api/start-upload.js";
-import { loadAppConfigFile } from "../util/app-config.js";
-import { loadDeveloperConfig, loadInitialDeveloperConfig, saveTargetWorkspaceToConfig, } from "../util/load-developer-config.js";
 import notifier from "node-notifier";
 import { loadEnv } from "../util/load-env.js";
 import { loadAttioCliPackageJson } from "../util/load-attio-cli-package-json.js";
@@ -21,10 +19,8 @@ import { printMessage } from "../util/print-message.js";
 import { printJsError, printTsError } from "../util/typescript.js";
 import { clearTerminal } from "../util/clear-terminal.js";
 import { setTerminalTitle } from "../util/set-terminal-title.js";
-import { printInstallInstructions } from "../util/print-install-instructions.js";
-import { printLogo } from "./actions.js";
-import { askWithTypedChoices, fromCallbackWithErrorHandling } from "./actors.js";
-import { fetchWorkspaces } from "../api/fetch-workspaces.js";
+import { printLogo, showActorError } from "./actions.js";
+import { askWithTypedChoices, authenticate, determineWorkspace, fromCallbackWithErrorHandling, loadAppInfo, loadAppSlug, } from "./actors.js";
 import { ensureAuthed } from "../api/ensure-authed.js";
 process.on("SIGINT", () => {
     process.stdout.write("\x1B[?25h");
@@ -37,33 +33,18 @@ export const devMachine = setup({
     types: {
         context: {},
         events: {},
+        input: {},
         children: {},
     },
-    guards: {
-        "have dev version": ({ context }) => Boolean(context.devVersion),
-        "have typescript errors": (_, params) => Boolean(params.typeScriptErrors?.length),
-        "have target workspace": (_, params) => Boolean(params.config?.target_workspace_id),
-        "have workspaces": (_, params) => Boolean(params.output?.length),
-        "is workspace admin": (_, params) => params.output.access_level === "admin",
-        "only one workspace and admin": (_, params) => params.output.length === 1 && params.output[0].access_level === "admin",
-        "only one workspace and not admin": (_, params) => params.output.length === 1 && params.output[0].access_level !== "admin",
-    },
     actors: {
         "javascript": jsMachine,
         "typescript": tsMachine,
         "env": envMachine,
         "code-gen": codeGenMachine,
         "askForWorkspace": askWithTypedChoices(),
-        "loadConfig": fromCallbackWithErrorHandling(({ sendBack }) => {
-            const config = loadInitialDeveloperConfig();
-            if (typeof config === "string") {
-                sendBack({ type: "Initialization Error", error: config });
-                return;
-            }
-            ensureAuthed().then((token) => {
-                sendBack({ type: "Initialized", config: { ...config, token } });
-            });
-        }),
+        authenticate,
+        loadAppSlug,
+        loadAppInfo,
         "keyboard": fromCallbackWithErrorHandling(({ sendBack }) => {
             if (!process.stdin.isTTY)
                 return;
@@ -108,64 +89,29 @@ export const devMachine = setup({
                 }
             };
         }),
-        "loadWorkspaces": fromPromise(async ({ input }) => await fetchWorkspaces({ token: input.token })),
-        "loadWorkspaceDetails": fromPromise(async ({ input }) => {
-            const workspaces = await fetchWorkspaces({ token: input.config.token });
-            const workspace = workspaces.find((workspace) => workspace.id === input.config.target_workspace_id);
-            if (!workspace) {
-                throw new Error(`Workspace not found: ${input.config.target_workspace_id}`);
-            }
-            return workspace;
-        }),
-        "prepareUpload": fromCallbackWithErrorHandling(({ sendBack }) => {
-            const prepareUpload = async () => {
-                const config = await loadDeveloperConfig();
-                if (typeof config === "string")
-                    throw config;
-                const app = loadAppConfigFile();
-                if (typeof app === "string")
-                    throw app;
-                const environmentVariables = await loadEnv();
-                if (typeof environmentVariables === "string")
-                    throw environmentVariables;
-                const packageJson = loadAttioCliPackageJson();
-                if (typeof packageJson === "string")
-                    throw packageJson;
-                const devVersion = await createDevVersion({
-                    token: await ensureAuthed(),
-                    devSlug: config.developer_slug,
-                    appId: app.id,
-                    targetWorkspaceId: config.target_workspace_id,
-                    environmentVariables,
-                    cliVersion: packageJson.version,
-                });
-                sendBack({
-                    type: "Upload Prepared",
-                    devVersion: { ...devVersion, app_slug: app.slug },
-                });
-            };
-            prepareUpload().catch((error) => {
-                if (error instanceof Error &&
-                    error.message.includes("invalid authentication token")) {
-                    sendBack({
-                        type: "Auth Error",
-                        error,
-                    });
-                    return;
-                }
-                sendBack({
-                    type: "Upload Error",
-                    error: typeof error === "string" ? new Error(error) : error,
-                });
+        determineWorkspace,
+        "prepareUpload": fromPromise(async ({ input: { appInfo, workspace } }) => {
+            const environmentVariables = await loadEnv();
+            if (typeof environmentVariables === "string")
+                throw environmentVariables;
+            const packageJson = loadAttioCliPackageJson();
+            if (typeof packageJson === "string")
+                throw packageJson;
+            const devVersion = await createDevVersion({
+                token: await ensureAuthed(),
+                appId: appInfo.app_id,
+                targetWorkspaceId: workspace.id,
+                environmentVariables,
+                cliVersion: packageJson.version,
             });
+            return devVersion;
         }),
-        "upload": fromCallbackWithErrorHandling(({ sendBack, input: { config: { token, developer_slug: developerSlug }, contents, devVersion: { app_id: appId, app_dev_version_id: devVersionId }, }, }) => {
+        "upload": fromPromise(async ({ input: { token, contents, devVersion: { app_dev_version_id: devVersionId }, appInfo: { app_id: appId }, }, }) => {
             const spinner = new Spinner();
-            const upload = async () => {
+            try {
                 spinner.start("Uploading...");
                 const { client_bundle_upload_url, server_bundle_upload_url, app_dev_version_bundle_id: bundleId, } = await startUpload({
                     token,
-                    developerSlug,
                     appId,
                     devVersionId,
                 });
@@ -192,26 +138,29 @@ export const devMachine = setup({
                 });
                 await completeBundleUpload({
                     token,
-                    developerSlug,
                     appId,
                     devVersionId,
                     bundleId,
                 });
                 spinner.success(`Upload completed at ${new Date().toLocaleString()}.`);
-                sendBack({ type: "Upload Complete" });
                 notifier.notify({
                     title: "Upload Complete",
                     message: "New bundle uploaded to Attio",
                 });
-            };
-            upload().catch((error) => {
-                spinner.error(`Upload failed: ${error.message}`);
-                sendBack({ type: "Upload Error", error });
-                notifier.notify({
-                    title: "Upload Failed",
-                    message: "Bundle upload to Attio failed",
-                });
-            });
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    spinner.error(`Upload failed: ${error.message}`);
+                    notifier.notify({
+                        title: "Upload Failed",
+                        message: "Bundle upload to Attio failed",
+                    });
+                }
+                throw error;
+            }
+            finally {
+                spinner.stop();
+            }
         }),
         "watch": fromCallbackWithErrorHandling(({ sendBack }) => {
             const watcher = chokidar.watch(["src", ".env"], {
@@ -225,12 +174,11 @@ export const devMachine = setup({
             };
         }),
         "graphql": fromCallbackWithErrorHandling(({ sendBack }) => startGraphqlServer(sendBack)),
-        "loadInstallation": fromCallbackWithErrorHandling(({ sendBack, input }) => {
+        "loadInstallation": fromCallbackWithErrorHandling(({ sendBack, input: { token, appInfo, workspace } }) => {
             fetchInstallation({
-                token: input.config.token,
-                devSlug: input.config.developer_slug,
-                appId: input.devVersion.app_id,
-                workspaceId: input.config.target_workspace_id,
+                token,
+                appId: appInfo.app_id,
+                workspaceId: workspace.id,
             }).then((installation) => {
                 if (installation) {
                     sendBack({ type: "Found Installation" });
@@ -240,13 +188,12 @@ export const devMachine = setup({
                 }
             });
         }),
-        "pollForInstallation": fromCallbackWithErrorHandling(({ sendBack, input }) => {
+        "pollForInstallation": fromCallbackWithErrorHandling(({ sendBack, input: { token, appInfo, workspace } }) => {
             const interval = setInterval(() => {
                 fetchInstallation({
-                    token: input.config.token,
-                    devSlug: input.config.developer_slug,
-                    appId: input.devVersion.app_id,
-                    workspaceId: input.config.target_workspace_id,
+                    token,
+                    appId: appInfo.app_id,
+                    workspaceId: workspace.id,
                 }).then((installation) => {
                     if (installation) {
                         sendBack({ type: "Found Installation" });
@@ -258,15 +205,10 @@ export const devMachine = setup({
     },
     actions: {
         clearUploadError: assign({ uploadError: undefined }),
-        showConfigInstructions: ({ context }) => {
-            printInstallInstructions(context.configError);
-        },
+        showActorError,
         printAuthError: (_, params) => {
             process.stderr.write(`${params.error.message}\n\n`);
         },
-        printUploadError: (_, params) => {
-            printMessage(params.uploadError.message);
-        },
         printError: (_, params) => {
             printMessage(params.error);
         },
@@ -308,7 +250,7 @@ export const devMachine = setup({
             open(`http://localhost:${context.graphqlPort}/graphql`);
         },
         openInstallPage: ({ context }) => {
-            open(`${APP}/${context.workspace.slug}/settings/apps/${context.devVersion?.app_slug}`);
+            open(`${APP}/${context.workspace.slug}/settings/apps/${context.appSlug}`);
         },
         saveTypeScriptErrors: assign({
             typeScriptErrors: (_, params) => params.errors,
@@ -331,37 +273,26 @@ export const devMachine = setup({
         sendCodeGenerationDone: enqueueActions(({ enqueue }) => {
             enqueue.sendTo("typescript", { type: "Change" });
         }),
-        setConfig: assign({
-            config: (_, params) => params.config,
+        setToken: assign({
+            token: (_, params) => params.output,
         }),
-        setConfigError: assign({
-            configError: (_, params) => params.error,
+        setAppInfo: assign({
+            appInfo: (_, params) => params.output,
         }),
-        setDevVersion: assign({
-            devVersion: (_, params) => params.devVersion,
+        setAppSlug: assign({
+            appSlug: (_, params) => params.output,
+        }),
+        setWorkspace: assign({
+            workspace: (_, params) => params.output,
         }),
         setGraphqlPort: assign({
             graphqlPort: (_, params) => params.port,
         }),
-        setTerminalTitle: ({ context }) => {
-            setTerminalTitle(context.devVersion?.app_id
-                ? `attio dev – ${context.devVersion.app_id}`
-                : `attio dev`);
-        },
-        setTargetWorkspace: assign({
-            config: (_, params) => ({
-                ...params.config,
-                target_workspace_id: params.workspace.id,
-            }),
-        }),
-        saveTargetWorkspaceToConfig: (_, params) => {
-            saveTargetWorkspaceToConfig(params.workspace.id);
+        setTerminalTitle: (_, params) => {
+            setTerminalTitle(params.devVersion?.app_id ? `attio dev – ${params.devVersion.app_id}` : `attio dev`);
         },
-        setWorkspaces: assign({
-            workspaces: (_, params) => params.output,
-        }),
-        setWorkspace: assign({
-            workspace: (_, params) => params.output,
+        setDevVersion: assign({
+            devVersion: (_, params) => params.output,
         }),
         setSuccess: assign({
             jsContents: (_, params) => params.contents,
@@ -372,9 +303,15 @@ export const devMachine = setup({
         }),
     },
 }).createMachine({
-    context: { jsContents: ["", ""] },
+    context: ({ input }) => ({
+        jsContents: ["", ""],
+        appSlug: "",
+        token: "",
+        appInfo: { app_id: "", title: "" },
+        ...input,
+    }),
     id: "Dev Machine",
-    initial: "Read Config",
+    initial: "Authenticate",
     states: {
         "Watching": {
             invoke: [
@@ -438,91 +375,63 @@ export const devMachine = setup({
                             entry: "printWatching",
                         },
                         "Uploading": {
-                            on: {
-                                "Upload Complete": "Watching",
-                            },
                             invoke: {
                                 src: "upload",
                                 input: ({ context }) => {
-                                    if (!context.devVersion)
-                                        throw new Error("No devVersion");
-                                    if (!context.config)
-                                        throw new Error("No config");
                                     return {
                                         devVersion: context.devVersion,
-                                        config: context.config,
+                                        appInfo: context.appInfo,
+                                        token: context.token,
                                         contents: context.jsContents,
                                     };
                                 },
+                                onDone: "Watching",
+                                onError: {
+                                    target: "#Dev Machine.Error",
+                                    actions: { type: "showActorError", params: ({ event }) => event },
+                                },
                             },
                         },
                         "Upload When Ready": {
                             always: {
-                                target: "Can Upload?",
-                                guard: "have dev version",
+                                target: "Uploading",
+                                guard: ({ context }) => Boolean(context.devVersion),
                                 reenter: true,
                             },
-                            on: {
-                                "Upload Prepared": {
-                                    target: "Can Upload?",
-                                    actions: { type: "setDevVersion", params: ({ event }) => event },
-                                    reenter: true,
-                                },
-                            },
-                        },
-                        "Upload Error": {
-                            exit: "clearUploadError",
-                            on: {
-                                Change: {
-                                    target: "#Dev Machine.Watching.JavaScript",
-                                    reenter: true,
-                                    actions: "sendChange",
-                                    description: `Re-enter to invoke prepareUpload again`,
-                                },
-                            },
-                            entry: {
-                                type: "printUploadError",
-                                params: ({ context }) => ({ uploadError: context.uploadError }),
-                            },
-                        },
-                        "Can Upload?": {
-                            always: [
-                                {
-                                    target: "Watching",
-                                    guard: {
-                                        type: "have typescript errors",
-                                        params: ({ context }) => context,
-                                    },
-                                    reenter: true,
-                                },
-                                "Uploading",
-                            ],
                         },
                     },
                     initial: "Building",
                     on: {
-                        "Upload Prepared": {
-                            target: "JavaScript",
-                            actions: [
-                                { type: "setDevVersion", params: ({ event }) => event },
-                                "setTerminalTitle",
-                            ],
-                        },
                         "Change": {
                             target: "JavaScript",
                             actions: "sendChange",
                         },
-                        "Upload Error": {
-                            target: ".Upload Error",
-                            actions: { type: "setUploadError", params: ({ event }) => event },
-                        },
                         "Auth Error": {
                             target: "#Dev Machine.Auth Error",
-                            actions: { type: "printAuthError", params: ({ event }) => event },
+                            actions: {
+                                type: "printAuthError",
+                                params: ({ event }) => event,
+                            },
                         },
                     },
                     invoke: {
                         src: "prepareUpload",
+                        input: ({ context }) => ({
+                            appInfo: context.appInfo,
+                            workspace: context.workspace,
+                        }),
+                        onDone: {
+                            target: "JavaScript",
+                            actions: [
+                                { type: "setDevVersion", params: ({ event }) => event },
+                                { type: "setTerminalTitle", params: ({ event }) => event },
+                            ],
+                            reenter: true,
+                        },
+                        onError: {
+                            target: "#Dev Machine.Error",
+                            actions: { type: "showActorError", params: ({ event }) => event },
+                        },
                     },
                 },
                 TypeScript: {
@@ -593,8 +502,10 @@ export const devMachine = setup({
                             invoke: {
                                 src: "loadInstallation",
                                 input: ({ context }) => ({
-                                    config: context.config,
+                                    appInfo: context.appInfo,
+                                    token: context.token,
                                     devVersion: context.devVersion,
+                                    workspace: context.workspace,
                                 }),
                             },
                             on: {
@@ -612,8 +523,10 @@ export const devMachine = setup({
                             invoke: {
                                 src: "pollForInstallation",
                                 input: ({ context }) => ({
-                                    config: context.config,
+                                    appInfo: context.appInfo,
+                                    token: context.token,
                                     devVersion: context.devVersion,
+                                    workspace: context.workspace,
                                 }),
                             },
                             on: {
@@ -641,201 +554,76 @@ export const devMachine = setup({
             type: "parallel",
             entry: "promptToOpenGraphQLExplorer",
         },
-        "Read Config": {
-            on: {
-                "Initialized": {
-                    target: "Choose Target Workspace",
-                    actions: { type: "setConfig", params: ({ event }) => event },
+        "Authenticate": {
+            invoke: {
+                src: "authenticate",
+                onDone: {
+                    target: "Loading App Slug",
                     reenter: true,
+                    actions: { type: "setToken", params: ({ event }) => event },
                 },
-                "Initialization Error": {
-                    target: "No Config",
+                onError: {
+                    target: "Error",
                     actions: {
-                        type: "setConfigError",
+                        type: "showActorError",
                         params: ({ event }) => event,
                     },
                 },
             },
-            invoke: {
-                src: "loadConfig",
-            },
-        },
-        "No Config": {
-            type: "final",
-            entry: "showConfigInstructions",
         },
         "Auth Error": {
             type: "final",
         },
-        "Choose Target Workspace": {
-            states: {
-                "Need Target Workspace?": {
-                    always: [
-                        {
-                            target: "#Dev Machine.Loading Workspace Details",
-                            guard: { type: "have target workspace", params: ({ context }) => context },
-                            reenter: true,
-                        },
-                        "Loading Workspaces",
-                    ],
-                },
-                "Loading Workspaces": {
-                    invoke: {
-                        src: "loadWorkspaces",
-                        input: ({ context }) => ({ token: context.config.token }),
-                        onDone: [
-                            {
-                                target: "#Dev Machine.Loading Workspace Details",
-                                guard: {
-                                    type: "only one workspace and admin",
-                                    params: ({ event }) => event,
-                                },
-                                reenter: true,
-                                actions: [
-                                    {
-                                        type: "setTargetWorkspace",
-                                        params: ({ context, event }) => ({
-                                            config: context.config,
-                                            workspace: event.output[0],
-                                        }),
-                                    },
-                                    {
-                                        type: "saveTargetWorkspaceToConfig",
-                                        params: ({ event }) => ({ workspace: event.output[0] }),
-                                    },
-                                ],
-                            },
-                            {
-                                target: "#Dev Machine.Not admin of only workspace",
-                                guard: {
-                                    type: "only one workspace and not admin",
-                                    params: ({ event }) => event,
-                                },
-                                reenter: true,
-                                actions: {
-                                    type: "printError",
-                                    params: ({ event }) => ({
-                                        error: `You are not the admin of the workspace ${event.output[0].name}. Please ask an admin to make you an admin of the workspace or create your own workspace.
-
-${APP}/welcome/workspace-details
-                                      `,
-                                    }),
-                                },
-                            },
-                            {
-                                target: "Ask for Workspace",
-                                guard: { type: "have workspaces", params: ({ event }) => event },
-                                actions: { type: "setWorkspaces", params: ({ event }) => event },
-                            },
-                            {
-                                target: "No Workspaces",
-                                reenter: true,
-                                actions: {
-                                    type: "printError",
-                                    params: () => ({
-                                        error: `You are not the admin of any workspaces. Either request permission from an existing workspace or create your own.
-
-${APP}/welcome/workspace-details
-                                      `,
-                                    }),
-                                },
-                            },
-                        ],
-                        onError: {
-                            target: "Failed to load workspaces",
-                            actions: {
-                                type: "printError",
-                                params: ({ event }) => ({
-                                    error: `Failed to load workspaces: ${event.error}`,
-                                }),
-                            },
-                        },
-                    },
+        "Loading App Info": {
+            invoke: {
+                src: "loadAppInfo",
+                input: ({ context }) => context,
+                onDone: {
+                    target: "Determine Workspace",
+                    actions: { type: "setAppInfo", params: ({ event }) => event },
+                    reenter: true,
                 },
-                "Ask for Workspace": {
-                    invoke: {
-                        src: "askForWorkspace",
-                        input: ({ context }) => ({
-                            message: "Choose a workspace",
-                            choices: context.workspaces.map((workspace) => ({
-                                name: workspace.name,
-                                value: workspace,
-                            })),
-                        }),
-                        onDone: [
-                            {
-                                target: "#Dev Machine.Loading Workspace Details",
-                                actions: [
-                                    {
-                                        type: "setTargetWorkspace",
-                                        params: ({ context, event }) => ({
-                                            config: context.config,
-                                            workspace: event.output,
-                                        }),
-                                    },
-                                    {
-                                        type: "saveTargetWorkspaceToConfig",
-                                        params: ({ event }) => ({ workspace: event.output }),
-                                    },
-                                ],
-                                guard: { type: "is workspace admin", params: ({ event }) => event },
-                                reenter: true,
-                            },
-                            {
-                                target: "#Dev Machine.Require Admin Workspace",
-                                reenter: true,
-                                actions: {
-                                    type: "printError",
-                                    params: ({ event }) => ({
-                                        error: `You are not the admin of the workspace ${event.output.name}. Please ask an admin to make you an admin of the workspace or create your own workspace.
-
-${APP}/welcome/workspace-details
-                                      `,
-                                    }),
-                                },
-                            },
-                        ],
-                    },
+                onError: {
+                    target: "Error",
+                    actions: { type: "showActorError", params: ({ event }) => event },
                 },
-                "No Workspaces": {
-                    type: "final",
+            },
+        },
+        "Loading App Slug": {
+            invoke: {
+                src: "loadAppSlug",
+                onDone: {
+                    target: "Loading App Info",
+                    actions: { type: "setAppSlug", params: ({ event }) => event },
                 },
-                "Failed to load workspaces": {
-                    type: "final",
+                onError: {
+                    target: "Error",
+                    actions: { type: "showActorError", params: ({ event }) => event },
                 },
             },
-            initial: "Need Target Workspace?",
-        },
-        "Require Admin Workspace": {
-            type: "final",
         },
-        "Not admin of only workspace": {
+        "Error": {
             type: "final",
         },
-        "Loading Workspace Details": {
+        "Determine Workspace": {
             invoke: {
-                src: "loadWorkspaceDetails",
-                input: ({ context }) => ({
-                    config: context.config,
-                }),
+                src: "determineWorkspace",
+                input: ({ context }) => context,
                 onDone: {
                     target: "Watching",
-                    actions: { type: "setWorkspace", params: ({ event }) => event },
+                    actions: [
+                        {
+                            type: "setWorkspace",
+                            params: ({ event }) => event,
+                        },
+                    ],
                 },
                 onError: {
-                    target: "Failed to load workspaces",
-                    actions: {
-                        type: "printError",
-                        params: () => ({
-                            error: "Failed to load workspace details",
-                        }),
-                    },
+                    target: "Error",
+                    actions: { type: "showActorError", params: ({ event }) => event },
                 },
             },
         },
-        "Failed to load workspaces": {
-            type: "final",
-        },
     },
     entry: "printLogo",
 });