attio 0.0.1-experimental.20250813 → 0.0.1-experimental.20250813.2

package/README.md

@@ -1,4 +1,4 @@
-# Attio Extension CLI
+# Attio App SDK CLI
 
 ## ⚠️ This package is experimental and not yet ready for use. ⚠️
 

package/lib/api/api.js

@@ -1,7 +1,7 @@
 import { complete, errored, isErrored } from "@attio/fetchable-npm";
 import { APP } from "../env.js";
 import { Fetcher } from "./fetcher.js";
-import { appInfoSchema, completeBundleUploadSchema, createDevVersionSchema, createVersionSchema, installationSchema, listDevWorkspacesResponseSchema, startUploadSchema, TEST_APP_INFO, TEST_WORKSPACES, tokenResponseSchema, versionsSchema, whoamiSchema, } from "./schemas.js";
+import { ablyAuthResponseSchema, appInfoSchema, completeBundleUploadSchema, createDevVersionSchema, createVersionSchema, installationSchema, listDevWorkspacesResponseSchema, startUploadSchema, TEST_APP_INFO, TEST_WORKSPACES, tokenResponseSchema, versionsSchema, whoamiSchema, } from "./schemas.js";
 class ApiImpl {
     _fetcher;
     constructor() {
@@ -162,5 +162,18 @@ class ApiImpl {
         }
         return result;
     }
+    async authenticateAbly(tokenParams) {
+        const result = await this._fetcher.post({
+            path: "/integrations/ably/auth",
+            body: {
+                token_params: tokenParams,
+            },
+            schema: ablyAuthResponseSchema,
+        });
+        if (isErrored(result)) {
+            return errored({ code: "ABLY_AUTHENTICATION_ERROR", error: result.error });
+        }
+        return result;
+    }
 }
 export const api = new ApiImpl();

package/lib/api/schemas.js

@@ -80,3 +80,10 @@ export const tokenResponseSchema = z.object({
     refresh_token: z.string(),
     expires_in: z.number(),
 });
+export const ablyAuthResponseSchema = z.object({
+    capability: z.string(),
+    clientId: z.string().optional(),
+    expires: z.number(),
+    issued: z.number(),
+    token: z.string(),
+});

package/lib/attio.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { init } from "./commands/init.js";
 import { build } from "./commands/build.js";
 import { dev } from "./commands/dev.js";
-import { version } from "./commands/version/index.js";
+import { init } from "./commands/init.js";
 import { login } from "./commands/login.js";
 import { logout } from "./commands/logout.js";
+import { logs } from "./commands/logs.js";
+import { version } from "./commands/version/index.js";
 import { whoami } from "./commands/whoami.js";
 const program = new Command();
 program
@@ -19,4 +20,5 @@ program
     .addCommand(login)
     .addCommand(logout)
     .addCommand(whoami)
+    .addCommand(logs)
     .parse();

package/lib/commands/dev.js

@@ -33,7 +33,7 @@ export const optionsSchema = z.object({
 });
 export const dev = new Command("dev")
     .description("Develop your Attio app")
