attio 0.0.1-experimental.20250303 → 0.0.1-experimental.20250311

package/lib/api/fetch-workspaces.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { APP } from "../env.js";
+import { handleError } from "./handle-error.js";
+import { makeHeaders } from "./make-headers.js";
+const workspacesResponseSchema = z.array(z.object({
+    workspace: z.object({
+        id: z.string(),
+        name: z.string(),
+        slug: z.string(),
+    }),
+    membership: z.object({
+        access_level: z.enum(["admin", "member", "suspended"]),
+    }),
+}));
+export async function fetchWorkspaces({ token }) {
+    const response = await fetch(`${APP}/api/common/workspaces`, {
+        method: "GET",
+        headers: makeHeaders(token),
+    });
+    await handleError(response);
+    return workspacesResponseSchema
+        .parse(await response.json())
+        .map(({ workspace, membership }) => ({ ...workspace, ...membership }));
+}

package/lib/machines/dev-machine.js

@@ -1,13 +1,13 @@
 import chokidar from "chokidar";
 import open from "open";
-import { assign, setup, enqueueActions } from "xstate";
+import { assign, setup, enqueueActions, fromPromise } from "xstate";
 import { APP } from "../env.js";
 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, } from "../util/load-developer-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";
@@ -23,7 +23,8 @@ 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 { fromCallbackWithErrorHandling } from "./actors.js";
+import { askWithTypedChoices, fromCallbackWithErrorHandling } from "./actors.js";
+import { fetchWorkspaces } from "../api/fetch-workspaces.js";
 process.on("SIGINT", () => {
     process.stdout.write("\x1B[?25h");
     process.exit();
@@ -40,12 +41,18 @@ export const devMachine = setup({
     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") {
@@ -98,6 +105,15 @@ 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();
@@ -248,8 +264,8 @@ export const devMachine = setup({
         printUploadError: (_, params) => {
             printMessage(params.uploadError.message);
         },
-        printGenericError: (_, params) => {
-            process.stderr.write(`${params.error.message}\n\n`);
+        printError: (_, params) => {
+            printMessage(params.error);
         },
         printLogo: (_) => {
             process.stdout.write("\x1B[?25l");
@@ -289,7 +305,7 @@ export const devMachine = setup({
             open(`http://localhost:${context.graphqlPort}/graphql`);
         },
         openInstallPage: ({ context }) => {
-            open(`${APP}/_/settings/apps/${context.devVersion?.app_slug}`);
+            open(`${APP}/${context.workspace.slug}/settings/apps/${context.devVersion?.app_slug}`);
         },
         saveTypeScriptErrors: assign({
             typeScriptErrors: (_, params) => params.errors,
@@ -329,6 +345,21 @@ export const devMachine = setup({
                 ? `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);
+        },
+        setWorkspaces: assign({
+            workspaces: (_, params) => params.output,
+        }),
+        setWorkspace: assign({
+            workspace: (_, params) => params.output,
+        }),
         setSuccess: assign({
             jsContents: (_, params) => params.contents,
             lastSuccessfulJavaScriptBuild: (_, params) => params.time,
@@ -610,8 +641,9 @@ export const devMachine = setup({
         "Read Config": {
             on: {
                 "Initialized": {
-                    target: "Watching",
+                    target: "Choose Target Workspace",
                     actions: { type: "setConfig", params: ({ event }) => event },
+                    reenter: true,
                 },
                 "Initialization Error": {
                     target: "No Config",
@@ -632,15 +664,175 @@ export const devMachine = setup({
         "Auth Error": {
             type: "final",
         },
-        "Generic Error": {
+        "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}`,
+                                }),
+                            },
+                        },
+                    },
+                },
+                "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
+                                      `,
+                                    }),
+                                },
+                            },
+                        ],
+                    },
+                },
+                "No Workspaces": {
+                    type: "final",
+                },
+                "Failed to load workspaces": {
+                    type: "final",
+                },
+            },
+            initial: "Need Target Workspace?",
+        },
+        "Require Admin Workspace": {
+            type: "final",
+        },
+        "Not admin of only workspace": {
             type: "final",
         },
-    },
-    entry: "printLogo",
-    on: {
-        Error: {
-            target: ".Generic Error",
-            actions: { type: "printGenericError", params: ({ event }) => event },
+        "Loading Workspace Details": {
+            invoke: {
+                src: "loadWorkspaceDetails",
+                input: ({ context }) => ({
+                    config: context.config,
+                }),
+                onDone: {
+                    target: "Watching",
+                    actions: { type: "setWorkspace", params: ({ event }) => event },
+                },
+                onError: {
+                    target: "Failed to load workspaces",
+                    actions: {
+                        type: "printError",
+                        params: () => ({
+                            error: "Failed to load workspace details",
+                        }),
+                    },
+                },
+            },
+        },
+        "Failed to load workspaces": {
+            type: "final",
         },
     },
+    entry: "printLogo",
 });

package/lib/util/load-developer-config.js

@@ -7,7 +7,7 @@ import { isValidSlug } from "./validate-slug.js";
 export const initialDeveloperConfigSchema = z.object({
     token: z.string(),
     developer_slug: z.string(),
-    target_workspace_id: z.string().uuid(),
+    target_workspace_id: z.string().uuid().optional().nullable(),
 });
 const developerConfigSchema = initialDeveloperConfigSchema.extend({
     developer_account_id: z.string(),
@@ -76,8 +76,16 @@ export async function loadDeveloperConfig() {
         developer_slug: developerSlug,
         developer_account_id: devAccount.developer_account.developer_account_id,
         developer_account_member_id: devAccount.developer_account_member.developer_account_member_id,
-        target_workspace_id: initialDeveloperConfig.target_workspace_id,
+        target_workspace_id: initialDeveloperConfig.target_workspace_id ?? null,
     });
     writeFileSync(configFile.path, stringify(config));
     return config;
 }
+export async function saveTargetWorkspaceToConfig(workspaceId) {
+    const configFile = readDeveloperConfigFile();
+    if (configFile === "No config file" || configFile === "Invalid config file")
+        return;
+    const config = developerConfigSchema.parse(configFile.contents);
+    config.target_workspace_id = workspaceId;
+    writeFileSync(configFile.path, stringify(config));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20250303",
+  "version": "0.0.1-experimental.20250311",
   "bin": "lib/attio.js",
   "type": "module",
   "files": [