attio 0.0.1-experimental.20250328.1 → 0.0.1-experimental.20250401

package/lib/api/determine-workspace.spinner.js

@@ -0,0 +1,39 @@
+import { select } from "@inquirer/prompts";
+import { fetchWorkspaces } from "./fetch-workspaces.js";
+import { APP } from "../env.js";
+import { Spinner } from "../util/spinner.js";
+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 select({
+            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/api/{get-app-info.js → fetch-app-info.js}

@@ -11,7 +11,7 @@ const appSchema = z.object({
     })
         .nullable(),
 });
-export async function getAppInfo({ token, appSlug, }) {
+export async function fetchAppInfo({ token, appSlug, }) {
     if (isTest) {
         return {
             app_id: "test-id",

package/lib/api/fetch-workspaces.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { API } from "../env.js";
 import { handleError } from "./handle-error.js";
 import { makeHeaders } from "./make-headers.js";
+const isTest = process.env.NODE_ENV === "test";
 const workspaceResponseSchema = z.object({
     workspace_id: z.string().uuid(),
     slug: z.string(),
@@ -13,6 +14,16 @@ const listDevWorkspacesResponseSchema = z.object({
     accurate_at: z.string().datetime(),
 });
 export async function fetchWorkspaces({ token }) {
+    if (isTest) {
+        return [
+            {
+                workspace_id: "test-id",
+                slug: "test-slug",
+                name: "Test Workspace",
+                logo_url: null,
+            },
+        ];
+    }
     const response = await fetch(`${API}/dev-workspaces`, {
         method: "GET",
         headers: makeHeaders(token),

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

@@ -0,0 +1,18 @@
+import { fetchAppInfo } from "./fetch-app-info.js";
+import { Spinner } from "../util/spinner.js";
+export async function getAppInfo({ token, appSlug, }) {
+    const spinner = new Spinner();
+    spinner.start("Loading app information...");
+    try {
+        const appInfo = await fetchAppInfo({ 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();
+    }
+}

package/lib/api/get-app-slug-from-package-json.js

@@ -0,0 +1,26 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+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 async function getAppSlugFromPackageJson() {
+    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");
+    }
+}

package/lib/api/get-versions.spinner.js

@@ -0,0 +1,21 @@
+import { fetchVersions } from "./fetch-versions.js";
+import { Spinner } from "../util/spinner.js";
+export async function getVersions({ token, appInfo, }) {
+    const spinner = new Spinner();
+    try {
+        spinner.start("Loading versions...");
+        const versions = await fetchVersions({
+            token,
+            appId: appInfo.app_id,
+        });
+        spinner.success("Versions loaded");
+        return versions;
+    }
+    catch (error) {
+        spinner.error("Error loading versions");
+        throw error;
+    }
+    finally {
+        spinner.stop();
+    }
+}

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

@@ -0,0 +1,24 @@
+import { clearTerminal } from "../../util/clear-terminal.js";
+import { prepareBuildContexts } from "../dev/prepare-build-contexts.js";
+import { printJsError } from "../../util/typescript.js";
+import { errorsAndWarningsSchema } from "../../build.js";
+export async function buildJavaScript() {
+    let buildContexts;
+    try {
+        buildContexts = await prepareBuildContexts("write-to-disk");
+        await Promise.all(buildContexts.map(async (context) => context.rebuild()));
+        return true;
+    }
+    catch (error) {
+        const errors = errorsAndWarningsSchema.parse(error);
+        clearTerminal();
+        errors.errors?.forEach((error) => printJsError(error, "error"));
+        errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
+        return false;
+    }
+    finally {
+        if (buildContexts) {
+            await Promise.all(buildContexts.map(async (context) => context.dispose()));
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+import path from "path";
+import { getDiagnostics, readConfig, typeScriptErrorSchema, printTsError, } from "../../util/typescript.js";
+export async function validateTypeScript() {
+    try {
+        const program = await readConfig(path.resolve("tsconfig.json"));
+        if (program === "Not a TypeScript project") {
+            return true;
+        }
+        const errors = await getDiagnostics(program);
+        if (errors.length) {
+            errors.forEach(printTsError);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            const tsError = typeScriptErrorSchema.parse({ text: error.message });
+            printTsError(tsError);
+            return false;
+        }
+        if (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            (error.code === "ENOENT" || error.code === "EACCES" || error.code === "EPERM")) {
+            throw error;
+        }
+        return false;
+    }
+}

package/lib/commands/build.js

@@ -1,20 +1,36 @@
-import { Command, Option } from "commander";
-import { createActor } from "xstate";
-import { z } from "zod";
-import { buildMachine } from "../machines/build-machine.js";
-export const optionsSchema = z.object({
-    dev: z.boolean().default(false),
-});
+import { Command } from "commander";
+import { validateTypeScript } from "./build/validate-typescript.js";
+import { buildJavaScript } from "./build/build-javascript.js";
+import { Spinner } from "../util/spinner.js";
 export const build = new Command("build")
     .description("Build your Attio extension locally")
-    .addOption(new Option("--dev", "Run in development mode (additional debugging info)"))
-    .action((unparsedOptions) => {
-    const options = optionsSchema.parse(unparsedOptions);
-    const actor = createActor(buildMachine);
-    if (options.dev) {
-        actor.subscribe((state) => {
-            console.log("state:", state.value);
-        });
+    .action(async (unparsedOptions) => {
+    const spinner = new Spinner();
+    spinner.start("Validating TypeScript...");
+    try {
+        const tsValid = await validateTypeScript();
+        if (!tsValid) {
+            spinner.error("TypeScript validation failed");
+            process.exit(1);
+        }
+        spinner.success("TypeScript validation passed");
+    }
+    catch (error) {
+        spinner.error(`TypeScript validation failed: ${error}`);
+        process.exit(1);
+    }
+    spinner.start("Building JavaScript...");
+    try {
+        const jsBuilt = await buildJavaScript();
+        if (!jsBuilt) {
+            spinner.error("JavaScript build failed");
+            process.exit(1);
+        }
+        spinner.success("Build completed successfully");
+        process.exit(0);
+    }
+    catch (error) {
+        spinner.error(`JavaScript build failed: ${error}`);
+        process.exit(1);
     }
-    actor.start();
 });

package/lib/commands/dev/boot.js

@@ -1,14 +1,14 @@
 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 { getAppSlugFromPackageJson } from "../../api/get-app-slug-from-package-json.js";
 import { loadAttioCliPackageJson } from "../../util/load-attio-cli-package-json.js";
 import { createDevVersion } from "../../api/create-dev-version.js";
+import { determineWorkspace } from "../../api/determine-workspace.spinner.js";
+import { getAppInfo } from "../../api/get-app-info.spinner.js";
 export async function boot({ workspaceSlug }) {
     const token = await ensureAuthed();
     const appSlug = await getAppSlugFromPackageJson();
-    const appInfo = await fetchAppInfo({ token, appSlug });
+    const appInfo = await getAppInfo({ token, appSlug });
     const workspace = await determineWorkspace({ token, workspaceSlug });
     const environmentVariables = await loadEnv();
     const packageJson = loadAttioCliPackageJson();

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

@@ -20,7 +20,7 @@ export function buildJavaScript(onSuccess) {
     async function handleBuild() {
         try {
             if (!buildContexts) {
-                buildContexts = await prepareBuildContexts();
+                buildContexts = await prepareBuildContexts("in-memory");
             }
             const results = await Promise.all(buildContexts.map(async (context) => context.rebuild()));
             const bundles = results.map((result) => result.outputFiles[0].text);
@@ -36,7 +36,7 @@ export function buildJavaScript(onSuccess) {
     }
     watcher.on("ready", () => {
         handleBuild();
-        watcher.on("all", (event, path) => {
+        watcher.on("all", (event) => {
             if (event === "add" || event === "change" || event === "unlink") {
                 handleBuild();
             }

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

@@ -20,7 +20,7 @@ export function bundleJavaScript(onSuccess) {
     async function handleBuild() {
         try {
             if (!buildContexts) {
-                buildContexts = await prepareBuildContexts();
+                buildContexts = await prepareBuildContexts("in-memory");
             }
             const results = await Promise.all(buildContexts.map(async (context) => context.rebuild()));
             const bundles = results.map((result) => result.outputFiles[0].text);

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

@@ -6,7 +6,7 @@ import { createClientBuildConfig } from "../../build/client/create-client-build-
 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() {
+export async function prepareBuildContexts(mode) {
     const srcDir = "src";
     const assetsDir = path.join(srcDir, "assets");
     const webhooksDir = path.join(srcDir, "webhooks");
@@ -29,7 +29,7 @@ export async function prepareBuildContexts() {
                     entryPoint: tempFile.path,
                     srcDir,
                 }),
-                write: false,
+                write: mode === "write-to-disk",
                 outfile: path.resolve("dist", "index.js"),
                 loader: { ".png": "dataurl", ".graphql": "text", ".gql": "text" },
             });
@@ -58,7 +58,7 @@ export async function prepareBuildContexts() {
             };
             const esbuildContext = await esbuild.context({
                 ...createServerBuildConfig(tempFile.path),
-                write: false,
+                write: mode === "write-to-disk",
                 outfile: path.resolve("dist", "server.js"),
             });
             return {

package/lib/commands/init/ask-language.js

@@ -0,0 +1,11 @@
+import { select } from "@inquirer/prompts";
+export const LANGUAGES = [
+    { name: "TypeScript (recommended)", value: "typescript" },
+    { name: "JavaScript", value: "javascript" },
+];
+export async function askLanguage() {
+    return select({
+        message: "What language would you like to use?",
+        choices: LANGUAGES,
+    });
+}

package/lib/commands/init/boot.js

@@ -0,0 +1,14 @@
+import { ensureAuthed } from "../../api/ensure-authed.js";
+import { getAppInfo } from "../../api/get-app-info.spinner.js";
+import { determineWorkspace } from "../../api/determine-workspace.spinner.js";
+export async function boot({ workspaceSlug, appSlug, }) {
+    const token = await ensureAuthed();
+    const appInfo = await getAppInfo({ token, appSlug });
+    const workspace = await determineWorkspace({ token, workspaceSlug });
+    return {
+        token,
+        appId: appInfo.app_id,
+        appInfo,
+        workspace,
+    };
+}

package/lib/commands/init/create-project.js

@@ -0,0 +1,50 @@
+import { fileURLToPath } from "url";
+import path from "path";
+import chalk from "chalk";
+import boxen from "boxen";
+import { existsSync } from "fs";
+import { createDirectory } from "../../util/create-directory.js";
+import { canWrite } from "../../util/validate-slug.js";
+import { copyWithTransform } from "../../util/copy-with-replace.js";
+import { printMessage } from "../../util/print-message.js";
+import { Spinner } from "../../util/spinner.js";
+export async function createProject({ appSlug, language, appInfo, appId, }) {
+    const spinner = new Spinner();
+    if (existsSync(path.join(process.cwd(), appSlug))) {
+        throw new Error(`Directory "${appSlug}" already exists`);
+    }
+    if (!canWrite(process.cwd())) {
+        throw new Error("Write access denied to current directory");
+    }
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const projectDir = createDirectory(appSlug);
+    const templatesDir = path.resolve(__dirname, "../../templates", language);
+    const commonDir = path.resolve(__dirname, "../../templates", "common");
+    spinner.start("Creating project...");
+    try {
+        const transform = (contents) => contents
+            .replaceAll("title-to-be-replaced", appInfo.title)
+            .replaceAll("id-to-be-replaced", appId)
+            .replaceAll("slug-to-be-replaced", appSlug);
+        await Promise.all([
+            copyWithTransform(templatesDir, projectDir, transform),
+            copyWithTransform(commonDir, projectDir, transform),
+        ]);
+        spinner.success("Project created");
+        printMessage("\n" + chalk.green(`SUCCESS!! 🎉 Your app directory has been created.`));
+        printMessage("\nTo get started, run:\n");
+        printMessage(boxen(`cd ${appSlug}\nnpm install\nnpm run dev`, {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+        }) + "\n");
+        printMessage(`(${chalk.yellow("yarn")}, ${chalk.yellow("pnpm")}, and ${chalk.yellow("bun")} also work!)\n`);
+    }
+    catch (error) {
+        spinner.error("Error creating project");
+        throw error;
+    }
+    finally {
+        spinner.stop();
+    }
+}

package/lib/commands/init.js

@@ -1,30 +1,35 @@
 import { Argument, Command, Option } from "commander";
-import { createActor } from "xstate";
 import { z } from "zod";
-import { initMachine } from "../machines/init-machine.js";
+import chalk from "chalk";
+import { boot } from "./init/boot.js";
+import { createProject } from "./init/create-project.js";
+import { askLanguage } from "./init/ask-language.js";
 export const argsSchema = z.string();
 export const optionsSchema = z.object({
     language: z.enum(["javascript", "typescript"]).optional(),
-    dev: z.boolean().default(false),
+    workspace: z.string().optional(),
 });
 export const init = new Command("init")
     .description("Initialize a new Attio app")
     .addArgument(new Argument("<app-slug>", "The app slug, chosen in the developer dashboard"))
     .addOption(new Option("--language <language>", "Language").choices(["javascript", "typescript"]))
-    .addOption(new Option("--dev", "Run in development mode (additional debugging info)"))
-    .action((unparsedArgs, unparsedOptions) => {
-    const appSlug = argsSchema.parse(unparsedArgs);
-    const options = optionsSchema.parse(unparsedOptions);
-    const actor = createActor(initMachine, {
-        input: {
+    .addOption(new Option("--workspace <slug>", "The slug of the workspace to use"))
+    .action(async (unparsedArgs, unparsedOptions) => {
+    try {
+        const appSlug = argsSchema.parse(unparsedArgs);
+        const { language: cliLanguage, workspace: workspaceSlug } = optionsSchema.parse(unparsedOptions);
+        const { appId, appInfo } = await boot({ workspaceSlug, appSlug });
+        const language = cliLanguage ?? (await askLanguage());
+        await createProject({
             appSlug,
-            language: options.language,
-        },
-    });
-    if (options.dev) {
-        actor.subscribe((state) => {
-            console.log("state:", state.value);
+            language,
+            appInfo,
+            appId,
         });
+        process.exit(0);
+    }
+    catch (error) {
+        process.stderr.write(`${chalk.red("✖ " + error)}\n`);
+        process.exit(1);
     }
-    actor.start();
 });

package/lib/commands/login.js

@@ -4,8 +4,10 @@ export const login = new Command("login").description("Authenticate with Attio")
     authApi()
         .then((token) => {
         process.stdout.write("🔓 Successfully authenticated.\n");
+        process.exit(0);
     })
         .catch((error) => {
         process.stderr.write(`❌ Authentication failed\n\n${error}\n`);
+        process.exit(1);
     });
 });

package/lib/commands/logout.js

@@ -4,8 +4,10 @@ export const logout = new Command("logout").description("Log out from Attio").ac
     deleteAuthToken()
         .then(() => {
         process.stdout.write("🔒 Successfully logged out.\n");
+        process.exit(0);
     })
         .catch((error) => {
         process.stderr.write(`❌ Logout failed\n\n${error}\n`);
+        process.exit(1);
     });
 });

package/lib/commands/version/create/boot.js

@@ -0,0 +1,9 @@
+import { ensureAuthed } from "../../../api/ensure-authed.js";
+import { getAppSlugFromPackageJson } from "../../../api/get-app-slug-from-package-json.js";
+import { getAppInfo } from "../../../api/get-app-info.spinner.js";
+export async function boot() {
+    const token = await ensureAuthed();
+    const appSlug = await getAppSlugFromPackageJson();
+    const appInfo = await getAppInfo({ token, appSlug });
+    return { token, appInfo };
+}

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);
 }