Move success messages after await subscribe and add error hints for disabled apps and disconnections

Author: umair-ably

src/commands/logs/channel-lifecycle/subscribe.ts

@@ -79,14 +79,6 @@ export default class LogsChannelLifecycleSubscribe extends AblyBaseCommand {
         "subscribing",
         `Subscribing to ${channelName}...`,
       );
-      if (!this.shouldOutputJson(flags)) {
-        this.log(
-          formatSuccess(`Subscribed to ${formatResource(channelName)}.`),
-        );
-        this.log(formatListening("Listening for channel lifecycle logs."));
-        this.log("");
-      }
-
       // Subscribe to the channel
       await channel.subscribe((message) => {
         const timestamp = formatMessageTimestamp(message.timestamp);
@@ -136,6 +128,15 @@ export default class LogsChannelLifecycleSubscribe extends AblyBaseCommand {
 
         this.log(""); // Empty line for better readability
       });
+
+      if (!this.shouldOutputJson(flags)) {
+        this.log(
+          formatSuccess(`Subscribed to ${formatResource(channelName)}.`),
+        );
+        this.log(formatListening("Listening for channel lifecycle logs."));
+        this.log("");
+      }
+
       this.logCliEvent(
         flags,
         "logs",

src/commands/logs/connection-lifecycle/subscribe.ts

@@ -80,10 +80,6 @@ export default class LogsConnectionLifecycleSubscribe extends AblyBaseCommand {
         { channel: logsChannelName },
       );
 
-      if (!this.shouldOutputJson(flags)) {
-        this.log(formatSuccess("Subscribed to connection lifecycle logs."));
-      }
-
       // Subscribe to connection lifecycle logs
       await channel.subscribe((message: Ably.Message) => {
         const timestamp = formatMessageTimestamp(message.timestamp);
@@ -118,6 +114,10 @@ export default class LogsConnectionLifecycleSubscribe extends AblyBaseCommand {
         }
       });
 
+      if (!this.shouldOutputJson(flags)) {
+        this.log(formatSuccess("Subscribed to connection lifecycle logs."));
+      }
+
       this.logCliEvent(
         flags,
         "logs",

src/commands/logs/subscribe.ts

@@ -111,14 +111,6 @@ export default class LogsSubscribe extends AblyBaseCommand {
         { logTypes, channel: logsChannelName },
       );
 
-      if (!this.shouldOutputJson(flags)) {
-        this.log(
-          formatSuccess(
-            `Subscribed to app logs: ${formatResource(logTypes.join(", "))}.`,
-          ),
-        );
-      }
-
       // Subscribe to specified log types
       const subscribePromises: Promise<unknown>[] = [];
       for (const logType of logTypes) {
@@ -160,6 +152,14 @@ export default class LogsSubscribe extends AblyBaseCommand {
 
       await Promise.all(subscribePromises);
 
+      if (!this.shouldOutputJson(flags)) {
+        this.log(
+          formatSuccess(
+            `Subscribed to app logs: ${formatResource(logTypes.join(", "))}.`,
+          ),
+        );
+      }
+
       this.logCliEvent(
         flags,
         "logs",

src/utils/errors.ts

@@ -21,6 +21,10 @@ const hints: Record<number, string> = {
     'Run "ably auth keys list" to check your key\'s publish capability, or update it in the Ably dashboard.',
   40171:
     'Run "ably auth keys list" to check your key\'s capabilities, or update them in the Ably dashboard.',
+  40300:
+    "This application has been disabled. Check the app status in the Ably dashboard at https://ably.com/dashboard",
+  80003:
+    "The connection was lost. Check your network connection and try again.",
 };
 
 export function getFriendlyAblyErrorHint(code?: number): string | undefined {

test/unit/commands/channels/presence/enter.test.ts

@@ -171,5 +171,35 @@ describe("channels:presence:enter command", () => {
 
       expect(error).toBeDefined();
     });
+
+    it("should handle capability error with --show-others gracefully", async () => {
+      const mock = getMockAblyRealtime();
+      const channel = mock.channels._getChannel("test-channel");
+
+      channel.presence.subscribe.mockRejectedValue(
+        Object.assign(
+          new Error("Channel denied access based on given capability"),
+          {
+            code: 40160,
+            statusCode: 401,
+            href: "https://help.ably.io/error/40160",
+          },
+        ),
+      );
+
+      const { error } = await runCommand(
+        [
+          "channels:presence:enter",
+          "test-channel",
+          "--client-id",
+          "test-client",
+          "--show-others",
+        ],
+        import.meta.url,
+      );
+
+      expect(error).toBeDefined();
+      expect(error?.message).toContain("Channel denied access");
+    });
   });
 });

test/unit/commands/channels/subscribe.test.ts

@@ -265,5 +265,41 @@ describe("channels:subscribe command", () => {
       expect(error?.message).toContain("capability");
       expect(error?.message).toContain("Ably dashboard");
     });
+
+    it("should include hint in JSON error output for capability errors", async () => {
+      const mock = getMockAblyRealtime();
+      const channel = mock.channels._getChannel("test-channel");
+
+      channel.subscribe.mockRejectedValue(
+        Object.assign(
+          new Error("Channel denied access based on given capability"),
+          {
+            code: 40160,
+            statusCode: 401,
+            href: "https://help.ably.io/error/40160",
+          },
+        ),
+      );
+
+      const { error, stdout } = await runCommand(
+        ["channels:subscribe", "test-channel", "--json"],
+        import.meta.url,
+      );
+
+      expect(error).toBeDefined();
+      const jsonLines = stdout
+        .split("\n")
+        .filter((l: string) => l.trim().startsWith("{"));
+      const errorLine = jsonLines.find((l: string) =>
+        l.includes('"type":"error"'),
+      );
+      expect(errorLine).toBeDefined();
+      const parsed = JSON.parse(errorLine!);
+      expect(parsed.type).toBe("error");
+      expect(parsed.success).toBe(false);
+      expect(parsed.code).toBe(40160);
+      expect(parsed.hint).toBeDefined();
+      expect(parsed.hint).toContain("Ably dashboard");
+    });
   });
 });

