@whanext/core 0.13.1 → 0.14.0

package/dist/index.js

@@ -370,7 +370,7 @@ var CommandConcurrencyController = class {
         recoverable: true
       });
     } else if (strategy === "queue" && state.active >= max) {
-      await new Promise((resolve2) => state.queue.push(resolve2));
+      await new Promise((resolve3) => state.queue.push(resolve3));
     }
     const controller = new AbortController();
     state.controllers.add(controller);
@@ -392,6 +392,8 @@ var CommandConcurrencyController = class {
 var CommandContextImplementation = class {
   message;
   user;
+  account;
+  isOwner;
   chat;
   group;
   command;
@@ -413,6 +415,8 @@ var CommandContextImplementation = class {
   constructor(options) {
     this.message = options.message;
     this.user = options.message.sender;
+    this.account = options.services.account;
+    this.isOwner = this.account.isOwner(options.message);
     this.chat = { id: options.message.chatId, isGroup: options.message.isGroup };
     this.command = options.command;
     this.commands = options.commands;
@@ -979,6 +983,12 @@ _Nenhum comando dispon\xEDvel._`;
     }
   }
   async #authorizeLegacy(command, context) {
+    if (command.onlyOwner && !context.isOwner) {
+      throw new WhaNextError(
+        "COMMAND_NOT_ALLOWED",
+        "This command can only be used by the connected WhatsApp account."
+      );
+    }
     if (command.onlyGroup && !context.isGroup) {
       throw new WhaNextError("COMMAND_NOT_ALLOWED", "This command can only be used in groups.");
     }
@@ -1158,6 +1168,15 @@ function createLegacyServices(group) {
     }
   });
   return {
+    account: {
+      id: void 0,
+      get ids() {
+        return [];
+      },
+      isOwner(message) {
+        return message.keys.fromMe;
+      }
+    },
     groups: group,
     users: new UserService(group),
     messages: unavailable,
@@ -1696,6 +1715,26 @@ var TypedEventEmitter = class {
   }
 };
 
+// src/services/account-service.ts
+var AccountService = class {
+  id;
+  #provider;
+  constructor(provider, id) {
+    this.#provider = provider;
+    this.id = id;
+  }
+  get ids() {
+    return uniqueIdentities(this.#provider.getCurrentUserIds());
+  }
+  isOwner(message) {
+    if (message.keys.fromMe) {
+      return true;
+    }
+    const currentIds = this.ids;
+    return message.senderIds.some((senderId) => currentIds.some((currentId) => identitiesMatch(senderId, currentId)));
+  }
+};
+
 // src/services/chat-service.ts
 var ChatService = class {
   #provider;
@@ -1982,6 +2021,7 @@ var MessageService = class {
 
 // src/app/whanext-app.ts
 var WhaNextApp = class {
+  account;
   message;
   media;
   group;
@@ -2000,6 +2040,7 @@ var WhaNextApp = class {
   constructor(provider, options = {}, logger = new Logger(options.logger)) {
     this.#provider = provider;
     this.#phone = options.phone;
+    this.account = new AccountService(provider, options.accountId);
     this.logger = logger;
     const cache = options.cache?.store ?? new MemoryCache(
       options.cache?.memoryMaxEntries === void 0 ? void 0 : { maxEntries: options.cache.memoryMaxEntries }
@@ -2014,6 +2055,7 @@ var WhaNextApp = class {
     const muteStore = muteEnabled ? options.mute?.store ?? new SqliteMuteStore(options.mute?.database) : void 0;
     this.mute = new MuteService(provider, muteStore);
     this.commands = new CommandRouter({
+      account: this.account,
       messages: this.message,
       media: this.media,
       groups: this.group,
@@ -2062,9 +2104,9 @@ var WhaNextApp = class {
     this.logger.info("Login started");
     let unsubscribe = () => void 0;
     let timer;
-    const connected = new Promise((resolve2, reject) => {
+    const connected = new Promise((resolve3, reject) => {
       unsubscribe = this.#provider.on("connection", (update) => {
-        if (update.state === "connected") resolve2();
+        if (update.state === "connected") resolve3();
         if (update.state === "closed") {
           reject(
             new WhaNextError(
@@ -2828,9 +2870,9 @@ var BaileysProvider = class {
     );
   }
   #browserDescription() {
-    if (this.#options.browser === "macos" /* MacOS */) return Browsers.macOS("Chrome");
+    if (this.#options.browser === "macos" /* MacOS */) return Browsers.macOS("Safari");
     if (this.#options.browser === "ubuntu" /* Ubuntu */) return Browsers.ubuntu("Chrome");
-    return Browsers.windows("Chrome");
+    return Browsers.windows("Brave");
   }
   #isTerminal(error) {
     const statusCode = this.#statusCode(error);
@@ -3021,6 +3063,7 @@ async function create(options = {}) {
     ...options.reconnect ? { reconnect: options.reconnect } : {}
   });
   return new WhaNextApp(provider, {
+    ...options.accountId ? { accountId: options.accountId } : {},
     ...options.phone ? { phone: options.phone } : {},
     ...options.prefix !== void 0 ? { prefix: options.prefix } : {},
     ...options.cache ? { cache: options.cache } : {},
@@ -3030,8 +3073,243 @@ async function create(options = {}) {
   }, logger);
 }
 
+// src/app/multi-app.ts
+import {
+  join,
+  resolve as resolve2
+} from "path";
+var MultiCommandRouter = class {
+  #apps;
+  constructor(apps) {
+    this.#apps = apps;
+  }
+  command(definition) {
+    for (const app of this.#apps.values()) {
+      app.commands.command(definition);
+    }
+    return this;
+  }
+  use(middleware) {
+    for (const app of this.#apps.values()) {
+      app.commands.use(middleware);
+    }
+    return this;
+  }
+  onError(handler) {
+    const unsubscribe = [...this.#apps.values()].map((app) => app.commands.onError(handler));
+    return () => {
+      for (const remove of unsubscribe) remove();
+    };
+  }
+  async load(dirPath, options = {}) {
+    return Promise.all([...this.#apps].map(async ([accountId, app]) => ({
+      accountId,
+      result: await app.commands.load(dirPath, options)
+    })));
+  }
+};
+var WhaNextMultiApp = class {
+  commands;
+  #apps;
+  constructor(apps) {
+    this.#apps = apps;
+    this.commands = new MultiCommandRouter(apps);
+  }
+  get size() {
+    return this.#apps.size;
+  }
+  get isReady() {
+    return this.#apps.size > 0 && [...this.#apps.values()].every((app) => app.isReady);
+  }
+  ids() {
+    return [...this.#apps.keys()];
+  }
+  has(accountId) {
+    return this.#apps.has(accountId);
+  }
+  get(accountId) {
+    return this.#apps.get(accountId);
+  }
+  values() {
+    return [...this.#apps.values()];
+  }
+  router() {
+    return this.commands;
+  }
+  on(event, listener) {
+    const unsubscribe = [...this.#apps].map(([accountId, app]) => app.on(event, (payload) => listener({ accountId, app, payload })));
+    return () => {
+      for (const remove of unsubscribe) remove();
+    };
+  }
+  health() {
+    return [...this.#apps].map(([accountId, app]) => ({
+      accountId,
+      ...app.health()
+    }));
+  }
+  async login(options = {}) {
+    const results = await Promise.allSettled(
+      [...this.#apps].map(async ([accountId, app]) => {
+        await app.login({
+          ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+          ...options.onCode ? { onCode: (code) => options.onCode?.(accountId, code) } : {}
+        });
+      })
+    );
+    const failures = results.map((result, index) => ({ result, accountId: this.ids()[index] })).filter((entry) => entry.result.status === "rejected" && entry.accountId !== void 0);
+    if (failures.length === 0) {
+      return;
+    }
+    throw new WhaNextError(
+      "CONNECTION_FAILED",
+      "One or more WhatsApp accounts could not complete login.",
+      {
+        cause: new AggregateError(
+          failures.map(({ result }) => result.reason),
+          "Multi-account login failed."
+        ),
+        context: {
+          accounts: failures.map(({ accountId }) => accountId)
+        },
+        recoverable: true
+      }
+    );
+  }
+  async disconnect() {
+    const results = await Promise.allSettled(
+      [...this.#apps.values()].map((app) => app.disconnect())
+    );
+    const failures = results.filter((result) => result.status === "rejected");
+    if (failures.length > 0) {
+      throw new WhaNextError(
+        "CONNECTION_FAILED",
+        "One or more WhatsApp accounts could not disconnect cleanly.",
+        {
+          cause: new AggregateError(
+            failures.map((result) => result.reason),
+            "Multi-account disconnect failed."
+          ),
+          recoverable: true
+        }
+      );
+    }
+  }
+};
+async function createMulti(options) {
+  if (options.accounts.length === 0) {
+    throw new WhaNextError(
+      "ARGUMENT_INVALID",
+      "At least one WhatsApp account is required."
+    );
+  }
+  const {
+    accounts,
+    authRoot = "./sessions",
+    ...shared
+  } = options;
+  const normalizedIds = /* @__PURE__ */ new Set();
+  const authPaths = /* @__PURE__ */ new Set();
+  for (const account of accounts) {
+    validateAccountId(account.id);
+    const normalizedId = account.id.toLowerCase();
+    if (normalizedIds.has(normalizedId)) {
+      throw new WhaNextError(
+        "ARGUMENT_INVALID",
+        `The multi-account id "${account.id}" is duplicated.`
+      );
+    }
+    normalizedIds.add(normalizedId);
+    if (account.provider === void 0) {
+      const authPath = resolve2(account.auth ?? join(authRoot, account.id));
+      if (authPaths.has(authPath)) {
+        throw new WhaNextError(
+          "ARGUMENT_INVALID",
+          "Each WhatsApp account must use a different auth directory.",
+          { context: { auth: authPath } }
+        );
+      }
+      authPaths.add(authPath);
+    }
+  }
+  const apps = /* @__PURE__ */ new Map();
+  for (const account of accounts) {
+    const {
+      id,
+      ...overrides
+    } = account;
+    const merged = mergeCreateOptions(shared, overrides);
+    if (merged.mute?.enabled === true && merged.mute.store === void 0 && merged.mute.database === void 0) {
+      merged.mute = {
+        ...merged.mute,
+        database: join("./data", `whanext-${id}.sqlite`)
+      };
+    }
+    const app = await create({
+      ...merged,
+      accountId: id,
+      auth: overrides.auth ?? join(authRoot, id)
+    });
+    apps.set(id, app);
+  }
+  return new WhaNextMultiApp(apps);
+}
+function validateAccountId(accountId) {
+  if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(accountId)) {
+    throw new WhaNextError(
+      "ARGUMENT_INVALID",
+      "Multi-account ids must use lowercase letters, numbers, underscores or hyphens.",
+      { context: { accountId } }
+    );
+  }
+}
+function mergeCreateOptions(shared, account) {
+  const merged = {
+    ...shared,
+    ...account
+  };
+  if (shared.cache || account.cache) {
+    merged.cache = {
+      ...shared.cache,
+      ...account.cache
+    };
+  }
+  if (shared.mute || account.mute) {
+    merged.mute = {
+      ...shared.mute,
+      ...account.mute
+    };
+  }
+  if (shared.router || account.router) {
+    merged.router = {
+      ...shared.router,
+      ...account.router
+    };
+  }
+  if (shared.reconnect || account.reconnect) {
+    merged.reconnect = {
+      ...shared.reconnect,
+      ...account.reconnect
+    };
+  }
+  if (shared.logger && account.logger && typeof shared.logger === "object" && typeof account.logger === "object") {
+    merged.logger = {
+      ...shared.logger,
+      ...account.logger
+    };
+  }
+  return merged;
+}
+
 // src/commands/guards.ts
 var guards = {
+  owner() {
+    return (context) => context.isOwner || {
+      allowed: false,
+      code: "COMMAND_NOT_ALLOWED",
+      message: "This command can only be used by the connected WhatsApp account."
+    };
+  },
   group() {
     return (context) => context.isGroup || {
       allowed: false,
@@ -3072,19 +3350,23 @@ var guards = {
   }
 };
 export {
+  AccountService,
   ArgsParser,
   Browser,
   CommandRouter,
   DeferredReply,
   Logger,
   MemoryCache,
+  MultiCommandRouter,
   MuteService,
   ParsedCommandOptions,
   SqliteMuteStore,
   User,
   WhaNextApp,
   WhaNextError,
+  WhaNextMultiApp,
   create,
+  createMulti,
   defineCommand,
   defineCommandGroup,
   defineCommands,