@botdocs/cli 0.10.2 → 0.10.3

package/dist/index.js

@@ -21,8 +21,29 @@ import { registerTeamCommands } from './commands/team.js';
 import { registerBackupCommands } from './commands/backups.js';
 import { undo } from './commands/undo.js';
 import { createRequire } from 'node:module';
+import { WaitlistError } from './lib/api.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
+/** Top-level handler for the launch-day waitlist gate. When any command's
+ * `apiFetch` returns a 403 with the `waitlisted` body, the CLI exits 0 with
+ * a single friendly one-liner instead of a stack trace. Exit 0 because being
+ * on the waitlist isn't a malformed command — it's the expected state.
+ *
+ * We hook `unhandledRejection` rather than wrapping every command because
+ * commands use `process.exit(1)` inside their own error paths today; an
+ * outer try/catch around `program.parseAsync` wouldn't see throws from
+ * actions that commander dispatches as fire-and-forget. */
+process.on('unhandledRejection', (reason) => {
+    if (reason instanceof WaitlistError) {
+        process.stdout.write("You're on the BotDocs waitlist. We'll email you when there's space.\n" +
+            '(Check https://botdocs.ai/waitlist for status.)\n');
+        process.exit(0);
+    }
+    // Anything else: re-raise as a real failure so we don't silently swallow
+    // bugs. Mirrors Node's default behavior for un-handled rejections.
+    console.error(reason instanceof Error ? reason.stack ?? reason.message : reason);
+    process.exit(1);
+});
 const program = new Command();
 program
     .name('botdocs')

package/dist/lib/api.d.ts

@@ -13,6 +13,23 @@ export declare class ApiError extends Error {
     readonly body?: unknown;
     constructor(status: number, message: string, body?: unknown);
 }
+/** Thrown by apiFetch when the server replies 403 with `{ error: 'waitlisted',
+ * ... }` — meaning the caller is signed in but BotDocs is currently behind the
+ * waitlist gate and they haven't been admitted yet.
+ *
+ * Subclass of ApiError so existing `catch (err) { if (err instanceof ApiError)
+ * ... }` paths keep working; the index.ts top-level handler does an explicit
+ * `instanceof WaitlistError` check first to print a single friendly one-liner
+ * and exit 0 (this is not a user-facing error condition — the user is on the
+ * waitlist by design).
+ *
+ * Telemetry-style callers (`syncLibrary`) that already swallow errors will
+ * continue to swallow this one too — they catch every ApiError, so the new
+ * class lands inside the same catch arm.
+ */
+export declare class WaitlistError extends ApiError {
+    constructor(message: string, body?: unknown);
+}
 interface FetchOptions {
     method?: string;
     body?: unknown;

package/dist/lib/api.js

@@ -22,6 +22,35 @@ export class ApiError extends Error {
         this.body = body;
     }
 }
+/** Thrown by apiFetch when the server replies 403 with `{ error: 'waitlisted',
+ * ... }` — meaning the caller is signed in but BotDocs is currently behind the
+ * waitlist gate and they haven't been admitted yet.
+ *
+ * Subclass of ApiError so existing `catch (err) { if (err instanceof ApiError)
+ * ... }` paths keep working; the index.ts top-level handler does an explicit
+ * `instanceof WaitlistError` check first to print a single friendly one-liner
+ * and exit 0 (this is not a user-facing error condition — the user is on the
+ * waitlist by design).
+ *
+ * Telemetry-style callers (`syncLibrary`) that already swallow errors will
+ * continue to swallow this one too — they catch every ApiError, so the new
+ * class lands inside the same catch arm.
+ */
+export class WaitlistError extends ApiError {
+    constructor(message, body) {
+        super(403, message, body);
+        this.name = 'WaitlistError';
+    }
+}
+/** Type guard for the `{ error: 'waitlisted', ... }` JSON shape returned by
+ * `requireAdmitted` on the web side. Matches by string discriminant so a
+ * server-side rename of the field would break this exactly once, here, rather
+ * than silently disabling the friendly path. */
+function isWaitlistedBody(body) {
+    return (typeof body === 'object' &&
+        body !== null &&
+        body.error === 'waitlisted');
+}
 export async function apiFetch(path, options = {}) {
     const { method = 'GET', body, auth = false } = options;
     const baseUrl = getApiUrl();
@@ -67,6 +96,13 @@ export async function apiFetch(path, options = {}) {
         if (response.status === 401 && auth) {
             message = 'Authentication failed. Run `botdocs login` to sign in again.';
         }
+        // Distinct error type for the launch-day waitlist. Lets the top-level
+        // CLI handler print "You're on the BotDocs waitlist..." instead of a raw
+        // 403 trace, and lets background telemetry (syncLibrary) silently swallow
+        // it without surfacing anything to the user.
+        if (response.status === 403 && isWaitlistedBody(parsedBody)) {
+            throw new WaitlistError(parsedBody.message ?? message, parsedBody);
+        }
         throw new ApiError(response.status, message, parsedBody);
     }
     const contentType = response.headers.get('content-type') || '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botdocs/cli",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "CLI for BotDocs — author, publish, install, and sync agent skills across Claude, Claude Code, Cursor, Codex, ChatGPT, Windsurf, Copilot, Gemini, Antigravity, and OpenCode.",
   "keywords": [
     "botdocs",