@whanext/core 0.13.1 → 0.14.1

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,45 @@ 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());
+  }
+  get jid() {
+    const identity = this.ids.find((candidate) => candidate.endsWith("@s.whatsapp.net") || candidate.endsWith("@c.us"));
+    if (identity) {
+      return normalizeIdentity(identity);
+    }
+    const phone = this.ids.map((candidate) => identityPhoneNumber(candidate)).find((candidate) => candidate !== void 0);
+    return phone ? `${phone}@s.whatsapp.net` : void 0;
+  }
+  get lid() {
+    const identity = this.ids.find((candidate) => candidate.endsWith("@lid"));
+    return identity ? normalizeIdentity(identity) : void 0;
+  }
+  get phoneNumber() {
+    const jid = this.jid;
+    return jid ? identityPhoneNumber(jid) : void 0;
+  }
+  get selfChatId() {
+    return this.jid ?? this.lid ?? this.ids[0];
+  }
+  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;
@@ -1861,7 +1919,7 @@ var MediaService = class {
     return this.#provider.sendMessage(chatId, content);
   }
   download(message) {
-    const key = "keys" in message ? message.keys : message;
+    const key = "keys" in message ? message.keys : "key" in message ? message.key : message;
     return this.#provider.downloadMedia(key);
   }
 };
@@ -1982,6 +2040,7 @@ var MessageService = class {
 
 // src/app/whanext-app.ts
 var WhaNextApp = class {
+  account;
   message;
   media;
   group;
@@ -2000,6 +2059,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 +2074,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 +2123,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(
@@ -2289,6 +2350,13 @@ function unwrapMessageContent(input) {
   const nested = content.ephemeralMessage?.message ?? content.viewOnceMessage?.message ?? content.viewOnceMessageV2?.message ?? content.viewOnceMessageV2Extension?.message;
   return nested ? unwrapMessageContent(nested) : content;
 }
+function isViewOnceContent(input) {
+  if (!input) return false;
+  if (input.viewOnceMessage?.message || input.viewOnceMessageV2?.message || input.viewOnceMessageV2Extension?.message) {
+    return true;
+  }
+  return isViewOnceContent(input.ephemeralMessage?.message);
+}
 function extractQuotedBaileysMessage(input) {
   const chatId = input.key.remoteJid;
   const content = unwrapMessageContent(input.message);
@@ -2334,7 +2402,8 @@ function normalizeBaileysMessage(input) {
     ...input.pushName ? { name: input.pushName } : {}
   });
   const mentionedUsers = (context?.mentionedJid ?? []).map((identity) => User.fromIdentities([identity]));
-  const media = getMedia(type, node, Boolean(input.key.isViewOnce));
+  const viewOnce = Boolean(input.key.isViewOnce) || isViewOnceContent(input.message);
+  const media = getMedia(type, node, viewOnce);
   const contentKind = getContentKind(type);
   const text = getText(content);
   const caption = getCaption(content);
@@ -2454,21 +2523,26 @@ function getQuoted(context, chatId) {
     return void 0;
   }
   const quoted = context.quotedMessage;
+  const quotedIsViewOnce = isViewOnceContent(quoted);
   const content = unwrapMessageContent(quoted);
+  const type = content ? getContentType(content) : void 0;
+  const node = type && content ? content[type] : void 0;
+  const media = getMedia(type, node, quotedIsViewOnce);
   const result = {
     key: {
       id: context.stanzaId,
       chatId: context.remoteJid ?? chatId,
       fromMe: false
     },
-    hasMedia: Boolean(
-      content && getMedia(
-        getContentType(content),
-        content[getContentType(content) ?? "conversation"],
-        false
-      )
-    )
+    hasMedia: media !== void 0,
+    isViewOnce: media?.viewOnce ?? quotedIsViewOnce
   };
+  if (content) {
+    result.contentKind = getContentKind(type);
+  }
+  if (media) {
+    result.media = media;
+  }
   if (context.participant) {
     result.senderId = context.participant;
     result.sender = User.fromIdentities([context.participant]);
@@ -2828,9 +2902,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 +3095,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 +3105,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 +3382,23 @@ var guards = {
   }
 };
 export {
+  AccountService,
   ArgsParser,
   Browser,
   CommandRouter,
   DeferredReply,
   Logger,
   MemoryCache,
+  MultiCommandRouter,
   MuteService,
   ParsedCommandOptions,
   SqliteMuteStore,
   User,
   WhaNextApp,
   WhaNextError,
+  WhaNextMultiApp,
   create,
+  createMulti,
   defineCommand,
   defineCommandGroup,
   defineCommands,