attio 0.0.1-experimental.20250324.1 → 0.0.1-experimental.20250325.1

package/lib/machines/init-machine.js

@@ -2,18 +2,14 @@ import { existsSync } from "fs";
 import Spinner from "tiny-spinner";
 import path, { join } from "path";
 import { fileURLToPath } from "url";
-import { assign, setup, fromCallback, fromPromise } from "xstate";
+import { assign, setup, fromPromise } from "xstate";
 import { copyWithTransform } from "../util/copy-with-replace.js";
 import { createDirectory } from "../util/create-directory.js";
-import { loadDeveloperConfig } from "../util/load-developer-config.js";
 import { canWrite } from "../util/validate-slug.js";
-import { ask, askWithChoices } from "./actors.js";
-import { showError, printLogo } from "./actions.js";
+import { ask, askWithChoices, authenticate, loadAppInfo } from "./actors.js";
+import { printLogo, showActorError } from "./actions.js";
 import chalk from "chalk";
 import boxen from "boxen";
-import { printInstallInstructions } from "../util/print-install-instructions.js";
-import { getAppInfo } from "../api/get-app-info.js";
-import { ensureAuthed } from "../api/ensure-authed.js";
 export const languages = [
     { name: "TypeScript (recommended)", value: "typescript" },
     { name: "JavaScript", value: "javascript" },
@@ -21,96 +17,50 @@ export const languages = [
 export const initMachine = setup({
     types: {
         context: {},
-        events: {},
         input: {},
     },
     actors: {
         ask,
         askWithChoices,
-        createProject: fromCallback(({ sendBack, input }) => {
+        createProject: fromPromise(async ({ input }) => {
             const { appSlug, appInfo, language } = input;
-            const create = async () => {
-                const spinner = new Spinner();
-                try {
-                    if (existsSync(join(process.cwd(), appSlug))) {
-                        sendBack({
-                            type: "Error",
-                            error: `Directory "${appSlug}" already exists`,
-                        });
-                        return;
-                    }
-                    if (!canWrite(process.cwd())) {
-                        sendBack({
-                            type: "Error",
-                            error: "Write access denied to current directory",
-                        });
-                        return;
-                    }
-                    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");
-                    const transform = (contents) => contents
-                        .replaceAll("title-to-be-replaced", appInfo.title)
-                        .replaceAll("id-to-be-replaced", appInfo.app_id)
-                        .replaceAll("slug-to-be-replaced", appSlug);
-                    spinner.start("Creating project...");
-                    await Promise.all([
-                        copyWithTransform(templatesDir, projectDir, transform),
-                        copyWithTransform(commonDir, projectDir, transform),
-                    ]);
-                    spinner.success("Project created");
-                    sendBack({ type: "Success" });
-                }
-                catch (error) {
-                    spinner.error("Error creating project");
-                    sendBack({ type: "Error", error: error.message });
-                }
-            };
-            create();
-        }),
-        loadConfig: fromCallback(({ sendBack }) => {
-            const load = async () => {
-                const config = await loadDeveloperConfig();
-                if (typeof config === "string") {
-                    sendBack({ type: "No Config", configError: config });
-                    return;
-                }
-                const token = await ensureAuthed();
-                sendBack({
-                    type: "Config Loaded",
-                    token,
-                    developerSlug: config.developer_slug,
-                });
-            };
-            load();
-        }),
-        loadAppInfo: fromPromise(async ({ input: { token, developerSlug, appSlug } }) => {
             const spinner = new Spinner();
-            spinner.start("Loading app information...");
             try {
-                const appInfo = await getAppInfo({ token, developerSlug, appSlug });
-                if (appInfo === null) {
-                    spinner.error("App not found");
-                    return null;
+                if (existsSync(join(process.cwd(), appSlug))) {
+                    throw new Error(`Directory "${appSlug}" already exists`);
+                }
+                if (!canWrite(process.cwd())) {
+                    throw new Error("Write access denied to current directory");
                 }
-                spinner.success(`App found: ${appInfo.title}`);
-                return appInfo;
+                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");
+                const transform = (contents) => contents
+                    .replaceAll("title-to-be-replaced", appInfo.title)
+                    .replaceAll("id-to-be-replaced", appInfo.app_id)
+                    .replaceAll("slug-to-be-replaced", appSlug);
+                spinner.start("Creating project...");
+                await Promise.all([
+                    copyWithTransform(templatesDir, projectDir, transform),
+                    copyWithTransform(commonDir, projectDir, transform),
+                ]);
+                spinner.success("Project created");
+            }
+            catch (error) {
+                spinner.error("Error creating project");
+                throw error;
             }
             finally {
                 spinner.stop();
             }
         }),
+        authenticate,
+        loadAppInfo,
     },
     actions: {
         printLogo,
-        clearError: assign({
-            error: () => undefined,
-        }),
-        showError,
-        showConfigInstructions: ({ context: { configError } }) => {
-            printInstallInstructions(configError);
-        },
+        showActorError,
         showInstructions: (_, params) => {
             process.stdout.write("\n" + chalk.green(`SUCCESS!! 🎉 Your app directory has been created.`) + "\n");
             process.stdout.write("\nTo get started, run:\n");
@@ -125,14 +75,10 @@ export const initMachine = setup({
             language: (_, params) => params.output,
         }),
         setAppInfo: assign({
-            appInfo: (_, params) => params.appInfo,
-        }),
-        setConfig: assign({
-            token: (_, params) => params.token,
-            developerSlug: (_, params) => params.developerSlug,
+            appInfo: (_, params) => params.output,
         }),
-        setConfigError: assign({
-            configError: (_, params) => params.configError,
+        setToken: assign({
+            token: (_, params) => params.output,
         }),
     },
     guards: {
@@ -141,8 +87,6 @@ export const initMachine = setup({
     },
 }).createMachine({
     context: ({ input }) => ({
-        availablePackageManagers: ["npm"],
-        developerSlug: "",
         appId: "",
         token: "",
         ...input,
@@ -167,16 +111,6 @@ export const initMachine = setup({
             },
         },
         "Creating Project": {
-            on: {
-                Error: {
-                    target: "Error",
-                    actions: { type: "showError", params: ({ event }) => event },
-                },
-                Success: {
-                    target: "Success",
-                    reenter: true,
-                },
-            },
             invoke: {
                 src: "createProject",
                 input: ({ context }) => ({
@@ -184,6 +118,11 @@ export const initMachine = setup({
                     appInfo: context.appInfo,
                     appSlug: context.appSlug,
                 }),
+                onDone: "Success",
+                onError: {
+                    target: "Error",
+                    actions: { type: "showActorError", params: ({ event }) => event },
+                },
             },
         },
         "Error": {
@@ -215,55 +154,39 @@ export const initMachine = setup({
                 {
                     src: "loadAppInfo",
                     input: ({ context }) => context,
-                    onDone: [
-                        {
-                            target: "Do we need language?",
-                            guard: { type: "app exists", params: ({ event }) => event },
-                            actions: {
-                                type: "setAppInfo",
-                                params: ({ event }) => ({ appInfo: event.output }),
-                            },
-                        },
-                        {
-                            target: "Error",
-                            reenter: true,
+                    onDone: {
+                        target: "Do we need language?",
+                        guard: { type: "app exists", params: ({ event }) => event },
+                        actions: {
+                            type: "setAppInfo",
+                            params: ({ event }) => event,
                         },
-                    ],
+                    },
                     onError: {
                         target: "Error",
                         actions: {
-                            type: "showError",
-                            params: ({ event }) => ({
-                                error: event.error instanceof Error
-                                    ? event.error.message
-                                    : String(event.error),
-                            }),
+                            type: "showActorError",
+                            params: ({ event }) => event,
                         },
                     },
                 },
             ],
         },
-        "Load Config": {
-            on: {
-                "No Config": {
-                    target: "Show config instructions",
-                    actions: { type: "setConfigError", params: ({ event }) => event },
+        "Authenticate": {
+            invoke: {
+                src: "authenticate",
+                onError: {
+                    target: "Error",
+                    reenter: true,
+                    actions: { type: "showActorError", params: ({ event }) => event },
                 },
-                "Config Loaded": {
+                onDone: {
                     target: "Loading App Info",
-                    actions: { type: "setConfig", params: ({ event }) => event },
-                    reenter: true,
+                    actions: { type: "setToken", params: ({ event }) => event },
                 },
             },
-            invoke: {
-                src: "loadConfig",
-            },
-        },
-        "Show config instructions": {
-            type: "final",
-            entry: "showConfigInstructions",
         },
     },
-    initial: "Load Config",
+    initial: "Authenticate",
     entry: "printLogo",
 });

package/lib/util/find-available-port.js

@@ -1,8 +1,14 @@
 import net from "net";
 async function isPortAvailable(port) {
     return new Promise((resolve) => {
-        const tester = net.createConnection(port, "127.0.0.1");
-        tester.once("error", (err) => {
+        const portTester = net.createConnection(port, "127.0.0.1");
+        portTester.setTimeout(1000);
+        const cleanup = () => {
+            portTester.removeAllListeners();
+            portTester.destroy();
+        };
+        portTester.once("error", (err) => {
+            cleanup();
             if (err.code === "ECONNREFUSED") {
                 resolve(true);
             }
@@ -10,8 +16,12 @@ async function isPortAvailable(port) {
                 resolve(false);
             }
         });
-        tester.once("connect", () => {
-            tester.end();
+        portTester.once("connect", () => {
+            cleanup();
+            resolve(false);
+        });
+        portTester.once("timeout", () => {
+            cleanup();
             resolve(false);
         });
     });

package/package.json

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

package/lib/api/add-connection-definition.js

@@ -1,32 +0,0 @@
-import { v4 as uuid } from "uuid";
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const addConnectionSchema = z.object({
-    app_id: z.string(),
-    connection_definition_id: z.string(),
-});
-export async function addConnectionDefinition({ token, appId, label, description, global, connectionType, clientId, clientSecret, authorizeUrl, accessTokenUrl, major, scopes, }) {
-    const connectionDefinitionId = uuid();
-    const body = {
-        connection_type: connectionType,
-        label,
-        description,
-        global,
-    };
-    if (connectionType === "oauth2-code") {
-        body.authorize_url = authorizeUrl;
-        body.access_token_url = accessTokenUrl;
-        body.client_id = clientId;
-        body.client_secret = clientSecret;
-        body.scopes = scopes.split(",").map((scope) => scope.trim());
-    }
-    const response = await fetch(`${API}/apps/${appId}/versions/${major}/connection-definitions/${connectionDefinitionId}`, {
-        method: "PUT",
-        headers: makeHeaders(token),
-        body: JSON.stringify(body),
-    });
-    await handleError(response);
-    return addConnectionSchema.parse(await response.json());
-}

package/lib/api/load-app-id.js

@@ -1,9 +0,0 @@
-import { loadAppConfigFile } from "../util/app-config.js";
-export function loadAppId() {
-    const appConfig = loadAppConfigFile();
-    if (typeof appConfig === "string") {
-        process.stderr.write(`❌ App config not found\n\n${appConfig}\n`);
-        process.exit(1);
-    }
-    return appConfig.id;
-}

package/lib/api/load-dev-slug.js

@@ -1,9 +0,0 @@
-import { loadDeveloperConfig } from "../util/load-developer-config.js";
-export async function loadDevSlug() {
-    const devConfig = await loadDeveloperConfig();
-    if (typeof devConfig === "string") {
-        process.stderr.write(`❌ Developer config not found\n\n${devConfig}\n`);
-        process.exit(1);
-    }
-    return devConfig.developer_slug;
-}

package/lib/schema.js

@@ -1,33 +0,0 @@
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { fromError } from "zod-validation-error";
-const configSchema = z.object({
-    slug: z.string().describe("A unique slug for the app"),
-    id: z.string().uuid().describe("A unique ID for the app"),
-    major: z.number().int().min(1).default(1).describe("The major version of the app"),
-    minor: z.number().int().min(0).default(0).describe("The minor version of the app"),
-    connection: z
-        .object({
-        connection_type: z.enum(["secret", "oauth2-code"]).describe("The type of connection"),
-        audience: z
-            .enum(["workspace", "workspace-member"])
-            .describe("The connection's audience"),
-    })
-        .nullable()
-        .default(null)
-        .describe("Connections to other services"),
-});
-export const emptyConfig = {
-    slug: "",
-    id: "",
-    major: 1,
-    minor: 0,
-    connection: null,
-};
-export function parseConfig(json) {
-    const result = configSchema.safeParse(json);
-    if (result.success)
-        return result.data;
-    throw fromError(result.error).message;
-}
-export const getConfigJsonSchema = () => zodToJsonSchema(configSchema);

package/lib/templates/common/attio.json

@@ -1,4 +0,0 @@
-{
-  "slug": "slug-to-be-replaced",
-  "id": "id-to-be-replaced"
-}

package/lib/util/app-config.js

@@ -1,51 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { parseConfig } from "../schema.js";
-const ERRORS = {
-    noAttioJson: "No attio.json. Run this from your app project directory.",
-    invalidAttioJson: "Invalid attio.json",
-    writeError: "Error writing to attio.json",
-};
-function determineConfigPath() {
-    if (process.env.NODE_ENV === "development") {
-        const path = "./attio.dev.json";
-        if (existsSync(path))
-            return path;
-    }
-    const path = "./attio.json";
-    if (existsSync(path))
-        return path;
-    return ERRORS.noAttioJson;
-}
-export function loadAppConfigFile() {
-    const configPath = determineConfigPath();
-    if (configPath === ERRORS.noAttioJson)
-        return configPath;
-    let doc;
-    try {
-        doc = JSON.parse(readFileSync(configPath, "utf8"));
-    }
-    catch {
-        return ERRORS.invalidAttioJson;
-    }
-    try {
-        return parseConfig(doc);
-    }
-    catch (e) {
-        return e.message;
-    }
-}
-export function updateAppConfig(mutator) {
-    const configPath = determineConfigPath();
-    if (configPath === ERRORS.noAttioJson)
-        return configPath;
-    const config = loadAppConfigFile();
-    if (typeof config === "string")
-        return config;
-    const updated = parseConfig(mutator(config));
-    try {
-        writeFileSync(configPath, JSON.stringify(updated, null, 2));
-    }
-    catch {
-        return ERRORS.writeError;
-    }
-}

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

@@ -1,92 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { stringify, parse } from "ini";
-import { homedir } from "os";
-import { z } from "zod";
-import { createDeveloperAccount } from "../api/create-developer-account.js";
-import { isValidSlug } from "./validate-slug.js";
-export const initialDeveloperConfigSchema = z.object({
-    token: z.string(),
-    developer_slug: z.string(),
-    target_workspace_id: z.string().uuid().optional().nullable(),
-});
-const developerConfigSchema = initialDeveloperConfigSchema.extend({
-    developer_account_id: z.string(),
-    developer_account_member_id: z.string(),
-});
-export const configFileName = process.env.NODE_ENV === "development" ? ".attiorc.dev" : ".attiorc";
-function determineDeveloperConfigPath() {
-    if (process.env.NODE_ENV === "development") {
-        const path = `${homedir()}/.attiorc.dev`;
-        if (existsSync(path))
-            return path;
-    }
-    const path = `${homedir()}/.attiorc`;
-    if (existsSync(path))
-        return path;
-    return "No config file";
-}
-function readDeveloperConfigFile() {
-    const path = determineDeveloperConfigPath();
-    if (path === "No config file")
-        return "No config file";
-    const configFileContents = readFileSync(path, { encoding: "utf8" });
-    try {
-        return { path, contents: parse(configFileContents) };
-    }
-    catch {
-        return "Invalid config file";
-    }
-}
-export function loadInitialDeveloperConfig() {
-    const configFile = readDeveloperConfigFile();
-    switch (configFile) {
-        case "No config file":
-        case "Invalid config file":
-            return configFile;
-    }
-    const parsed = initialDeveloperConfigSchema.safeParse(configFile.contents);
-    if (!parsed.success)
-        return "Invalid config file";
-    parsed.data.target_workspace_id = null;
-    return parsed.data;
-}
-export async function loadDeveloperConfig() {
-    const configFile = readDeveloperConfigFile();
-    switch (configFile) {
-        case "No config file":
-        case "Invalid config file":
-            return configFile;
-    }
-    const parsed = developerConfigSchema.safeParse(configFile.contents);
-    if (parsed.success) {
-        if (!isValidSlug(parsed.data.developer_slug)) {
-            return "Invalid developer_slug: must be lower kebab case and contain only letters, numbers and hyphens. e.g. my-slug";
-        }
-        return parsed.data;
-    }
-    const initialDeveloperConfig = loadInitialDeveloperConfig();
-    if (typeof initialDeveloperConfig === "string")
-        return initialDeveloperConfig;
-    const { token, developer_slug: developerSlug } = initialDeveloperConfig;
-    if (!isValidSlug(developerSlug)) {
-        return "Invalid developer_slug: must be lower kebab case and contain only letters, numbers and hyphens. e.g. my-slug";
-    }
-    const devAccount = await createDeveloperAccount({ token, developerSlug });
-    const config = developerConfigSchema.parse({
-        token,
-        developer_slug: developerSlug,
-        developer_account_id: devAccount.developer_account.developer_account_id,
-        developer_account_member_id: devAccount.developer_account_member.developer_account_member_id,
-        target_workspace_id: initialDeveloperConfig.target_workspace_id ?? null,
-    });
-    writeFileSync(configFile.path, stringify(config));
-    return config;
-}
-export async function saveTargetWorkspaceToConfig(workspaceId) {
-    const configFile = readDeveloperConfigFile();
-    if (configFile === "No config file" || configFile === "Invalid config file")
-        return;
-    const config = developerConfigSchema.parse(configFile.contents);
-    config.target_workspace_id = workspaceId;
-    writeFileSync(configFile.path, stringify(config));
-}

package/lib/util/print-install-instructions.js

@@ -1,32 +0,0 @@
-import { stringify } from "ini";
-import chalk from "chalk";
-import { APP, APP_NO_PROTOCOL, IS_DEV } from "../env.js";
-import { configFileName } from "../util/load-developer-config.js";
-const exampleConfig = {
-    token: "YOUR TOKEN HERE",
-    developer_slug: "ANY UNIQUE SLUG YOU WANT",
-    target_workspace_id: "YOUR WORKSPACE ID HERE",
-};
-export function printInstallInstructions(reason) {
-    const write = (str = "") => process.stdout.write(str + "\n");
-    if (reason) {
-        write("Failed to load config file.");
-        write(chalk.red(reason));
-        write();
-    }
-    write("You will need to:");
-    write();
-    write(`  1. Log into${IS_DEV ? ` ${chalk.italic("DEVELOPMENT")}` : ""} Attio web app: ${APP}`);
-    write(`  2. Open Dev Tools > Application > Cookies > ${APP_NO_PROTOCOL}`);
-    write(`  3. Copy the value for attio-session. That's your "token".`);
-    write(`  4. Create a file in your home directory called ~/${configFileName}`);
-    write(`  5. It should have the following [INI] format:`);
-    write();
-    write("     " + stringify(exampleConfig).trim().replace(/\n/g, "\n     "));
-    write();
-    write("  6. Run this command again.");
-    write();
-    write("  ...");
-    write();
-    write("  N. PROFIT!");
-}