attio 0.0.1-experimental.20250815 → 0.0.1-experimental.20250815.2

package/lib/commands/log/subscribe-to-logs.js

@@ -1,17 +1,37 @@
-import { complete, isErrored } from "@attio/fetchable-npm";
-import { getRealtime } from "../../util/realtime.js";
+import { complete, errored, isErrored } from "@attio/fetchable-npm";
+import { Realtime } from "../../util/realtime.js";
 import { logEventSchema } from "./log-event.js";
 import { LogsBuffer } from "./logs-buffer.js";
-export async function subscribeToLogs({ workspaceId, appId, }, listener) {
+export async function subscribeToLogs({ workspaceId, appId, }, listener, onConnectionSuspended) {
     const logsBuffer = new LogsBuffer(200);
     logsBuffer.listen((event) => event.forEach(listener));
-    const realtime = getRealtime();
+    const realtime = new Realtime();
+    realtime.onSuspended(() => {
+        onConnectionSuspended({
+            close: async () => {
+                await realtime.close();
+            },
+            reconnect: async () => {
+                const reconnectResult = await realtime.reconnect();
+                if (isErrored(reconnectResult)) {
+                    return errored({
+                        code: "FAILED_TO_CONNECT_TO_LOGS_SERVER",
+                        error: reconnectResult.error.error,
+                    });
+                }
+                return complete(true);
+            },
+        });
+    });
     const channelName = `ecosystem-app-logs:${workspaceId}:${appId}`;
     const realtimeSubscriptionResult = await realtime.subscribe(channelName, "app-dev-log-emitted", logEventSchema, (event) => {
         logsBuffer.add(event);
     });
     if (isErrored(realtimeSubscriptionResult)) {
-        return realtimeSubscriptionResult;
+        return errored({
+            code: "FAILED_TO_CONNECT_TO_LOGS_SERVER",
+            error: realtimeSubscriptionResult.error.error,
+        });
     }
     const realtimeSubscription = realtimeSubscriptionResult.value;
     return complete({

package/lib/commands/logs.js

@@ -1,3 +1,4 @@
+import readline from "node:readline/promises";
 import chalk from "chalk";
 import { Command, Option } from "commander";
 import { z } from "zod";
@@ -12,6 +13,13 @@ import { subscribeToLogs } from "./log/subscribe-to-logs.js";
 export const optionsSchema = z.object({
     workspace: z.string().optional(),
 });
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+async function waitForEnter(prompt = "Press Enter to resume...") {
+    await rl.question(prompt);
+}
 export const logs = new Command("logs")
     .description("Stream development server logs")
     .addOption(new Option("-w, --workspace <slug>", "The slug of the workspace to get the logs from"))
@@ -54,6 +62,14 @@ export const logs = new Command("logs")
             }
             const logLine = `${timestamp} ${coloredSeverity}: ${message.trim()}`;
             process.stdout.write(`\n${logLine}`);
+        }, async ({ close, reconnect }) => {
+            await close();
+            await waitForEnter("The connection to the logs server was closed. Press Enter to reconnect...");
+            const reconnectResult = await spinnerify("Connecting to log server...", "Connected to log server", () => reconnect());
+            if (isErrored(reconnectResult)) {
+                printLogSubscriptionError(reconnectResult.error);
+                process.exit(2);
+            }
         });
     });
     if (isErrored(subscriptionResult)) {

package/lib/print-errors.js

@@ -165,13 +165,13 @@ export function printAuthenticationError(error) {
 }
 export function printLogSubscriptionError(error) {
     switch (error.code) {
-        case "FAILED_TO_AUTHENTICATE_CHANNEL":
-            process.stderr.write(chalk.red("Failed to authenticate to logs server\n"));
-            break;
-        case "FAILED_TO_SUBSCRIBE_TO_EVENTS":
-            process.stderr.write(chalk.red("Failed to subscribe to logs\n"));
+        case "FAILED_TO_CONNECT_TO_LOGS_SERVER":
+            process.stderr.write(chalk.red("Failed to connect to logs server\n"));
+            if (error.error instanceof Error) {
+                process.stderr.write(chalk.red(error.error.message));
+            }
             break;
         default:
-            return error;
+            return error.code;
     }
 }

package/lib/template/graphql.config.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://unpkg.com/graphql-config@5.1.5/config-schema.json",
+  "projects": {
+    "attio": {
+      "schema": "./node_modules/attio/schema.graphql",
+      "documents": ["./src/**/*.{graphql,gql}"]
+    }
+  }
+}

package/lib/util/realtime.js

@@ -1,11 +1,82 @@
 import Ably from "ably";
