novaapp-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,430 @@
+// src/client.ts
+import { io } from "socket.io-client";
+import { EventEmitter } from "events";
+
+// src/http.ts
+var HttpClient = class {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.token = token;
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}/api/bot${path}`;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
+        "User-Agent": "nova-bot-sdk/1.0.0"
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+    if (!res.ok) {
+      let message = res.statusText;
+      try {
+        const json = await res.json();
+        if (json.error) message = json.error;
+      } catch {
+      }
+      const err = new Error(`Nova API error ${res.status}: ${message}`);
+      err.status = res.status;
+      throw err;
+    }
+    if (res.status === 204) return void 0;
+    return res.json();
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/api/messages.ts
+var MessagesAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Send a message to a channel.
+   *
+   * @example
+   * await client.messages.send('channel-id', { content: 'Hello!' })
+   * await client.messages.send('channel-id', {
+   *   embed: { title: 'Report', description: 'Everything is fine.' }
+   * })
+   */
+  send(channelId, options) {
+    return this.http.post("/messages", { channelId, ...options });
+  }
+  /**
+   * Edit a message previously sent by this bot.
+   */
+  edit(messageId, options) {
+    return this.http.patch(`/messages/${messageId}`, options);
+  }
+  /**
+   * Delete a message previously sent by this bot.
+   */
+  delete(messageId) {
+    return this.http.delete(`/messages/${messageId}`);
+  }
+  /**
+   * Fetch recent messages from a channel.
+   */
+  fetch(channelId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.before) params.set("before", options.before);
+    const qs = params.toString();
+    return this.http.get(`/channels/${channelId}/messages${qs ? `?${qs}` : ""}`);
+  }
+  /**
+   * Send a typing indicator in a channel (appears for ~5 seconds).
+   */
+  typing(channelId) {
+    return this.http.post(`/channels/${channelId}/typing`);
+  }
+};
+
+// src/api/commands.ts
+var CommandsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // ── Slash Commands ────────────────────────────────────────────────────────
+  /**
+   * Register (or fully replace) slash commands.
+   * Pass `guildId` to register guild-specific commands; omit for global.
+   *
+   * @example
+   * await client.commands.setSlash([
+   *   { name: 'ping', description: 'Responds with pong!' },
+   *   { name: 'ban', description: 'Ban a user', options: [
+   *     { name: 'user', description: 'User to ban', type: 'USER', required: true }
+   *   ]}
+   * ])
+   */
+  setSlash(commands, guildId) {
+    return this.http.post("/commands", { commands, guildId });
+  }
+  /**
+   * Fetch all registered slash commands.
+   */
+  getSlash(guildId) {
+    const qs = guildId ? `?guildId=${encodeURIComponent(guildId)}` : "";
+    return this.http.get(`/commands${qs}`);
+  }
+  /**
+   * Delete a slash command by name.
+   */
+  deleteSlash(name) {
+    return this.http.delete(`/commands/${encodeURIComponent(name)}`);
+  }
+  // ── Prefix Commands ───────────────────────────────────────────────────────
+  /**
+   * Register (or fully replace) prefix commands.
+   *
+   * @example
+   * await client.commands.setPrefix([
+   *   { prefix: '!', name: 'help', description: 'Show help' },
+   *   { prefix: '!', name: 'kick', description: 'Kick a user' },
+   * ])
+   */
+  setPrefix(commands) {
+    return this.http.post("/prefix-commands", commands);
+  }
+  /**
+   * Fetch all registered prefix commands.
+   */
+  getPrefix() {
+    return this.http.get("/prefix-commands");
+  }
+  /**
+   * Delete a prefix command.
+   */
+  deletePrefix(prefix, name) {
+    return this.http.delete(
+      `/prefix-commands/${encodeURIComponent(prefix)}/${encodeURIComponent(name)}`
+    );
+  }
+  // ── Context Menu Commands ─────────────────────────────────────────────────
+  /**
+   * Register (or fully replace) context menu commands.
+   *
+   * @example
+   * await client.commands.setContext([
+   *   { name: 'Report message', target: 'MESSAGE' },
+   *   { name: 'View profile', target: 'USER' },
+   * ])
+   */
+  setContext(commands) {
+    return this.http.post("/context-commands", commands);
+  }
+  /**
+   * Fetch all registered context menu commands.
+   */
+  getContext() {
+    return this.http.get("/context-commands");
+  }
+  /**
+   * Delete a context menu command by name.
+   */
+  deleteContext(name) {
+    return this.http.delete(`/context-commands/${encodeURIComponent(name)}`);
+  }
+};
+
+// src/api/members.ts
+var MembersAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Fetch members of a server the bot is in.
+   *
+   * @example
+   * const members = await client.members.list('server-id', { limit: 50 })
+   */
+  list(serverId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    const qs = params.toString();
+    return this.http.get(`/servers/${serverId}/members${qs ? `?${qs}` : ""}`);
+  }
+  /**
+   * Kick a member from a server.
+   * Bots cannot kick owners or admins (403 will be thrown).
+   *
+   * @example
+   * await client.members.kick('server-id', 'user-id')
+   */
+  kick(serverId, userId) {
+    return this.http.post(`/servers/${serverId}/members/${userId}/kick`);
+  }
+  /**
+   * Ban a member from a server.
+   * Bots cannot ban owners or admins (403 will be thrown).
+   *
+   * @example
+   * await client.members.ban('server-id', 'user-id', 'Spamming')
+   */
+  ban(serverId, userId, reason) {
+    return this.http.post(`/servers/${serverId}/members/${userId}/ban`, { reason });
+  }
+};
+
+// src/api/servers.ts
+var ServersAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Fetch all servers the bot is currently a member of.
+   *
+   * @example
+   * const servers = await client.servers.list()
+   * console.log(`Bot is in ${servers.length} servers`)
+   */
+  list() {
+    return this.http.get("/servers");
+  }
+};
+
+// src/api/interactions.ts
+var InteractionsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Acknowledge an interaction without sending a visible response.
+   * Shows a loading state to the user. You must follow up with `respond()`.
+   *
+   * @example
+   * client.on('interactionCreate', async (interaction) => {
+   *   await client.interactions.ack(interaction.id)
+   *   // ... do work ...
+   *   await client.interactions.respond(interaction.id, { content: 'Done!' })
+   * })
+   */
+  ack(interactionId) {
+    return this.http.post(`/interactions/${interactionId}/ack`);
+  }
+  /**
+   * Respond to an interaction with a message.
+   * Set `ephemeral: true` to only show the response to the triggering user.
+   *
+   * @example
+   * await client.interactions.respond(interaction.id, {
+   *   content: 'Pong!',
+   *   ephemeral: true,
+   * })
+   */
+  respond(interactionId, options) {
+    return this.http.post(
+      `/interactions/${interactionId}/respond`,
+      options
+    );
+  }
+  /**
+   * Poll for pending (unacknowledged) interactions.
+   * Useful when not using the WebSocket gateway.
+   *
+   * @example
+   * const pending = await client.interactions.poll({ limit: 20 })
+   * for (const i of pending) {
+   *   await client.interactions.respond(i.id, { content: 'Got it!' })
+   * }
+   */
+  poll(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.since) params.set("since", options.since);
+    const qs = params.toString();
+    return this.http.get(`/interactions${qs ? `?${qs}` : ""}`);
+  }
+};
+
+// src/client.ts
+var EVENT_MAP = {
+  "message.created": "messageCreate",
+  "message.edited": "messageUpdate",
+  "message.deleted": "messageDelete",
+  "message.reaction_added": "reactionAdd",
+  "message.reaction_removed": "reactionRemove",
+  "user.joined_server": "memberAdd",
+  "user.left_server": "memberRemove",
+  "user.started_typing": "typingStart"
+};
+var NovaClient = class extends EventEmitter {
+  constructor(options) {
+    super();
+    /** The authenticated bot application. Available after `ready` fires. */
+    this.botUser = null;
+    this.socket = null;
+    if (!options.token) {
+      throw new Error("[nova-bot-sdk] A bot token is required.");
+    }
+    if (!options.token.startsWith("nova_bot_")) {
+      console.warn('[nova-bot-sdk] Warning: token does not start with "nova_bot_". Are you sure this is a bot token?');
+    }
+    this.options = {
+      token: options.token,
+      baseUrl: options.baseUrl ?? "https://api.nova.chat"
+    };
+    this.http = new HttpClient(this.options.baseUrl, this.options.token);
+    this.messages = new MessagesAPI(this.http);
+    this.commands = new CommandsAPI(this.http);
+    this.members = new MembersAPI(this.http);
+    this.servers = new ServersAPI(this.http);
+    this.interactions = new InteractionsAPI(this.http);
+  }
+  /**
+   * Connect to the Nova WebSocket gateway.
+   * Resolves when the `ready` event is received.
+   *
+   * @example
+   * await client.connect()
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      const gatewayUrl = this.options.baseUrl.replace(/\/$/, "") + "/bot-gateway";
+      this.socket = io(gatewayUrl, {
+        path: "/socket.io",
+        transports: ["websocket"],
+        auth: { botToken: this.options.token },
+        reconnection: true,
+        reconnectionAttempts: Infinity,
+        reconnectionDelay: 1e3,
+        reconnectionDelayMax: 3e4
+      });
+      const onConnectError = (err) => {
+        this.emit("error", { code: 0, message: err.message });
+        reject(err);
+      };
+      this.socket.once("connect_error", onConnectError);
+      this.socket.once("bot:ready", (data) => {
+        this.socket.off("connect_error", onConnectError);
+        this.botUser = { ...data.bot, scopes: data.scopes };
+        this.emit("ready", this.botUser);
+        resolve();
+      });
+      this.socket.on("interaction:created", (interaction) => {
+        this.emit("interactionCreate", interaction);
+      });
+      this.socket.on("bot:event", (event) => {
+        this.emit("event", event);
+        const shorthand = EVENT_MAP[event.type];
+        if (shorthand) {
+          this.emit(shorthand, event.data);
+        }
+      });
+      this.socket.on("bot:error", (err) => {
+        this.emit("error", err);
+      });
+      this.socket.on("disconnect", (reason) => {
+        this.emit("disconnect", reason);
+      });
+    });
+  }
+  /**
+   * Disconnect from the gateway and clean up.
+   */
+  disconnect() {
+    this.socket?.disconnect();
+    this.socket = null;
+  }
+  /**
+   * Send a message via the WebSocket gateway (lower latency than HTTP).
+   * Requires the `messages.write` scope.
+   *
+   * @example
+   * client.wsSend('channel-id', 'Hello from the gateway!')
+   */
+  wsSend(channelId, content) {
+    if (!this.socket?.connected) {
+      throw new Error("[nova-bot-sdk] Not connected. Call client.connect() first.");
+    }
+    this.socket.emit("bot:message:send", { channelId, content });
+  }
+  /**
+   * Start a typing indicator via WebSocket.
+   */
+  wsTypingStart(channelId) {
+    this.socket?.emit("bot:typing:start", { channelId });
+  }
+  /**
+   * Stop a typing indicator via WebSocket.
+   */
+  wsTypingStop(channelId) {
+    this.socket?.emit("bot:typing:stop", { channelId });
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+export {
+  CommandsAPI,
+  HttpClient,
+  InteractionsAPI,
+  MembersAPI,
+  MessagesAPI,
+  NovaClient,
+  ServersAPI
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "novaapp-sdk",
+  "version": "1.0.0",
+  "description": "Official SDK for building bots on the Nova platform",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": ["nova", "bot", "sdk", "discord-like", "chat"],
+  "author": "Nova",
+  "license": "MIT",
+  "dependencies": {
+    "socket.io-client": "^4.8.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}