-    .addOption(new Option("--workspace <slug>", "The slug of the workspace to use"))
+    .addOption(new Option("-w, --workspace <slug>", "The slug of the workspace to use"))
     .action(async (unparsedOptions) => {
     const { workspace: workspaceSlug } = optionsSchema.parse(unparsedOptions);
     const cleanupFunctions = [];

package/lib/commands/log/log-event.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+const severitySchema = z.union([z.literal("INFO"), z.literal("WARNING"), z.literal("ERROR")]);
+export const logEventSchema = z.object({
+    message: z.string(),
+    severity: severitySchema,
+    timestamp: z.string().datetime(),
+});

package/lib/commands/log/logs-buffer.js

@@ -0,0 +1,52 @@
+export class LogsBuffer {
+    bufferDelayMs;
+    buffer = [];
+    listeners = [];
+    flushInterval;
+    constructor(bufferDelayMs) {
+        this.bufferDelayMs = bufferDelayMs;
+        this.flushInterval = setInterval(() => {
+            this.flush();
+        }, bufferDelayMs / 5);
+    }
+    close() {
+        if (this.flushInterval) {
+            clearInterval(this.flushInterval);
+        }
+        this.flushInterval = null;
+    }
+    listen(listener) {
+        this.assertNotClosed();
+        this.listeners.push(listener);
+    }
+    add(event) {
+        this.assertNotClosed();
+        const receivedAt = Date.now();
+        const insertIndex = this.buffer.findIndex((bufferItem) => event.timestamp > bufferItem.event.timestamp);
+        if (insertIndex >= 0) {
+            this.buffer.splice(insertIndex, 0, { event, receivedAt });
+        }
+        else {
+            this.buffer.push({ event, receivedAt });
+        }
+    }
+    flush() {
+        const now = Date.now();
+        const firstFlushIndex = this.buffer.findIndex((bufferItem) => now - bufferItem.receivedAt > this.bufferDelayMs);
+        if (firstFlushIndex === -1) {
+            return;
+        }
+        const eventsToFlush = this.buffer
+            .splice(firstFlushIndex, this.buffer.length - firstFlushIndex)
+            .reverse()
+            .map(({ event }) => event);
+        for (const listener of this.listeners) {
+            listener(eventsToFlush);
+        }
+    }
+    assertNotClosed() {
+        if (this.flushInterval === null) {
+            throw new Error("This buffer was closed");
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+import { complete, isErrored } from "@attio/fetchable-npm";
+import { getRealtime } from "../../util/realtime.js";
+import { logEventSchema } from "./log-event.js";
+import { LogsBuffer } from "./logs-buffer.js";
+export async function subscribeToLogs({ workspaceId, appId, }, listener) {
+    const logsBuffer = new LogsBuffer(200);
+    logsBuffer.listen((event) => event.forEach(listener));
+    const realtime = getRealtime();
+    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;
+    }
+    const realtimeSubscription = realtimeSubscriptionResult.value;
+    return complete({
+        unsubscribe: async () => {
+            logsBuffer.close();
+            await realtimeSubscription.unsubscribe();
+        },
+    });
+}

package/lib/commands/logs.js

@@ -0,0 +1,93 @@
+import chalk from "chalk";
+import { Command, Option } from "commander";
+import { z } from "zod";
+import { isErrored } from "@attio/fetchable-npm";
+import { authenticator } from "../auth/auth.js";
+import { printDetermineWorkspaceError, printFetcherError, printLogSubscriptionError, printPackageJsonError, } from "../print-errors.js";
+import { determineWorkspace } from "../spinners/determine-workspace.spinner.js";
+import { getAppInfo } from "../spinners/get-app-info.spinner.js";
+import { getAppSlugFromPackageJson } from "../spinners/get-app-slug-from-package-json.js";
+import { spinnerify } from "../util/spinner.js";
+import { subscribeToLogs } from "./log/subscribe-to-logs.js";
+export const optionsSchema = z.object({
+    workspace: z.string().optional(),
+});
+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"))
+    .action(async (unparsedOptions) => {
+    const { workspace: workspaceSlug } = optionsSchema.parse(unparsedOptions);
+    await authenticator.ensureAuthed();
+    const appSlugResult = await getAppSlugFromPackageJson();
+    if (isErrored(appSlugResult)) {
+        printPackageJsonError(appSlugResult.error);
+        process.exit(1);
+    }
+    const appSlug = appSlugResult.value;
+    const appInfoResult = await getAppInfo(appSlug);
+    if (isErrored(appInfoResult)) {
+        printFetcherError("Error loading app info", appInfoResult.error);
+        process.exit(1);
+    }
+    const appInfo = appInfoResult.value;
+    const workspaceResult = await determineWorkspace(workspaceSlug);
+    if (isErrored(workspaceResult)) {
+        printDetermineWorkspaceError(workspaceResult.error);
+        process.exit(1);
+    }
+    const workspace = workspaceResult.value;
+    const subscriptionResult = await spinnerify("Connecting to log server...", "Connected to log server", async () => {
+        return subscribeToLogs({ workspaceId: workspace.workspace_id, appId: appInfo.app_id }, ({ message, severity, timestamp }) => {
+            let coloredSeverity;
+            switch (severity) {
+                case "INFO":
+                    coloredSeverity = chalk.blue(severity);
+                    break;
+                case "ERROR":
+                    coloredSeverity = chalk.red(severity);
+                    break;
+                case "WARNING":
+                    coloredSeverity = chalk.yellow(severity);
+                    break;
+                default:
+                    coloredSeverity = severity;
+            }
+            const logLine = `${timestamp} ${coloredSeverity}: ${message.trim()}`;
+            process.stdout.write(`\n${logLine}`);
+        });
+    });
+    if (isErrored(subscriptionResult)) {
+        printLogSubscriptionError(subscriptionResult.error);
+        process.exit(2);
+    }
+    let isShuttingDown = false;
+    const shutdown = async (exitCode = 0) => {
+        if (isShuttingDown) {
+            return;
+        }
+        isShuttingDown = true;
+        try {
+            await subscriptionResult.value.unsubscribe();
+        }
+        catch {
+            exitCode = Math.min(exitCode, 1);
+        }
+        finally {
+            process.exit(exitCode);
+        }
+    };
+    ["SIGINT", "SIGTERM"].forEach((signal) => process.on(signal, async () => shutdown(0)));
+    process.on("beforeExit", async (exitCode) => {
+        await shutdown(exitCode);
+    });
+    process.on("uncaughtException", async (error) => {
+        process.stderr.write(chalk.red(`Uncaught exception: ${error}\n`));
+        await shutdown(1);
+    });
+    process.on("unhandledRejection", async (error) => {
+        process.stderr.write(chalk.red(`Unhandled rejection: ${error}\n`));
+        await shutdown(1);
+    });
+    await new Promise(() => {
+    });
+});

package/lib/print-errors.js

@@ -163,3 +163,15 @@ export function printAuthenticationError(error) {
             return 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"));
+            break;
+        default:
+            return error;
+    }
+}

package/lib/template/README.md

@@ -1,6 +1,6 @@
 # title-to-be-replaced
 
-## `slug-to-be-replaced` Attio Extension
+## `slug-to-be-replaced` Attio app
 
 ### Build
 

package/lib/util/realtime.js

@@ -0,0 +1,62 @@
+import Ably from "ably";
+import { complete, errored, isErrored } from "@attio/fetchable-npm";
+import { api } from "../api/api.js";
+export class Realtime {
+    _realtime;
+    _channels = new Map();
+    constructor() {
+        this._realtime = new Ably.Realtime({
+            useTokenAuth: true,
+            autoConnect: false,
+            tls: true,
+            echoMessages: false,
+            authCallback: async (tokenParams, callback) => {
+                const tokenResult = await api.authenticateAbly(tokenParams);
+                if (isErrored(tokenResult)) {
+                    return callback(tokenResult.error.code, null);
+                }
+                return callback(null, tokenResult.value);
+            },
+        });
+    }
+    async subscribe(channelName, eventName, eventDataSchema, listener) {
+        let 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"],
+                    },
+                });
+            }
+            catch (error) {
+                return errored({ code: "FAILED_TO_AUTHENTICATE_CHANNEL", error });
+            }
+        }
+        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();
+                },
+            });
+        }
+        catch (error) {
+            return errored({ code: "FAILED_TO_SUBSCRIBE_TO_EVENTS", 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.20250813",
+  "version": "0.0.1-experimental.20250813.2",
   "type": "module",
   "files": [
     "lib",
@@ -38,6 +38,7 @@
     "@hono/graphql-server": "0.6.2",
     "@hono/node-server": "1.14.4",
     "@inquirer/prompts": "7.5.3",
+    "ably": "^2.0.1",
     "boxen": "^8.0.1",
     "chalk": "^5.4.1",
     "chokidar": "^3.6.0",