test/unit/commands/logs/channel-lifecycle/subscribe.test.ts

@@ -138,5 +138,29 @@ describe("logs:channel-lifecycle:subscribe command", () => {
       expect(error).toBeDefined();
       expect(error?.message).toMatch(/No mock|client/i);
     });
+
+    it("should handle capability error gracefully", async () => {
+      const mock = getMockAblyRealtime();
+      const channel = mock.channels._getChannel("[meta]channel.lifecycle");
+
+      channel.subscribe.mockRejectedValue(
+        Object.assign(
+          new Error("Channel denied access based on given capability"),
+          {
+            code: 40160,
+            statusCode: 401,
+            href: "https://help.ably.io/error/40160",
+          },
+        ),
+      );
+
+      const { error } = await runCommand(
+        ["logs:channel-lifecycle:subscribe"],
+        import.meta.url,
+      );
+
+      expect(error).toBeDefined();
+      expect(error?.message).toContain("Channel denied access");
+    });
   });
 });

test/unit/commands/logs/connection-lifecycle/subscribe.test.ts

@@ -356,5 +356,29 @@ describe("LogsConnectionLifecycleSubscribe", function () {
       expect(error).toBeDefined();
       expect(error?.message).toContain("Channel subscribe failed");
     });
+
+    it("should handle capability error gracefully", async () => {
+      const mock = getMockAblyRealtime();
+      const channel = mock.channels._getChannel("[meta]connection.lifecycle");
+
+      channel.subscribe.mockRejectedValue(
+        Object.assign(
+          new Error("Channel denied access based on given capability"),
+          {
+            code: 40160,
+            statusCode: 401,
+            href: "https://help.ably.io/error/40160",
+          },
+        ),
+      );
+
+      const { error } = await runCommand(
+        ["logs:connection-lifecycle:subscribe"],
+        import.meta.url,
+      );
+
+      expect(error).toBeDefined();
+      expect(error?.message).toContain("Channel denied access");
+    });
   });
 });

test/unit/commands/logs/push/subscribe.test.ts

@@ -52,6 +52,30 @@ describe("logs:push:subscribe command", () => {
       expect(error).toBeDefined();
       expect(error?.message).toMatch(/No mock|client/i);
     });
+
+    it("should handle capability error gracefully", async () => {
+      const mock = getMockAblyRealtime();
+      const channel = mock.channels._getChannel("[meta]log:push");
+
+      channel.subscribe.mockRejectedValue(
+        Object.assign(
+          new Error("Channel denied access based on given capability"),
+          {
+            code: 40160,
+            statusCode: 401,
+            href: "https://help.ably.io/error/40160",
+          },
+        ),
+      );
+
+      const { error } = await runCommand(
+        ["logs:push:subscribe"],
+        import.meta.url,
+      );
+
+      expect(error).toBeDefined();
+      expect(error?.message).toContain("Channel denied access");
+    });
   });
 
   describe("functionality", () => {

test/unit/commands/logs/subscribe.test.ts

@@ -193,5 +193,26 @@ describe("logs:subscribe command", () => {
       expect(error).toBeDefined();
       expect(error?.message).toMatch(/No mock|client/i);
     });
+
+    it("should handle capability error gracefully", async () => {
+      const mock = getMockAblyRealtime();
+      const channel = mock.channels._getChannel("[meta]log");
+
+      channel.subscribe.mockRejectedValue(
+        Object.assign(
+          new Error("Channel denied access based on given capability"),
+          {
+            code: 40160,
+            statusCode: 401,
+            href: "https://help.ably.io/error/40160",
+          },
+        ),
+      );
+
+      const { error } = await runCommand(["logs:subscribe"], import.meta.url);
+
+      expect(error).toBeDefined();
+      expect(error?.message).toContain("Channel denied access");
+    });
   });
 });