attio 0.0.1-experimental.20251104.3 → 0.0.1-experimental.20251105.1

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

@@ -0,0 +1,37 @@
+import net from "net";
+import { hardExit } from "./hard-exit.js";
+async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        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);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        portTester.once("connect", () => {
+            cleanup();
+            resolve(false);
+        });
+        portTester.once("timeout", () => {
+            cleanup();
+            resolve(false);
+        });
+    });
+}
+export async function findAvailablePort(startPort, maxAttempts = 100) {
+    for (let port = startPort; port < startPort + maxAttempts; port++) {
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+    }
+    hardExit(`Could not find an available port after ${maxAttempts} attempts`);
+}

package/lib/util/generate-settings-files.js

@@ -1,8 +1,8 @@
 import fs from "fs/promises";
 import path from "path";
-import { APP_SETTINGS_FILENAME, SETTINGS_TYPES_FILENAME } from "@attio/cli";
 import { combineAsync, complete, errored, isErrored } from "@attio/fetchable-npm";
 import { HIDDEN_ATTIO_DIRECTORY } from "../constants/hidden-attio-directory.js";
+import { APP_SETTINGS_FILENAME, SETTINGS_TYPES_FILENAME } from "../constants/settings-files.js";
 const SETTINGS_SCHEMA_FILE_CONTENT = `import type {SettingsSchema} from "attio"
 
 export const settingsSchema = {

package/lib/util/hard-exit.js

@@ -0,0 +1,6 @@
+import chalk from "chalk";
+import process from "process";
+export function hardExit(message) {
+    process.stderr.write(chalk.red("✖ " + message) + "\n");
+    process.exit(1);
+}

package/lib/util/print-logo.js

@@ -0,0 +1,5 @@
+import { attioLogoAndName } from "../attio-logo.js";
+import { textGradient } from "./text-gradient.js";
+export function printLogo() {
+    process.stdout.write(`\n${textGradient(attioLogoAndName, "#ff5f6d", "#ffc371")}\n\n`);
+}

package/lib/util/realtime.js

@@ -1,6 +1,6 @@
 import Ably from "ably";
-import { api } from "@attio/cli";
 import { complete, errored, isComplete, isErrored } from "@attio/fetchable-npm";
+import { api } from "../api/api.js";
 function makeConnectionError(error) {
     return errored({
         code: "FAILED_TO_CONNECT_TO_REALTIME_SERVER",

package/lib/util/spinner.js

@@ -0,0 +1,61 @@
+import chalk from "chalk";
+import { isComplete } from "@attio/fetchable-npm";
+const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+class Spinner {
+    frameIndex = 0;
+    stopped = false;
+    interval = null;
+    message = "";
+    start(message) {
+        if (this.interval) {
+            clearInterval(this.interval);
+        }
+        this.message = message;
+        this.stopped = false;
+        this.interval = setInterval(() => {
+            if (this.stopped)
+                return;
+            const frame = frames[(this.frameIndex = ++this.frameIndex % frames.length)];
+            process.stdout.write(`\r${frame} ${this.message}`);
+        }, 80);
+        return this;
+    }
+    update(message) {
+        this.message = message;
+        return this;
+    }
+    stop(message) {
+        this.stopped = true;
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        if (message) {
+            process.stdout.write(`\r${message}    \n`);
+        }
+        return this;
+    }
+    success(message) {
+        return this.stop(`${chalk.green("✓")} ${message}`);
+    }
+    error(message) {
+        return this.stop(`${chalk.red("✖")} ${message}`);
+    }
+    warning(message) {
+        return this.stop(`${chalk.yellow("⚠")} ${message}`);
+    }
+}
+export async function spinnerify(busyMessage, successMessage, fn) {
+    const spinner = new Spinner();
+    spinner.start(busyMessage);
+    try {
+        const result = await fn();
+        if (isComplete(result)) {
+            spinner.success(typeof successMessage === "string" ? successMessage : successMessage(result.value));
+        }
+        return result;
+    }
+    finally {
+        spinner.stop();
+    }
+}

package/lib/util/text-gradient.js

@@ -0,0 +1,28 @@
+import chalk from "chalk";
+function hexToRgb(hex) {
+    const bigint = parseInt(hex.replace("#", ""), 16);
+    return [(bigint >> 16) & 255, (bigint >> 8) & 255, bigint & 255];
+}
+function interpolateColor(start, end, factor) {
+    return [
+        Math.round(start[0] + (end[0] - start[0]) * factor),
+        Math.round(start[1] + (end[1] - start[1]) * factor),
+        Math.round(start[2] + (end[2] - start[2]) * factor),
+    ];
+}
+export function textGradient(input, startHex, endHex) {
+    const lines = input.split("\n");
+    const startColor = hexToRgb(startHex);
+    const endColor = hexToRgb(endHex);
+    const gradientLines = lines.map((line) => {
+        const length = line.length;
+        return Array.from(line)
+            .map((char, index) => {
+            const factor = length > 1 ? index / (length - 1) : 0;
+            const [r, g, b] = interpolateColor(startColor, endColor, factor);
+            return chalk.rgb(r, g, b)(char);
+        })
+            .join("");
+    });
+    return gradientLines.join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20251104.3",
+  "version": "0.0.1-experimental.20251105.1",
   "type": "module",
   "files": [
     "lib",