-import { complete, errored, isErrored } from "@attio/fetchable-npm";
+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",
+        error,
+    });
+}
 export class Realtime {
-    _realtime;
+    _ablyRealtime;
     _channels = new Map();
+    _suspendListeners = new Set();
     constructor() {
-        this._realtime = new Ably.Realtime({
+        this._ablyRealtime = this._createAblyRealtime();
+    }
+    async subscribe(channelName, eventName, eventDataSchema, listener) {
+        let channel = this._channels.get(channelName);
+        if (!channel) {
+            channel = {
+                listeners: new Map(),
+            };
+            const authorizeResult = await this._authorizeChannel(channelName);
+            if (isErrored(authorizeResult)) {
+                return makeConnectionError(authorizeResult.error.error);
+            }
+            this._channels.set(channelName, channel);
+        }
+        let eventListeners = channel.listeners.get(eventName);
+        if (!eventListeners) {
+            eventListeners = new Set();
+            channel.listeners.set(eventName, eventListeners);
+        }
+        const subscribeResult = await this._subscribe(channelName, eventName, (data) => {
+            const parsedEventData = eventDataSchema.safeParse(data);
+            if (parsedEventData.success) {
+                listener(parsedEventData.data);
+            }
+        });
+        if (isErrored(subscribeResult)) {
+            return makeConnectionError(subscribeResult.error.error);
+        }
+        eventListeners.add(listener);
+        return complete({
+            unsubscribe: async () => {
+                await this._unsubscribe(channelName, eventName, listener);
+            },
+        });
+    }
+    async reconnect() {
+        await this._teardown();
+        this._ablyRealtime = this._createAblyRealtime();
+        for (const [channelName, { listeners }] of this._channels) {
+            const authorizeResult = await this._authorizeChannel(channelName);
+            if (isErrored(authorizeResult)) {
+                return makeConnectionError(authorizeResult.error.error);
+            }
+            for (const [eventName, eventListeners] of listeners) {
+                for (const eventListener of eventListeners) {
+                    const subscribeResult = await this._subscribe(channelName, eventName, eventListener);
+                    if (isErrored(subscribeResult)) {
+                        return makeConnectionError(subscribeResult.error.error);
+                    }
+                }
+            }
+        }
+        return complete(true);
+    }
+    onSuspended(cb) {
+        this._suspendListeners.add(cb);
+        return () => {
+            this._suspendListeners.delete(cb);
+        };
+    }
+    async close() {
+        await this._teardown();
+    }
+    _createAblyRealtime() {
+        const realtime = new Ably.Realtime({
             useTokenAuth: true,
             autoConnect: false,
             tls: true,
@@ -18,45 +89,75 @@ export class Realtime {
                 return callback(null, tokenResult.value);
             },
         });
+        realtime.connection.on("suspended", () => {
+            this._suspendListeners.forEach((listener) => listener());
+        });
+        return realtime;
     }
-    async subscribe(channelName, eventName, eventDataSchema, listener) {
-        let channel = this._channels.get(channelName);
+    async _authorizeChannel(channelName) {
+        try {
+            await this._ablyRealtime.auth.authorize({
+                capability: {
+                    [`${channelName}`]: ["subscribe"],
+                },
+            });
+            return complete(true);
+        }
+        catch (error) {
+            return errored({ code: "FAILED_TO_AUTHORIZE_CHANNEL", error });
+        }
+    }
+    async _subscribe(channelName, eventName, listener) {
+        try {
+            const ablyChannel = this._ablyRealtime.channels.get(channelName);
+            await ablyChannel.presence.enter();
+            await ablyChannel.subscribe(eventName, (event) => {
+                listener(event.data.data);
+            });
+            return complete(true);
+        }
+        catch (error) {
+            return errored({ code: "FAILED_TO_SUBSCRIBE_TO_EVENTS", error });
+        }
+    }
+    async _unsubscribe(channelName, eventName, listener) {
+        const ablyChannel = this._ablyRealtime.channels.get(channelName);
+        ablyChannel.unsubscribe(eventName, listener);
+        const channel = this._channels.get(channelName);
         if (!channel) {
-            channel = this._realtime.channels.get(channelName);
-            this._channels.set(channelName, channel);
-            try {
-                await this._realtime.auth.authorize({
-                    capability: {
-                        [`${channelName}`]: ["subscribe"],
-                    },
-                });
+            return complete(true);
+        }
+        const eventListeners = channel.listeners.get(eventName);
+        if (eventListeners) {
+            eventListeners.delete(listener);
+            if (eventListeners?.size === 0) {
+                channel.listeners.delete(eventName);
             }
-            catch (error) {
-                return errored({ code: "FAILED_TO_AUTHENTICATE_CHANNEL", error });
+        }
+        if (channel.listeners.size === 0) {
+            const channelTeardownResult = await this._teardownChannel(channelName);
+            if (isComplete(channelTeardownResult)) {
+                this._channels.delete(channelName);
             }
         }
+        return complete(true);
+    }
+    async _teardown() {
+        for (const [channelName] of this._channels) {
+            await this._teardownChannel(channelName);
+        }
+        this._ablyRealtime.close();
+        return complete(true);
+    }
+    async _teardownChannel(channelName) {
+        const ablyChannel = this._ablyRealtime.channels.get(channelName);
         try {
-            await channel.presence.enter();
-            await channel.subscribe(eventName, (event) => {
-                const parsedEventData = eventDataSchema.safeParse(event.data.data);
-                if (parsedEventData.success) {
-                    listener(parsedEventData.data);
-                }
-            });
-            return complete({
-                unsubscribe: async () => {
-                    channel.unsubscribe(listener);
-                    await channel.presence.leave();
-                },
-            });
+            await ablyChannel.presence.leave();
+            await ablyChannel.detach();
+            return complete(true);
         }
         catch (error) {
-            return errored({ code: "FAILED_TO_SUBSCRIBE_TO_EVENTS", error });
+            return errored({ code: "FAILED_TO_TEARDOWN_CHANNEL", error });
         }
     }
 }
-let realtime;
-export function getRealtime() {
-    realtime ??= new Realtime();
-    return realtime;
-}

package/package.json

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