attio 0.0.1-experimental.20250328 → 0.0.1-experimental.20250401

package/lib/commands/version/create.js

@@ -1,20 +1,76 @@
-import { Command, Option } from "commander";
-import { createActor } from "xstate";
-import { z } from "zod";
-import { createVersionMachine } from "../../machines/create-version-machine.js";
-export const optionsSchema = z.object({
-    dev: z.boolean().default(false),
-});
+import { Command } from "commander";
+import chalk from "chalk";
+import { Spinner } from "../../util/spinner.js";
+import { loadAttioCliPackageJson } from "../../util/load-attio-cli-package-json.js";
+import { createVersion } from "../../api/create-version.js";
+import { fetchVersions } from "../../api/fetch-versions.js";
+import { completeProdBundleUpload } from "../../api/complete-prod-bundle-upload.js";
+import { buildJavaScript } from "../dev/build-javascript.js";
+import { boot } from "./create/boot.js";
 export const versionCreate = new Command("create")
     .description("Create a new unpublished version of your Attio app")
-    .addOption(new Option("--dev", "Run in development mode (additional debugging info)"))
-    .action((unparsedOptions) => {
-    const options = optionsSchema.parse(unparsedOptions);
-    const actor = createActor(createVersionMachine);
-    if (options.dev) {
-        actor.subscribe((state) => {
-            console.log("state:", state.value);
+    .action(async () => {
+    try {
+        const { token, appInfo } = await boot();
+        const bundlingSpinner = new Spinner();
+        bundlingSpinner.start("Bundling JavaScript...");
+        const [clientBundle, serverBundle] = await new Promise((resolve) => {
+            const cleanup = buildJavaScript((bundles) => {
+                cleanup();
+                bundlingSpinner.success("Bundling complete");
+                resolve(bundles);
+            });
+        });
+        const versions = await fetchVersions({
+            token,
+            appId: appInfo.app_id,
+        });
+        const uploadSpinner = new Spinner();
+        uploadSpinner.start("Uploading...");
+        const packageJson = loadAttioCliPackageJson();
+        if (typeof packageJson === "string")
+            throw packageJson;
+        const major = versions.length === 0 ? 1 : Math.max(...versions.map((version) => version.major), 1);
+        const version = await createVersion({
+            token,
+            appId: appInfo.app_id,
+            major,
+            cliVersion: packageJson.version,
         });
+        await Promise.all([
+            fetch(version.client_bundle_upload_url, {
+                method: "PUT",
+                body: clientBundle,
+                headers: {
+                    "Content-Type": "text/javascript",
+                    "Content-Length": String(Buffer.from(clientBundle).length),
+                },
+            }),
+            fetch(version.server_bundle_upload_url, {
+                method: "PUT",
+                body: serverBundle,
+                headers: {
+                    "Content-Type": "text/javascript",
+                    "Content-Length": String(Buffer.from(serverBundle).length),
+                },
+            }),
+        ]);
+        uploadSpinner.success("Upload complete");
+        const signSpinner = new Spinner();
+        signSpinner.start("Signing bundles...");
+        await completeProdBundleUpload({
+            token,
+            appId: version.app_id,
+            major: version.major,
+            minor: version.minor,
+            bundleId: version.app_prod_version_bundle_id,
+        });
+        signSpinner.success("Bundles signed");
+        process.stdout.write(`\nVersion ${chalk.green(`${version.major}.${version.minor}`)} created!\n\n`);
+        process.exit(0);
+    }
+    catch (error) {
+        process.stderr.write(`${chalk.red("✖ " + error)}\n`);
+        process.exit(1);
     }
-    actor.start();
 });

package/lib/commands/version/list.js

@@ -4,14 +4,15 @@ import Table from "cli-table3";
 import chalk from "chalk";
 import formatDate from "date-fns/format/index.js";
 import { ensureAuthed } from "../../api/ensure-authed.js";
-import { getAppSlugFromPackageJson, fetchAppInfo } from "../../machines/actors.js";
+import { getAppSlugFromPackageJson } from "../../api/get-app-slug-from-package-json.js";
+import { getAppInfo } from "../../api/get-app-info.spinner.js";
 export const versionList = new Command("list")
     .description("List all versions of your Attio app")
     .alias("ls")
     .action(async () => {
     const token = await ensureAuthed();
     const appSlug = await getAppSlugFromPackageJson();
-    const appInfo = await fetchAppInfo({ token, appSlug });
+    const appInfo = await getAppInfo({ token, appSlug });
     const versions = await fetchVersions({
         token,
         appId: appInfo.app_id,
@@ -31,4 +32,5 @@ export const versionList = new Command("list")
         formatDate(new Date(version.created_at), "MMMM d, yyyy, HH:mm"),
     ]));
     process.stdout.write(table.toString());
+    process.exit(0);
 });

package/lib/commands/whoami.js

@@ -7,7 +7,7 @@ export const whoami = new Command("whoami")
     const token = await authApi();
     if (!token) {
         process.stdout.write("🔒 Not logged in.\n");
-        return;
+        process.exit(0);
     }
     try {
         const user = await whoamiApi({ token });
@@ -15,5 +15,6 @@ export const whoami = new Command("whoami")
     }
     catch (error) {
         process.stderr.write(`❌ User lookup failed\n\n${error}\n`);
+        process.exit(1);
     }
 });

package/lib/util/print-message.js

@@ -1,9 +1,10 @@
 import Blocker from "stdin-blocker";
 import Cursor from "tiny-cursor";
+import readline from "readline";
 export function printMessage(message) {
     Blocker.block();
     Cursor.hide();
-    process.stdout.cursorTo(0);
+    readline.cursorTo(process.stdout, 0);
     process.stdout.write(message);
-    process.stdout.clearLine(1);
+    readline.clearLine(process.stdout, 1);
 }

package/lib/util/spinner.js

@@ -0,0 +1,46 @@
+import chalk from "chalk";
+const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export class Spinner {
+    frameIndex = 0;
+    stopped = false;
+    interval = null;
+    message = "";
+    start(message) {
+        if (this.interval) {
+            clearInterval(this.interval);
+        }
+        this.message = message;
+        this.stopped = false;
+        this.interval = setInterval(() => {
+            if (this.stopped)
+                return;
+            const frame = frames[(this.frameIndex = ++this.frameIndex % frames.length)];
+            process.stdout.write(`\r${frame} ${this.message}`);
+        }, 80);
+        return this;
+    }
+    update(message) {
+        this.message = message;
+        return this;
+    }
+    stop(message) {
+        this.stopped = true;
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        if (message) {
+            process.stdout.write(`\r${message}    \n`);
+        }
+        return this;
+    }
+    success(message) {
+        return this.stop(`${chalk.green("✓")} ${message}`);
+    }
+    error(message) {
+        return this.stop(`${chalk.red("✖")} ${message}`);
+    }
+    warning(message) {
+        return this.stop(`${chalk.yellow("⚠")} ${message}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20250328",
+  "version": "0.0.1-experimental.20250401",
   "bin": "lib/attio.js",
   "type": "module",
   "files": [
@@ -39,8 +39,6 @@
     "@hono/node-server": "1.13.7",
     "@inquirer/prompts": "7.2.0",
     "@swc/core": "^1.3.58",
-    "@xstate/react": "4.1.1",
-    "@xstate/store": "1.0.0",
     "boxen": "^8.0.1",
     "chalk": "^5.4.1",
     "chokidar": "^3.6.0",
@@ -64,12 +62,10 @@
     "react": "18.3.1",
     "stdin-blocker": "^2.0.0",
     "tiny-cursor": "^2.0.0",
-    "tiny-spinner": "^2.0.4",
     "tmp-promise": "^3.0.3",
     "ts-morph": "^24.0.0",
     "typescript": "5.6.3",
     "uuid": "^9.0.1",
-    "xstate": "5.19.1",
     "zod": "^3.22.3",
     "zod-to-json-schema": "3.23.1",
     "zod-validation-error": "3.3.0"

package/lib/machines/actions.js

@@ -1,8 +0,0 @@
-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,123 +0,0 @@
-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 { 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";
-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 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;
-    }
-    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();
-    try {
-        spinner.start("Loading versions...");
-        const versions = await fetchVersionsApi({
-            token,
-            appId: appInfo.app_id,
-        });
-        spinner.success("Versions loaded");
-        return versions;
-    }
-    catch (error) {
-        spinner.error("Error loading versions");
-        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));
-export const askWithTypedChoices = () => fromPromise(async ({ input, }) => await selectPrompt(input));
-export const confirm = fromPromise(async ({ input }) => await confirmPrompt(input));
-export const fromCallbackWithErrorHandling = (callback) => fromCallback((...args) => {
-    try {
-        return callback(...args);
-    }
-    catch (error) {
-        args[0].sendBack({
-            type: "Error",
-            error: typeof error === "string" ? new Error(error) : error,
-        });
-    }
-});
-export async function determineWorkspace({ 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;
-        }
-        if (workspaces.length === 0) {
-            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/build-machine.js

@@ -1,192 +0,0 @@
-import { assign, setup } from "xstate";
-import Spinner from "tiny-spinner";
-import { codeGenMachine } from "./code-gen-machine.js";
-import { jsMachine } from "./js-machine.js";
-import { tsMachine } from "./ts-machine.js";
-import { printJsError, printTsError } from "../util/typescript.js";
-import { printLogo } from "./actions.js";
-const processes = ["javascript", "typescript"];
-const spinner = new Spinner();
-export const buildMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        children: {},
-    },
-    actors: {
-        "typescript": tsMachine,
-        "javascript": jsMachine,
-        "code-gen": codeGenMachine,
-    },
-    guards: {
-        "all done": ({ context }) => context.failed.length + context.successful.length === processes.length,
-        "all success": ({ context }) => context.successful.length === processes.length,
-    },
-    actions: {
-        buildingStart: () => {
-            spinner.start("🔨 Building...");
-        },
-        buildFail: ({ context }) => {
-            spinner.error("Build failed");
-            const { tsErrors = [], jsErrors } = context;
-            process.stderr.write("\n");
-            tsErrors.forEach(printTsError);
-            jsErrors?.errors?.forEach((error) => {
-                printJsError(error, "error");
-            });
-            jsErrors?.warnings?.forEach((warning) => {
-                printJsError(warning, "warning");
-            });
-        },
-        buildSuccess: () => {
-            spinner.success("Build succeeded");
-        },
-        printLogo,
-        setFailed: assign({
-            failed: ({ context }, params) => [...context.failed, params.process],
-        }),
-        setTypeScriptErrors: assign({
-            tsErrors: (_, params) => params.errors,
-        }),
-        setJavaScriptErrors: assign({
-            jsErrors: (_, params) => params.errors,
-        }),
-        setSuccess: assign({
-            successful: ({ context }, params) => [
-                ...context.successful,
-                params.process,
-            ],
-        }),
-    },
-}).createMachine({
-    context: { successful: [], failed: [] },
-    id: "Build Machine",
-    states: {
-        "Errored": {
-            type: "final",
-            entry: "buildFail",
-        },
-        "Success": {
-            type: "final",
-            entry: "buildSuccess",
-        },
-        "Building": {
-            type: "parallel",
-            states: {
-                JavaScript: {
-                    states: {
-                        Building: {
-                            on: {
-                                "JavaScript Success": {
-                                    target: "Waiting",
-                                    actions: {
-                                        type: "setSuccess",
-                                        params: { process: "javascript" },
-                                    },
-                                },
-                                "JavaScript Error": {
-                                    target: "Waiting",
-                                    actions: [
-                                        {
-                                            type: "setFailed",
-                                            params: { process: "javascript" },
-                                        },
-                                        {
-                                            type: "setJavaScriptErrors",
-                                            params: ({ event }) => event,
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                        Waiting: {
-                            always: {
-                                target: "#Build Machine.All Done",
-                                guard: "all done",
-                            },
-                        },
-                    },
-                    initial: "Building",
-                    invoke: {
-                        src: "javascript",
-                        id: "javascript",
-                        input: ({ self }) => ({ parentRef: self, write: true }),
-                    },
-                },
-                TypeScript: {
-                    states: {
-                        "Validating": {
-                            on: {
-                                "TypeScript Success": {
-                                    target: "Waiting",
-                                    actions: {
-                                        type: "setSuccess",
-                                        params: { process: "typescript" },
-                                    },
-                                },
-                                "TypeScript Error": {
-                                    target: "Waiting",
-                                    actions: [
-                                        {
-                                            type: "setFailed",
-                                            params: { process: "typescript" },
-                                        },
-                                        {
-                                            type: "setTypeScriptErrors",
-                                            params: ({ event }) => event,
-                                        },
-                                    ],
-                                },
-                            },
-                            invoke: {
-                                src: "typescript",
-                                id: "typescript",
-                                input: ({ self }) => ({ parentRef: self }),
-                            },
-                        },
-                        "Waiting": {
-                            always: {
-                                target: "#Build Machine.All Done",
-                                guard: "all done",
-                            },
-                        },
-                        "Code Generating": {
-                            on: {
-                                "Code Generation Done": "Validating",
-                                "Error": {
-                                    target: "Waiting",
-                                    actions: {
-                                        type: "setFailed",
-                                        params: { process: "typescript" },
-                                    },
-                                    reenter: true,
-                                },
-                            },
-                            invoke: {
-                                src: "code-gen",
-                                id: "code-gen",
-                                input: ({ self }) => ({ parentRef: self }),
-                            },
-                        },
-                    },
-                    initial: "Code Generating",
-                },
-            },
-            entry: "buildingStart",
-        },
-        "All Done": {
-            always: [
-                {
-                    target: "Success",
-                    guard: "all success",
-                },
-                {
-                    target: "Errored",
-                    reenter: true,
-                },
-            ],
-        },
-    },
-    initial: "Building",
-    entry: "printLogo",
-});

package/lib/machines/build-orchestrator.js

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

package/lib/machines/code-gen-machine.js

@@ -1,97 +0,0 @@
-import { readFileSync } from "fs";
-import { parse } from "graphql";
-import { sendTo, assign, setup, fromCallback } from "xstate";
-import { generateOperations } from "../graphql/generate-operations.js";
-import { findNodeModulesPath } from "../util/find-node-modules-path.js";
-export const codeGenMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        input: {},
-    },
-    actors: {
-        loadSchema: fromCallback(({ sendBack }) => {
-            const loadSchema = async () => {
-                try {
-                    const path = await findNodeModulesPath(["schema.graphql"]);
-                    if (!path) {
-                        sendBack({ type: "Error", error: new Error("No schema found") });
-                        return;
-                    }
-                    const schema = parse(readFileSync(path, "utf8"));
-                    sendBack({ type: "Schema Loaded", schema });
-                }
-                catch (error) {
-                    sendBack({ type: "Error", error });
-                }
-            };
-            loadSchema();
-        }),
-        generateOperations: fromCallback(({ sendBack, input }) => {
-            generateOperations(".", input.schema)
-                .then(() => sendBack({ type: "Done" }))
-                .catch((error) => sendBack({ type: "Error", error }));
-        }),
-    },
-    actions: {
-        clearError: assign({
-            error: () => undefined,
-        }),
-        setError: assign({
-            error: (_, params) => params.error,
-        }),
-        setSchema: assign({
-            schema: (_, params) => params.schema,
-        }),
-        raiseDone: sendTo(({ context }) => context.parentRef, { type: "Code Generation Done" }),
-    },
-}).createMachine({
-    id: "GraphQL Code Generation Machine",
-    context: ({ input }) => ({
-        schema: null,
-        parentRef: input.parentRef,
-    }),
-    states: {
-        "Load Schema": {
-            on: {
-                "Error": {
-                    target: "Errored",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-                "Schema Loaded": {
-                    target: "Generating Operations",
-                    actions: { type: "setSchema", params: ({ event }) => event },
-                    reenter: true,
-                },
-            },
-            invoke: {
-                src: "loadSchema",
-            },
-        },
-        "Done": {
-            entry: "raiseDone",
-        },
-        "Errored": {},
-        "Generating Operations": {
-            on: {
-                Done: {
-                    target: "Done",
-                    actions: "clearError",
-                },
-                Error: {
-                    target: "Errored",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-            },
-            invoke: {
-                src: "generateOperations",
-                input: ({ context }) => ({ schema: context.schema }),
-            },
-        },
-    },
-    initial: "Load Schema",
-    on: {
-        Change: ".Load Schema",
-    },
-    description: `Generates operations typescript types`,
-});