attio 0.0.1-experimental.20250326 → 0.0.1-experimental.20250327

package/lib/api/auth.js

@@ -47,7 +47,12 @@ export async function auth() {
     const state = randomBytes(32).toString("base64url");
     const port = await findAvailablePort(3000, 65000);
     const redirectUri = `http://localhost:${port}`;
-    const { promise: tokenPromise, resolve: resolveToken, reject: rejectToken, } = Promise.withResolvers();
+    let resolveToken;
+    let rejectToken;
+    const tokenPromise = new Promise((resolve, reject) => {
+        resolveToken = resolve;
+        rejectToken = reject;
+    });
     const app = new Hono();
     let serverRef;
     app.get("/", async (c) => {

package/lib/commands/dev/boot.js

@@ -0,0 +1,29 @@
+import { ensureAuthed } from "../../api/ensure-authed.js";
+import { loadEnv } from "../../util/load-env.js";
+import { determineWorkspace } from "../../machines/actors.js";
+import { fetchAppInfo } from "../../machines/actors.js";
+import { getAppSlugFromPackageJson } from "../../machines/actors.js";
+import { loadAttioCliPackageJson } from "../../util/load-attio-cli-package-json.js";
+import { createDevVersion } from "../../api/create-dev-version.js";
+export async function boot({ workspaceSlug }) {
+    const token = await ensureAuthed();
+    const appSlug = await getAppSlugFromPackageJson();
+    const appInfo = await fetchAppInfo({ token, appSlug });
+    const workspace = await determineWorkspace({ token, workspaceSlug });
+    const environmentVariables = await loadEnv();
+    const packageJson = loadAttioCliPackageJson();
+    const devVersion = await createDevVersion({
+        token,
+        appId: appInfo.app_id,
+        targetWorkspaceId: workspace.workspace_id,
+        environmentVariables,
+        cliVersion: packageJson.version,
+    });
+    return {
+        token,
+        appId: appInfo.app_id,
+        appSlug,
+        devVersionId: devVersion.app_dev_version_id,
+        workspace,
+    };
+}

package/lib/commands/dev/build-javascript.js

@@ -0,0 +1,49 @@
+import chokidar from "chokidar";
+import notifier from "node-notifier";
+import { clearTerminal } from "../../util/clear-terminal.js";
+import { errorsAndWarningsSchema } from "../../build.js";
+import { prepareBuildContexts } from "./prepare-build-contexts.js";
+import { printJsError } from "../../util/typescript.js";
+const notify = (errors) => {
+    const totalErrors = (errors.errors?.length || 0) + (errors.warnings?.length || 0);
+    notifier.notify({
+        title: `JavaScript ${totalErrors === 1 ? "Error" : "Errors"}`,
+        message: `There ${totalErrors === 1 ? "was one error" : `were ${totalErrors} errors`} in your JavaScript code`,
+    });
+};
+export function buildJavaScript(onSuccess) {
+    const watcher = chokidar.watch(["src/**/*.{js,jsx,ts,tsx}"], {
+        ignored: ["**/node_modules/**", "**/dist/**", "**/*.graphql.d.ts", "**/*.gql.d.ts"],
+        cwd: ".",
+    });
+    let buildContexts;
+    async function handleBuild() {
+        try {
+            if (!buildContexts) {
+                buildContexts = await prepareBuildContexts();
+            }
+            const results = await Promise.all(buildContexts.map(async (context) => context.rebuild()));
+            const bundles = results.map((result) => result.outputFiles[0].text);
+            onSuccess?.(bundles);
+        }
+        catch (error) {
+            const errors = errorsAndWarningsSchema.parse(error);
+            clearTerminal();
+            errors.errors?.forEach((error) => printJsError(error, "error"));
+            errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
+            notify(errors);
+        }
+    }
+    watcher.on("ready", () => {
+        handleBuild();
+        watcher.on("all", (event, path) => {
+            if (event === "add" || event === "change" || event === "unlink") {
+                handleBuild();
+            }
+        });
+    });
+    return async () => {
+        await Promise.all(buildContexts?.map(async (context) => context.dispose()) ?? []);
+        await watcher.close();
+    };
+}

package/lib/commands/dev/bundle-javascript.js

@@ -0,0 +1,49 @@
+import chokidar from "chokidar";
+import notifier from "node-notifier";
+import { clearTerminal } from "../../util/clear-terminal.js";
+import { errorsAndWarningsSchema } from "../../build.js";
+import { prepareBuildContexts } from "./prepare-build-contexts.js";
+import { printJsError } from "../../util/typescript.js";
+const notify = (errors) => {
+    const totalErrors = (errors.errors?.length || 0) + (errors.warnings?.length || 0);
+    notifier.notify({
+        title: `JavaScript ${totalErrors === 1 ? "Error" : "Errors"}`,
+        message: `There ${totalErrors === 1 ? "was one error" : `were ${totalErrors} errors`} in your JavaScript code`,
+    });
+};
+export function bundleJavaScript(onSuccess) {
+    const watcher = chokidar.watch(["./src/**/*.{js,jsx,ts,tsx}"], {
+        ignored: ["**/node_modules/**", "**/dist/**", "**/*.graphql.d.ts", "**/*.gql.d.ts"],
+        cwd: process.cwd(),
+    });
+    let buildContexts;
+    async function handleBuild() {
+        try {
+            if (!buildContexts) {
+                buildContexts = await prepareBuildContexts();
+            }
+            const results = await Promise.all(buildContexts.map(async (context) => context.rebuild()));
+            const bundles = results.map((result) => result.outputFiles[0].text);
+            onSuccess?.(bundles);
+        }
+        catch (error) {
+            const errors = errorsAndWarningsSchema.parse(error);
+            clearTerminal();
+            errors.errors?.forEach((error) => printJsError(error, "error"));
+            errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
+            notify(errors);
+        }
+    }
+    watcher.on("ready", () => {
+        handleBuild();
+        watcher.on("all", (event) => {
+            if (event === "add" || event === "change" || event === "unlink") {
+                handleBuild();
+            }
+        });
+    });
+    return async () => {
+        await Promise.all(buildContexts?.map(async (context) => context.dispose()) ?? []);
+        await watcher.close();
+    };
+}

package/lib/commands/dev/graphql-code-gen.js

@@ -0,0 +1,42 @@
+import chokidar from "chokidar";
+import { readFileSync } from "fs";
+import { parse } from "graphql";
+import { findNodeModulesPath } from "../../util/find-node-modules-path.js";
+import { generateOperations } from "../../graphql/generate-operations.js";
+import { GraphQLError } from "../../graphql/graphql-error.js";
+export function graphqlCodeGen(onSuccess) {
+    const watcher = chokidar.watch(["**/*.graphql", "**/*.gql"], {
+        ignored: ["**/node_modules/**", "**/dist/**"],
+        cwd: ".",
+    });
+    async function handleSchemaAndGenerate() {
+        try {
+            const schemaPath = await findNodeModulesPath(["schema.graphql"]);
+            if (!schemaPath) {
+                throw new Error("No schema.graphql found in node_modules");
+            }
+            const schema = parse(readFileSync(schemaPath, "utf8"));
+            await generateOperations(".", schema);
+            onSuccess?.();
+        }
+        catch (error) {
+            if (error instanceof GraphQLError) {
+                process.stderr.write(error.toString());
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    watcher.on("ready", () => {
+        handleSchemaAndGenerate();
+        watcher.on("all", (event, path) => {
+            if (event === "add" || event === "change" || event === "unlink") {
+                handleSchemaAndGenerate();
+            }
+        });
+    });
+    return () => {
+        watcher.close();
+    };
+}

package/lib/commands/dev/graphql-server.js

@@ -0,0 +1,66 @@
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import path from "path";
+import fs from "fs";
+import { buildSchema } from "graphql";
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { graphqlServer as graphqlServerMiddleware } from "@hono/graphql-server";
+import { findAvailablePort } from "../../util/find-available-port.js";
+import open from "open";
+import { listenForKey } from "../../util/listen-for-key.js";
+export function graphqlServer() {
+    let server = null;
+    let port;
+    let isShuttingDown = false;
+    const startServer = async () => {
+        if (isShuttingDown)
+            return;
+        try {
+            const currentFilePath = fileURLToPath(import.meta.url);
+            const currentDirPath = dirname(currentFilePath);
+            const schemaPath = path.resolve(currentDirPath, "..", "..", "..", "schema.graphql");
+            const schemaString = fs.readFileSync(schemaPath, "utf8");
+            port = await findAvailablePort(8700);
+            const schema = buildSchema(schemaString);
+            const app = new Hono();
+            const rootResolver = () => {
+                return {};
+            };
+            app.use("/graphql", graphqlServerMiddleware({
+                schema,
+                rootResolver,
+                graphiql: true,
+            }));
+            server = serve({
+                fetch: app.fetch,
+                port,
+            });
+            process.stdout.write(`\n\n Press "o" to open GraphQL Explorer.\n\n`);
+        }
+        catch (error) {
+            process.stderr.write(`Failed to start GraphQL server: ${error}\n`);
+            throw error;
+        }
+    };
+    startServer().catch((error) => {
+        process.stderr.write(`GraphQL server failed to start: ${error}\n`);
+    });
+    const cleanup = listenForKey("o", () => {
+        if (port) {
+            open(`http://localhost:${port}/graphql`);
+        }
+    });
+    return () => {
+        isShuttingDown = true;
+        cleanup();
+        if (server) {
+            try {
+                server.close();
+            }
+            catch (error) {
+                process.stderr.write(`Error closing GraphQL server: ${error}\n`);
+            }
+        }
+    };
+}

package/lib/commands/dev/onboarding.js

@@ -0,0 +1,29 @@
+import { listenForKey } from "../../util/listen-for-key.js";
+import open from "open";
+import { fetchInstallation } from "../../api/fetch-installation.js";
+import { APP } from "../../env.js";
+function prompt() {
+    process.stdout.write(`\n\n🚨 IMPORTANT: You will need to install your app in your workspace. Press "i" to open the app settings page, and then click "Install".\n\n`);
+}
+export function onboarding({ token, appId, appSlug, workspace, }) {
+    const haveInstallation = async () => (await fetchInstallation({ token, appId, workspaceId: workspace.workspace_id })) !== null;
+    const cleanup = listenForKey("i", () => {
+        open(`${APP}/${workspace.slug}/settings/apps/${appSlug}`);
+    });
+    const poll = async () => {
+        let installation = await haveInstallation();
+        if (!installation) {
+            prompt();
+            while (!installation) {
+                await new Promise((resolve) => setTimeout(resolve, 60_000));
+                installation = await haveInstallation();
+                if (!installation) {
+                    prompt();
+                }
+            }
+            cleanup();
+        }
+    };
+    poll();
+    return cleanup;
+}

package/lib/commands/dev/prepare-build-contexts.js

@@ -0,0 +1,75 @@
+import * as esbuild from "esbuild";
+import tmp from "tmp-promise";
+import fs from "fs/promises";
+import path from "path";
+import { createClientBuildConfig } from "../../build/client/create-client-build-config.js";
+import { generateClientEntry } from "../../build/client/generate-client-entry.js";
+import { createServerBuildConfig } from "../../build/server/create-server-build-config.js";
+import { generateServerEntry } from "../../build/server/generate-server-entry.js";
+export async function prepareBuildContexts() {
+    const srcDir = "src";
+    const assetsDir = path.join(srcDir, "assets");
+    const webhooksDir = path.join(srcDir, "webhooks");
+    const eventsDir = path.join(srcDir, "events");
+    return Promise.all([
+        tmp.file({ postfix: ".js" }).then(async (tempFile) => {
+            let lastJS;
+            const updateTempFile = async () => {
+                const js = await generateClientEntry({
+                    srcDirAbsolute: path.resolve(srcDir),
+                    assetsDirAbsolute: path.resolve(assetsDir),
+                });
+                if (js === lastJS)
+                    return;
+                lastJS = js;
+                await fs.writeFile(tempFile.path, js);
+            };
+            const esbuildContext = await esbuild.context({
+                ...createClientBuildConfig({
+                    entryPoint: tempFile.path,
+                    srcDir,
+                }),
+                write: false,
+                outfile: path.resolve("dist", "index.js"),
+                loader: { ".png": "dataurl", ".graphql": "text", ".gql": "text" },
+            });
+            return {
+                rebuild: async () => {
+                    await updateTempFile();
+                    return esbuildContext.rebuild();
+                },
+                dispose: async () => {
+                    await Promise.all([esbuildContext.dispose(), tempFile.cleanup()]);
+                },
+            };
+        }),
+        tmp.file({ postfix: ".js" }).then(async (tempFile) => {
+            let lastJS;
+            const updateTempFile = async () => {
+                const js = await generateServerEntry({
+                    srcDirAbsolute: path.resolve(srcDir),
+                    webhooksDirAbsolute: path.resolve(webhooksDir),
+                    eventDirAbsolute: path.resolve(eventsDir),
+                });
+                if (js === lastJS)
+                    return;
+                lastJS = js;
+                await fs.writeFile(tempFile.path, js);
+            };
+            const esbuildContext = await esbuild.context({
+                ...createServerBuildConfig(tempFile.path),
+                write: false,
+                outfile: path.resolve("dist", "server.js"),
+            });
+            return {
+                rebuild: async () => {
+                    await updateTempFile();
+                    return esbuildContext.rebuild();
+                },
+                dispose: async () => {
+                    await Promise.all([esbuildContext.dispose(), tempFile.cleanup()]);
+                },
+            };
+        }),
+    ]);
+}

package/lib/commands/dev/upload.js

@@ -0,0 +1,60 @@
+import Spinner from "tiny-spinner";
+import notifier from "node-notifier";
+import { startUpload } from "../../api/start-upload.js";
+import { completeBundleUpload } from "../../api/complete-bundle-upload.js";
+export async function upload({ token, contents, devVersionId, appId, }) {
+    const spinner = new Spinner();
+    try {
+        spinner.start("Uploading...");
+        const { client_bundle_upload_url, server_bundle_upload_url, app_dev_version_bundle_id: bundleId, } = await startUpload({
+            token,
+            appId,
+            devVersionId,
+        });
+        const [clientBundle, serverBundle] = contents;
+        await Promise.all([
+            fetch(client_bundle_upload_url, {
+                method: "PUT",
+                body: clientBundle,
+                headers: {
+                    "Content-Type": "text/javascript",
+                    "Content-Length": String(Buffer.from(clientBundle).length),
+                },
+            }),
+            fetch(server_bundle_upload_url, {
+                method: "PUT",
+                body: serverBundle,
+                headers: {
+                    "Content-Type": "text/javascript",
+                    "Content-Length": String(Buffer.from(serverBundle).length),
+                },
+            }),
+        ]).catch((error) => {
+            process.stderr.write(`Upload Error: ${error}`);
+        });
+        await completeBundleUpload({
+            token,
+            appId,
+            devVersionId,
+            bundleId,
+        });
+        spinner.success(`Upload completed at ${new Date().toLocaleString()}.`);
+        notifier.notify({
+            title: "Upload Complete",
+            message: "New bundle uploaded to Attio",
+        });
+    }
+    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();
+    }
+}

package/lib/commands/dev/validate-typescript.js

@@ -0,0 +1,90 @@
+import chokidar from "chokidar";
+import notifier from "node-notifier";
+import { getDiagnostics, readConfig, typeScriptErrorSchema, } from "../../util/typescript.js";
+import { printTsError } from "../../util/typescript.js";
+import { clearTerminal } from "../../util/clear-terminal.js";
+import path from "path";
+const notify = (errors) => {
+    notifier.notify({
+        title: `TypeScript Error${errors.length === 1 ? "" : "s"}`,
+        message: `There ${errors.length === 1 ? "was one error" : `were ${errors.length} errors`} in your TypeScript code`,
+    });
+};
+export function validateTypeScript(onSuccess) {
+    let isShuttingDown = false;
+    const watcher = chokidar.watch(["src/**/*.ts", "src/**/*.tsx"], {
+        ignored: [
+            "**/node_modules/**",
+            "**/dist/**",
+            "**/*.graphql.d.ts",
+            "**/*.gql.d.ts",
+        ],
+        cwd: ".",
+        persistent: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 100,
+            pollInterval: 100,
+        },
+    });
+    async function handleValidation() {
+        if (isShuttingDown)
+            return;
+        try {
+            const program = await readConfig(path.resolve("tsconfig.json"));
+            if (program === "Not a TypeScript project") {
+                onSuccess?.();
+                return;
+            }
+            const errors = await getDiagnostics(program);
+            if (errors.length) {
+                clearTerminal();
+                errors.forEach(printTsError);
+                notify(errors);
+            }
+            else {
+                onSuccess?.();
+            }
+        }
+        catch (error) {
+            if (typeof error === "object" &&
+                error !== null &&
+                "code" in error &&
+                (error.code === "ENOENT" || error.code === "EACCES" || error.code === "EPERM")) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                const tsError = typeScriptErrorSchema.parse({ text: error.message });
+                clearTerminal();
+                printTsError(tsError);
+                notify([tsError]);
+            }
+        }
+    }
+    let watcherReady = false;
+    watcher.on("ready", () => {
+        watcherReady = true;
+        handleValidation();
+        watcher.on("all", (event, path) => {
+            if (event === "add" || event === "change" || event === "unlink") {
+                handleValidation();
+            }
+        });
+    });
+    watcher.on("error", (error) => {
+        process.stderr.write(`TypeScript watcher error: ${error}\n`);
+    });
+    return [
+        () => {
+            isShuttingDown = true;
+            if (watcherReady) {
+                try {
+                    watcher.close();
+                }
+                catch (error) {
+                    process.stderr.write(`Error closing TypeScript watcher: ${error}\n`);
+                }
+            }
+        },
+        handleValidation,
+    ];
+}

package/lib/commands/dev.js

@@ -1,26 +1,45 @@
 import { Command, Option } from "commander";
-import { createActor } from "xstate";
 import { z } from "zod";
-import { devMachine } from "../machines/dev-machine.js";
+import chalk from "chalk";
+import { boot } from "./dev/boot.js";
+import { bundleJavaScript } from "./dev/bundle-javascript.js";
+import { upload } from "./dev/upload.js";
+import { printMessage } from "../util/print-message.js";
+import { onboarding } from "./dev/onboarding.js";
+import { validateTypeScript } from "./dev/validate-typescript.js";
+import { graphqlCodeGen } from "./dev/graphql-code-gen.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, {
-        input: {
-            workspaceSlug: options.workspace,
-        },
-    });
-    if (options.dev) {
-        actor.subscribe((state) => {
-            console.log("state:", state.value);
+    .action(async (unparsedOptions) => {
+    const { workspace: workspaceSlug } = optionsSchema.parse(unparsedOptions);
+    const cleanupFunctions = [];
+    try {
+        const { token, appId, devVersionId, appSlug, workspace } = await boot({ workspaceSlug });
+        const cleanupOnboardingDaemon = onboarding({ token, appId, appSlug, workspace });
+        cleanupFunctions.push(cleanupOnboardingDaemon);
+        const [cleanupTs, triggerTs] = validateTypeScript();
+        cleanupFunctions.push(cleanupTs);
+        const cleanupGraphqlCodeGen = graphqlCodeGen(triggerTs);
+        cleanupFunctions.push(cleanupGraphqlCodeGen);
+        const cleanupJs = bundleJavaScript((contents) => {
+            upload({ token, contents, devVersionId, appId });
         });
+        cleanupFunctions.push(cleanupJs);
+        printMessage("\n👀 Watching for changes...");
+        await new Promise((resolve) => {
+            process.on("SIGINT", async () => {
+                await Promise.all(cleanupFunctions.map(async (cleanup) => cleanup()));
+                resolve(undefined);
+            });
+        });
+    }
+    catch (error) {
+        process.stderr.write(`${chalk.red("✖ " + error)}\n`);
+        process.exit(1);
     }
-    actor.start();
 });

package/lib/machines/actors.js

@@ -86,7 +86,7 @@ export const fromCallbackWithErrorHandling = (callback) => fromCallback((...args
         });
     }
 });
-export const determineWorkspace = fromPromise(async ({ input: { token, workspaceSlug } }) => {
+export async function determineWorkspace({ token, workspaceSlug, }) {
     const spinner = new Spinner();
     spinner.start("Loading workspaces...");
     try {
@@ -120,4 +120,4 @@ ${APP}/welcome/workspace-details
     finally {
         spinner.stop();
     }
-});
+}

package/lib/util/listen-for-key.js

@@ -0,0 +1,27 @@
+export function listenForKey(targetKey, onKeyPress) {
+    let cleanupFunction;
+    function handleKeyPress(data) {
+        const rawKey = data.toString();
+        const key = rawKey.trim().toLowerCase();
+        if (key === "\u0003") {
+            return;
+        }
+        if (key === targetKey.toLowerCase()) {
+            onKeyPress();
+        }
+    }
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", handleKeyPress);
+    }
+    cleanupFunction = () => {
+        if (process.stdin.isTTY) {
+            process.stdin.removeListener("data", handleKeyPress);
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        }
+    };
+    return cleanupFunction;
+}

package/lib/util/load-attio-cli-package-json.js

@@ -12,14 +12,14 @@ export function loadAttioCliPackageJson() {
     if (packageJson === undefined) {
         const packageJsonPath = findUpSync(FILE_NAME, { cwd: fileURLToPath(import.meta.url) });
         if (packageJsonPath === undefined) {
-            return "Failed to find package.json";
+            throw new Error("Failed to find package.json");
         }
         try {
             const packageJsonContent = JSON.parse(readFileSync(packageJsonPath, "utf8"));
             packageJson = packageJsonSchema.parse(packageJsonContent);
         }
         catch (error) {
-            return "Failed to find version in package.json";
+            throw new Error("Failed to find version in package.json");
         }
     }
     return packageJson;

package/lib/util/load-env.js

@@ -18,6 +18,6 @@ export async function loadEnv() {
         return dotenv.parse(contents);
     }
     catch {
-        return `Failed to parse ${PATH}`;
+        throw new Error(`Failed to parse ${PATH}`);
     }
 }

package/lib/util/print-message.js

@@ -4,6 +4,6 @@ export function printMessage(message) {
     Blocker.block();
     Cursor.hide();
     process.stdout.cursorTo(0);
-    process.stdout.write(message.trim());
+    process.stdout.write(message);
     process.stdout.clearLine(1);
 }

package/package.json

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

package/lib/machines/dev-machine.js

@@ -1,619 +0,0 @@
-import chokidar from "chokidar";
-import open from "open";
-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 notifier from "node-notifier";
-import { loadEnv } from "../util/load-env.js";
-import { loadAttioCliPackageJson } from "../util/load-attio-cli-package-json.js";
-import { codeGenMachine } from "./code-gen-machine.js";
-import { envMachine } from "./env-machine.js";
-import { jsMachine } from "./js-machine.js";
-import { tsMachine } from "./ts-machine.js";
-import { fetchInstallation } from "../api/fetch-installation.js";
-import Spinner from "tiny-spinner";
-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 { 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");
-    process.exit();
-});
-process.on("exit", () => {
-    process.stdout.write("\x1B[?25h");
-});
-export const devMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        input: {},
-        children: {},
-    },
-    actors: {
-        "javascript": jsMachine,
-        "typescript": tsMachine,
-        "env": envMachine,
-        "code-gen": codeGenMachine,
-        "askForWorkspace": askWithTypedChoices(),
-        authenticate,
-        loadAppSlug,
-        loadAppInfo,
-        "keyboard": fromCallbackWithErrorHandling(({ sendBack }) => {
-            if (!process.stdin.isTTY)
-                return;
-            const originalIsRaw = process.stdin.isRaw;
-            const originalIsTTY = process.stdin.isTTY;
-            const ensureRawMode = () => {
-                if (process.stdin.isTTY) {
-                    process.stdin.setRawMode(true);
-                }
-            };
-            const handleData = (data) => {
-                ensureRawMode();
-                const str = data.toString();
-                if (str === "\u0003") {
-                    process.stdout.write("\x1B[?25h");
-                    process.stdin.setRawMode(originalIsRaw);
-                    process.exit();
-                }
-                switch (str) {
-                    case "o":
-                        sendBack({ type: "Open GraphQL Explorer" });
-                        break;
-                    case "i":
-                        sendBack({ type: "Install Opened" });
-                        break;
-                }
-            };
-            process.stdin.setRawMode(true);
-            process.stdin.resume();
-            process.stdin.on("data", handleData);
-            process.stdin.on("focus", ensureRawMode);
-            process.stdout.on("focus", ensureRawMode);
-            process.on("focus", ensureRawMode);
-            return () => {
-                process.stdin.removeListener("data", handleData);
-                process.stdin.removeListener("focus", ensureRawMode);
-                process.stdout.removeListener("focus", ensureRawMode);
-                process.removeListener("focus", ensureRawMode);
-                process.stdin.setRawMode(originalIsRaw);
-                if (originalIsTTY) {
-                    process.stdin.pause();
-                }
-            };
-        }),
-        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.workspace_id,
-                environmentVariables,
-                cliVersion: packageJson.version,
-            });
-            return devVersion;
-        }),
-        "upload": fromPromise(async ({ input: { token, contents, devVersion: { app_dev_version_id: devVersionId }, appInfo: { app_id: appId }, }, }) => {
-            const spinner = new Spinner();
-            try {
-                spinner.start("Uploading...");
-                const { client_bundle_upload_url, server_bundle_upload_url, app_dev_version_bundle_id: bundleId, } = await startUpload({
-                    token,
-                    appId,
-                    devVersionId,
-                });
-                const [clientBundle, serverBundle] = contents;
-                await Promise.all([
-                    fetch(client_bundle_upload_url, {
-                        method: "PUT",
-                        body: clientBundle,
-                        headers: {
-                            "Content-Type": "text/javascript",
-                            "Content-Length": String(Buffer.from(clientBundle).length),
-                        },
-                    }),
-                    fetch(server_bundle_upload_url, {
-                        method: "PUT",
-                        body: serverBundle,
-                        headers: {
-                            "Content-Type": "text/javascript",
-                            "Content-Length": String(Buffer.from(serverBundle).length),
-                        },
-                    }),
-                ]).catch((error) => {
-                    process.stderr.write(`Upload Error: ${error}`);
-                });
-                await completeBundleUpload({
-                    token,
-                    appId,
-                    devVersionId,
-                    bundleId,
-                });
-                spinner.success(`Upload completed at ${new Date().toLocaleString()}.`);
-                notifier.notify({
-                    title: "Upload Complete",
-                    message: "New bundle uploaded to Attio",
-                });
-            }
-            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"], {
-                ignored: "**/*.graphql.d.ts",
-            });
-            watcher.on("ready", () => watcher.on("all", () => {
-                sendBack({ type: "Change" });
-            }));
-            return () => {
-                watcher.close();
-            };
-        }),
-        "graphql": fromCallbackWithErrorHandling(({ sendBack }) => startGraphqlServer(sendBack)),
-        "loadInstallation": fromCallbackWithErrorHandling(({ sendBack, input: { token, appInfo, workspace } }) => {
-            fetchInstallation({
-                token,
-                appId: appInfo.app_id,
-                workspaceId: workspace.workspace_id,
-            }).then((installation) => {
-                if (installation) {
-                    sendBack({ type: "Found Installation" });
-                }
-                else {
-                    sendBack({ type: "No Installation" });
-                }
-            });
-        }),
-        "pollForInstallation": fromCallbackWithErrorHandling(({ sendBack, input: { token, appInfo, workspace } }) => {
-            const interval = setInterval(() => {
-                fetchInstallation({
-                    token,
-                    appId: appInfo.app_id,
-                    workspaceId: workspace.workspace_id,
-                }).then((installation) => {
-                    if (installation) {
-                        sendBack({ type: "Found Installation" });
-                    }
-                });
-            }, 2_000);
-            return () => clearInterval(interval);
-        }),
-    },
-    actions: {
-        clearUploadError: assign({ uploadError: undefined }),
-        showActorError,
-        printAuthError: (_, params) => {
-            process.stderr.write(`${params.error.message}\n\n`);
-        },
-        printError: (_, params) => {
-            printMessage(params.error);
-        },
-        printLogo: (_) => {
-            process.stdout.write("\x1B[?25l");
-            printLogo();
-        },
-        printWatching: (_) => {
-            printMessage("👀 Watching for changes...");
-        },
-        printTypeScriptErrors: (_, params) => {
-            if (params.errors.length) {
-                clearTerminal();
-                params.errors.forEach(printTsError);
-                notifier.notify({
-                    title: "TypeScript Errors",
-                    message: `There ${params.errors.length === 1 ? "was one error" : `were ${params.errors.length} errors`} in your TypeScript code`,
-                });
-            }
-        },
-        printJavaScriptErrors: (_, params) => {
-            if (params.errors.errors?.length || params.errors.warnings?.length) {
-                clearTerminal();
-                params.errors.errors?.forEach((error) => {
-                    printJsError(error, "error");
-                });
-                params.errors.warnings?.forEach((warning) => {
-                    printJsError(warning, "warning");
-                });
-            }
-        },
-        promptToInstall: (_) => {
-            process.stdout.write(`\n\n🚨 IMPORTANT: You will need to install your app in your workspace. Press "i" to open the app settings page, and then click "Install".\n\n`);
-        },
-        promptToOpenGraphQLExplorer: (_) => {
-            process.stdout.write(`\n\n Press "o" to open GraphQL Explorer.\n\n`);
-        },
-        openGraphQLExplorer: ({ context }) => {
-            open(`http://localhost:${context.graphqlPort}/graphql`);
-        },
-        openInstallPage: ({ context }) => {
-            open(`${APP}/${context.workspace.slug}/settings/apps/${context.appSlug}`);
-        },
-        saveTypeScriptErrors: assign({
-            typeScriptErrors: (_, params) => params.errors,
-        }),
-        saveJavaScriptErrors: assign({
-            javaScriptErrors: (_, params) => params.errors,
-        }),
-        clearTypeScriptErrors: assign({
-            typeScriptErrors: () => [],
-        }),
-        clearJavaScriptErrors: assign({
-            javaScriptErrors: () => undefined,
-        }),
-        sendChange: enqueueActions(({ enqueue, event }) => {
-            enqueue.sendTo("javascript", event);
-            enqueue.sendTo("typescript", event);
-            enqueue.sendTo("env", event);
-            enqueue.sendTo("code-gen", event);
-        }),
-        sendCodeGenerationDone: enqueueActions(({ enqueue }) => {
-            enqueue.sendTo("typescript", { type: "Change" });
-        }),
-        setToken: assign({
-            token: (_, params) => params.output,
-        }),
-        setAppInfo: assign({
-            appInfo: (_, params) => params.output,
-        }),
-        setAppSlug: assign({
-            appSlug: (_, params) => params.output,
-        }),
-        setWorkspace: assign({
-            workspace: (_, params) => params.output,
-        }),
-        setGraphqlPort: assign({
-            graphqlPort: (_, params) => params.port,
-        }),
-        setTerminalTitle: (_, params) => {
-            setTerminalTitle(params.devVersion?.app_id ? `attio dev – ${params.devVersion.app_id}` : `attio dev`);
-        },
-        setDevVersion: assign({
-            devVersion: (_, params) => params.output,
-        }),
-        setSuccess: assign({
-            jsContents: (_, params) => params.contents,
-            lastSuccessfulJavaScriptBuild: (_, params) => params.time,
-        }),
-        setUploadError: assign({
-            uploadError: (_, params) => params.error,
-        }),
-    },
-}).createMachine({
-    context: ({ input }) => ({
-        jsContents: ["", ""],
-        appSlug: "",
-        token: "",
-        appInfo: { app_id: "", title: "" },
-        ...input,
-    }),
-    id: "Dev Machine",
-    initial: "Authenticate",
-    states: {
-        "Watching": {
-            invoke: [
-                {
-                    src: "javascript",
-                    id: "javascript",
-                    input: ({ self }) => ({ parentRef: self, write: false }),
-                },
-                {
-                    src: "typescript",
-                    id: "typescript",
-                    input: ({ self }) => ({ parentRef: self }),
-                },
-                {
-                    src: "env",
-                    id: "env",
-                    input: ({ self }) => ({ parentRef: self }),
-                },
-                {
-                    src: "code-gen",
-                    id: "code-gen",
-                    input: ({ self }) => ({ parentRef: self }),
-                },
-                { src: "watch" },
-                {
-                    src: "keyboard",
-                },
-            ],
-            states: {
-                JavaScript: {
-                    states: {
-                        "Building": {
-                            on: {
-                                "JavaScript Success": {
-                                    target: "Upload When Ready",
-                                    actions: [
-                                        {
-                                            type: "setSuccess",
-                                            params: ({ event }) => event,
-                                        },
-                                        "clearJavaScriptErrors",
-                                    ],
-                                },
-                                "JavaScript Error": {
-                                    target: "Watching",
-                                    actions: [
-                                        {
-                                            type: "saveJavaScriptErrors",
-                                            params: ({ event }) => event,
-                                        },
-                                        {
-                                            type: "printJavaScriptErrors",
-                                            params: ({ event }) => event,
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                        "Watching": {
-                            entry: "printWatching",
-                        },
-                        "Uploading": {
-                            invoke: {
-                                src: "upload",
-                                input: ({ context }) => {
-                                    return {
-                                        devVersion: context.devVersion,
-                                        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: "Uploading",
-                                guard: ({ context }) => Boolean(context.devVersion),
-                            },
-                        },
-                    },
-                    initial: "Building",
-                    on: {
-                        "Change": {
-                            target: "JavaScript",
-                            actions: "sendChange",
-                        },
-                        "Auth Error": {
-                            target: "#Dev Machine.Auth Error",
-                            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 },
-                            ],
-                        },
-                        onError: {
-                            target: "#Dev Machine.Error",
-                            actions: { type: "showActorError", params: ({ event }) => event },
-                        },
-                    },
-                },
-                TypeScript: {
-                    states: {
-                        Validating: {
-                            on: {
-                                "TypeScript Success": {
-                                    target: "Watching",
-                                    actions: "clearTypeScriptErrors",
-                                },
-                                "TypeScript Error": {
-                                    target: "Watching",
-                                    actions: [
-                                        {
-                                            type: "printTypeScriptErrors",
-                                            params: ({ event }) => event,
-                                        },
-                                        { type: "saveTypeScriptErrors", params: ({ event }) => event },
-                                    ],
-                                },
-                            },
-                        },
-                        Watching: {},
-                    },
-                    initial: "Validating",
-                    on: {
-                        "Change": {
-                            target: "TypeScript",
-                            actions: "sendChange",
-                        },
-                        "Code Generation Done": {
-                            target: "TypeScript",
-                            description: `Re-enter TypeScript build when code generation is complete`,
-                            actions: "sendCodeGenerationDone",
-                        },
-                    },
-                },
-                Graphql: {
-                    invoke: {
-                        src: "graphql",
-                    },
-                    states: {
-                        "Not Started": {
-                            on: {
-                                "GraphQL Server Started": {
-                                    target: "Started",
-                                    actions: {
-                                        type: "setGraphqlPort",
-                                        params: ({ event }) => event,
-                                    },
-                                },
-                            },
-                        },
-                        "Started": {
-                            on: {
-                                "Open GraphQL Explorer": {
-                                    target: "Started",
-                                    actions: "openGraphQLExplorer",
-                                },
-                            },
-                        },
-                    },
-                    initial: "Not Started",
-                },
-                Onboarding: {
-                    states: {
-                        "Looking for Installations": {
-                            invoke: {
-                                src: "loadInstallation",
-                                input: ({ context }) => ({
-                                    appInfo: context.appInfo,
-                                    token: context.token,
-                                    devVersion: context.devVersion,
-                                    workspace: context.workspace,
-                                }),
-                            },
-                            on: {
-                                "Found Installation": "Done",
-                                "No Installation": "Prompt to Install",
-                            },
-                        },
-                        "Done": {
-                            type: "final",
-                        },
-                        "Prompt to Install": {
-                            entry: "promptToInstall",
-                        },
-                        "Poll For Installation": {
-                            invoke: {
-                                src: "pollForInstallation",
-                                input: ({ context }) => ({
-                                    appInfo: context.appInfo,
-                                    token: context.token,
-                                    devVersion: context.devVersion,
-                                    workspace: context.workspace,
-                                }),
-                            },
-                            on: {
-                                "Found Installation": "Done",
-                            },
-                            after: {
-                                "60000": "Prompt to Install",
-                            },
-                        },
-                    },
-                    initial: "Looking for Installations",
-                    on: {
-                        "Install Opened": {
-                            target: ".Poll For Installation",
-                            actions: "openInstallPage",
-                        },
-                    },
-                },
-            },
-            type: "parallel",
-            entry: "promptToOpenGraphQLExplorer",
-        },
-        "Authenticate": {
-            invoke: {
-                src: "authenticate",
-                onDone: {
-                    target: "Loading App Slug",
-                    actions: { type: "setToken", params: ({ event }) => event },
-                },
-                onError: {
-                    target: "Error",
-                    actions: {
-                        type: "showActorError",
-                        params: ({ event }) => event,
-                    },
-                },
-            },
-        },
-        "Auth Error": {
-            type: "final",
-        },
-        "Loading App Info": {
-            invoke: {
-                src: "loadAppInfo",
-                input: ({ context }) => context,
-                onDone: {
-                    target: "Determine Workspace",
-                    actions: { type: "setAppInfo", 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 },
-                },
-                onError: {
-                    target: "Error",
-                    actions: { type: "showActorError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Error": {
-            type: "final",
-        },
-        "Determine Workspace": {
-            invoke: {
-                src: "determineWorkspace",
-                input: ({ context }) => context,
-                onDone: {
-                    target: "Watching",
-                    actions: [
-                        {
-                            type: "setWorkspace",
-                            params: ({ event }) => event,
-                        },
-                    ],
-                },
-                onError: {
-                    target: "Error",
-                    actions: { type: "showActorError", params: ({ event }) => event },
-                },
-            },
-        },
-    },
-    entry: "printLogo",
-});