viber-channel 0.5.2 → 0.6.0

package/viber-channel.ts

@@ -28,13 +28,27 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { mkdirSync, writeFileSync, readFileSync, unlinkSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { runConnect } from "./lib/connect.ts";
 import { lockFilePath } from "./lib/lockfile.ts";
+import { sessionFilePath, clearHandle } from "./lib/channel_session.ts";
+import { clientFingerprint } from "./lib/fingerprint.ts";
+import { MessageDedup } from "./lib/message_dedup.ts";
+import {
+  acquireConversation,
+  ConversationMintError,
+  DEFAULT_REATTACH_WINDOW_SECONDS,
+  type ConversationMintResponse,
+} from "./lib/conversation.ts";
+import { acquireInstance, registerInstance } from "./lib/instance.ts";
+import { runPersistentControlStream } from "./lib/control_stream.ts";
+import { isOwnMessage } from "./lib/self_echo.ts";
 import {
   createTokenRefreshScheduler,
   type TokenRefreshScheduler,
 } from "./lib/token_refresh.ts";
+import { awaitStableStartup } from "./lib/startup_gate.ts";
 
 // ---- CLI subcommand dispatch (must happen before lock acquire + loadAuth) ----
 //
@@ -42,6 +56,22 @@ import {
 // exits — it does not start the MCP server. Any other invocation (no args, or
 // the unknown subcommand) falls through to the MCP server below.
 {
+  // #280 step-29: in an AGENT session (vibe-master terminal), the channel must
+  // be the PLUGIN copy (`--channels plugin:viber-channel@…` — only it can
+  // inject inbound messages). The manually-registered viber-dev-channel MCP
+  // loads in the same session with the same env; instead of racing it for the
+  // channel lock, it bows out deterministically here. Normal sessions
+  // (no VIBER_CHANNEL_AGENT_SESSION) are unaffected.
+  if (
+    process.env.VIBER_CHANNEL_AGENT_SESSION === "1" &&
+    process.env.VIBER_CHANNEL_PLUGIN !== "1"
+  ) {
+    process.stderr.write(
+      "[viber-channel] agent session: yielding to the plugin channel copy (manual MCP registration exits)\n",
+    );
+    process.exit(0);
+  }
+
   const sub = process.argv[2];
   if (sub === "--help" || sub === "-h") {
     process.stdout.write(
@@ -74,15 +104,84 @@ import {
 }
 
 // Lock file path: %APPDATA%/viber/ (Windows) or ~/.config/viber/ (Linux/Mac).
-// Namespaced by VIBER_BASE_URL so channels targeting different backends
-// (staging + dev) coexist on the same machine — only same-backend duplicates
-// still collide, which is the intended guard.
+// Namespaced by (VIBER_BASE_URL, client_fingerprint, VIBER_CHANNEL_SESSION_ID) so:
+//   - channels at different backends (staging + dev) coexist (different base_url);
+//   - two DIFFERENT projects on the same backend never collide — the fingerprint
+//     (deterministic per machine + folder) is the only axis that isolates them
+//     for a normal bunx client, where the session id is always "" (#267);
+//   - two concurrent launches of the SAME project coexist when each launcher
+//     supplies a per-launch session id (#259);
+//   - channel respawns within one launch inherit the same session id and
+//     re-acquire the same lock — accidental duplicates still blocked (#166).
+//
+// LOCK_FINGERPRINT is computed from the current folder (process.cwd()) rather
+// than read from auth.json so the lock paths are available before loadAuth();
+// it is verified equal to auth.client_fingerprint below — a mismatch exits.
 const LOCK_DIR =
   process.env.APPDATA
     ? join(process.env.APPDATA, "viber")
     : join(process.env.HOME ?? "/tmp", ".config", "viber");
 const LOCK_BASE_URL = process.env.VIBER_BASE_URL ?? "https://viber.dgypx.dev";
-const LOCK_FILE = lockFilePath(LOCK_BASE_URL, LOCK_DIR);
+// #269: a fleet's parallel agents each carry their own VIBER_INSTANCE_TOKEN but
+// often no VIBER_CHANNEL_SESSION_ID. Fold a HASH of the instance token into the
+// lock's session axis so distinct env-injected instances get distinct locks
+// (parallel same-folder agents no longer collide) — without reordering instance
+// acquisition before the lock, which would defeat the #257 stability gate. An
+// explicit VIBER_CHANNEL_SESSION_ID still wins (back-compat). The token is
+// hashed (never raw) because LOCK_SESSION_ID is logged as a prefix below.
+const LOCK_SESSION_ID =
+  process.env.VIBER_CHANNEL_SESSION_ID ??
+  (process.env.VIBER_INSTANCE_TOKEN
+    ? `inst-${createHash("sha256").update(process.env.VIBER_INSTANCE_TOKEN).digest("hex").slice(0, 16)}`
+    : "");
+const LOCK_FINGERPRINT = clientFingerprint(process.cwd());
+const LOCK_FILE = lockFilePath(LOCK_BASE_URL, LOCK_FINGERPRINT, LOCK_SESSION_ID, LOCK_DIR);
+// SESSION_FILE (the conversation handle path) is computed AFTER the instance is
+// acquired (#269) — it is namespaced by the server-issued instance, not the
+// local fingerprint/sessionId. Declared as a `let` near the mint below.
+
+// VIBER_REATTACH_WINDOW_SECONDS overrides the default TTL-based window.
+// A handle older than this cannot point at a live conversation — skip reattach.
+// Parsed once, mirroring the VIBER_REFRESH_LEAD_SECONDS pattern below: validate
+// finite && >= 0, log invalid→ignore, log override, fall back to the default.
+const REATTACH_WINDOW_SECONDS: number = (() => {
+  const raw = process.env.VIBER_REATTACH_WINDOW_SECONDS;
+  if (raw === undefined) return DEFAULT_REATTACH_WINDOW_SECONDS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    process.stderr.write(
+      `[viber-channel] Invalid VIBER_REATTACH_WINDOW_SECONDS=${raw}, ignoring.\n`
+    );
+    return DEFAULT_REATTACH_WINDOW_SECONDS;
+  }
+  process.stderr.write(
+    `[viber-channel] reattach window overridden to ${parsed}s via VIBER_REATTACH_WINDOW_SECONDS\n`
+  );
+  return parsed;
+})();
+
+// VIBER_STABILITY_DELAY_MS: how long to wait after mcp.connect() before
+// creating a conversation. A doomed process (broken-pipe respawn) dies during
+// this window via the stdin "end" handler, setting shuttingDown=true — the gate
+// then skips acquireConversation and the conversation is never created.
+// Default: 500ms (observed broken-pipe deaths are ~0s; 500ms is imperceptible).
+// Set to 0 to disable (useful for tests / custom launchers).
+const DEFAULT_STABILITY_DELAY_MS = 500;
+const STABILITY_DELAY_MS: number = (() => {
+  const raw = process.env.VIBER_STABILITY_DELAY_MS;
+  if (raw === undefined) return DEFAULT_STABILITY_DELAY_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    process.stderr.write(
+      `[viber-channel] Invalid VIBER_STABILITY_DELAY_MS=${raw}, ignoring.\n`
+    );
+    return DEFAULT_STABILITY_DELAY_MS;
+  }
+  process.stderr.write(
+    `[viber-channel] stability delay overridden to ${parsed}ms via VIBER_STABILITY_DELAY_MS\n`
+  );
+  return parsed;
+})();
 
 function isProcessAlive(pid: number): boolean {
   try {
@@ -147,8 +246,17 @@ function releaseLock(): void {
 // completes on slow boots) can cancel it idempotently via optional-chaining.
 let scheduler: TokenRefreshScheduler | null = null;
 
+// Stability gate flag (#257): set true as soon as any shutdown path begins so
+// the gate can observe an in-flight shutdown and abort conversation creation.
+let shuttingDown = false;
+
 // Best-effort cleanup — on Windows, signals may not fire (TerminateProcess)
 process.on("exit", () => { scheduler?.cancel(); releaseLock(); });
+// NOTE: shuttingDown is NOT set here. SIGINT/SIGTERM call process.exit(0) synchronously,
+// so the event loop ends before any setTimeout (the stability gate) can observe the flag.
+// Only the stdin `end` handler sets shuttingDown=true, because it does NOT call
+// process.exit() synchronously — it fires before the MCP transport's read loop begins,
+// giving the gate's setTimeout a chance to run and check the flag.
 process.on("SIGINT", () => { scheduler?.cancel(); releaseLock(); process.exit(0); });
 process.on("SIGTERM", () => { scheduler?.cancel(); releaseLock(); process.exit(0); });
 
@@ -166,6 +274,7 @@ process.on("SIGTERM", () => { scheduler?.cancel(); releaseLock(); process.exit(0
 // `end` fires on real EOF (parent closes write end) and is sufficient for
 // orphan detection. See plan #236 step-09 for the diagnosis.
 process.stdin.on("end", () => {
+  shuttingDown = true;
   process.stderr.write("[viber-channel] stdin closed (parent exited), shutting down\n");
   scheduler?.cancel();
   releaseLock();
@@ -174,20 +283,19 @@ process.stdin.on("end", () => {
 
 // ---- Auth from .viber/auth.json ----
 
-import { loadAuth, updateAuthToken } from "./lib/auth.ts";
+import { authFilePath, loadAuth, persistInstanceCredentials } from "./lib/auth.ts";
 import { handleConversationTokenExpired } from "./lib/channel_errors.ts";
 import { buildSseUrl } from "./lib/urls.ts";
 
-let auth = loadAuth();
+const auth = loadAuth();
 
 // ---- Fingerprint verification ----
-
-import { clientFingerprint } from "./lib/fingerprint.ts";
-
-const computedFp = clientFingerprint(process.cwd());
-if (computedFp !== auth.client_fingerprint) {
+//
+// LOCK_FINGERPRINT (computed above from process.cwd()) is the same value; this
+// re-checks it against the fingerprint stored in auth.json and exits on drift.
+if (LOCK_FINGERPRINT !== auth.client_fingerprint) {
   process.stderr.write(
-    `[viber-channel] Folder fingerprint mismatch — \`.viber/auth.json\` was issued for a different machine/folder.\n` +
+    `[viber-channel] Folder fingerprint mismatch — \`${authFilePath()}\` was issued for a different machine/folder.\n` +
     `Re-run the connect flow at https://viber.dgypx.dev/projects.\n`
   );
   process.exit(1);
@@ -197,11 +305,9 @@ if (computedFp !== auth.client_fingerprint) {
 
 import {
   defaultLabel,
-  mintConversation,
   refreshConversationToken,
   RefreshHttpError,
   RefreshNetworkError,
-  ReverifyRequiredError,
 } from "./lib/conversation.ts";
 import { postMessage, ConversationTokenExpiredError, parseArtifact } from "./lib/messages.ts";
 import { cfAccessHeaders } from "./lib/cfAccess.ts";
@@ -221,6 +327,7 @@ const mcp = new Server(
     instructions: [
       'Voice transcripts arrive as <channel source="viber-channel"> events carrying the user\'s microphone speech.',
       "Reply with send_message. The `text` field is read aloud to the user, so keep it a short, natural spoken sentence — no markdown symbols, no bullet lists, no tables, no code blocks.",
+      "Exception for inline identifiers: when mentioning a file name, hostname, variable, or other short token inline (auth.json, viber-dev.dgypx.dev, CONVERSATION_TOKEN), write the literal form with its real dots and dashes — do NOT spell them out as 'point' or 'dash'. The 'no markdown' rule is about visual clutter (`**bold**`, `- bullets`, code fences, tables, long path lists), not the punctuation that's naturally part of identifiers.",
       "Put technical content (code, lists, JSON, tables, command output, long file paths) in the optional `artifact` field with the matching `format`; it renders in a side viewer the user can read.",
       "Available formats: `markdown` (default), `code`, `json`, `html`.",
       "Use `html` only when the rendering needs structural HTML markdown can't express (styled cards, badges, mixed layouts). Scripts and event handlers are stripped server-side; don't try to send executable JS.",
@@ -337,8 +444,14 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
   };
 });
 
-// Prevent duplicate instances (#166)
-process.stderr.write(`[viber-channel] startup: pid=${process.pid}, acquiring lock\n`);
+// Prevent duplicate instances (#166); fingerprint namespacing for different
+// projects (#267); session-id namespacing for concurrent launches of the same
+// project (#259). The fingerprint and session-id prefixes are logged so a user
+// with multiple channels can tell their stderr logs apart.
+const sessionIdLogged = LOCK_SESSION_ID === "" ? "<unset>" : LOCK_SESSION_ID.slice(0, 8);
+process.stderr.write(
+  `[viber-channel] startup: pid=${process.pid}, fp=${LOCK_FINGERPRINT.slice(0, 8)}, sessionId=${sessionIdLogged}, acquiring lock\n`,
+);
 const blockingPid = acquireLock();
 process.stderr.write(`[viber-channel] startup: lock acquired (blockingPid=${blockingPid})\n`);
 
@@ -362,38 +475,129 @@ if (blockingPid !== null) {
   process.exit(1);
 }
 
-// ---- Mint conversation token (after mcp.connect so reverify notifications can be sent) ----
+// ---- Stability gate (#257): defer conversation creation so a doomed process exits first ----
+//
+// Claude Code respawns the channel on transport reconnects; a process that dies
+// within the first second (broken-pipe) had already created a conversation
+// because acquireConversation() ran immediately. The gate delays that call so
+// the stdin "end" handler can set shuttingDown=true and let process.exit(0)
+// race the timer. If the gate sees shuttingDown, it exits without creating a
+// conversation. A healthy process proceeds after STABILITY_DELAY_MS with no
+// user-perceptible delay (the user has not spoken yet at that point).
+
+process.stderr.write(`[viber-channel] startup: stability gate (${STABILITY_DELAY_MS}ms)...\n`);
+const gateOpen = await awaitStableStartup(STABILITY_DELAY_MS, () => shuttingDown);
+if (!gateOpen) {
+  process.stderr.write(`[viber-channel] startup: stability gate detected shutdown — skipping conversation creation\n`);
+  process.exit(0);
+}
+process.stderr.write(`[viber-channel] startup: stability gate passed (${STABILITY_DELAY_MS}ms), acquiring conversation\n`);
+
+// ---- Acquire conversation token (reattach or mint, after mcp.connect so a token-rejected notification can be sent) ----
 
 let CONVERSATION_TOKEN: string;
 let VOICE_BASE_URL: string;
 let CONVERSATION_ID: string;
+let SESSION_FILE = "";
+// This channel's own server-issued instance id (#280 step-16). Used by the
+// self-echo guard: messages posted by this instance are NOT surfaced back to
+// Claude when the conversation SSE replays them.
+let OWN_INSTANCE_ID = "";
 
-process.stderr.write(`[viber-channel] startup: calling mintConversation (project=${auth.project_id}, target=${auth.target_conversation_id ?? "null"})\n`);
 try {
-  const minted = await mintConversation(
-    BASE_URL,
-    auth.project_id,
-    auth.project_token,
-    auth.client_fingerprint,
-    label,
-    auth.target_conversation_id ?? null,
-  );
-  process.stderr.write(`[viber-channel] startup: mint OK, conv_id=${minted.conversation_id}\n`);
-
-  // Apply token rotation if the server issued a new project_token
-  if (minted.new_project_token) {
-    try {
-      auth = updateAuthToken(process.cwd(), auth, minted.new_project_token);
-    } catch (err) {
-      process.stderr.write(`[viber-channel] Warning: failed to update .viber/auth.json: ${String(err)}\n`);
-      // Don't exit — token is valid in memory; auth.json will be stale but channel keeps running
+  // #269: acquire this channel's server-issued instance identity — env-injected
+  // VIBER_INSTANCE_TOKEN > persisted auth.json instance_token > register a new
+  // one with the stable project_token (self-healing auth.json). The conversation
+  // handle is namespaced by the instance, not the local fingerprint/sessionId.
+  const acquired = await acquireInstance(BASE_URL, auth, auth.client_fingerprint);
+  let instanceToken = acquired.instance_token;
+  // Self-echo guard (#280 step-16) needs the REAL server instance id — never the
+  // token that instance_key may fall back to (Codex review P1). Undefined → ""
+  // → the guard is a no-op (delivers everything), which is the safe default.
+  OWN_INSTANCE_ID = acquired.instance_id ?? "";
+  SESSION_FILE = sessionFilePath(LOCK_BASE_URL, acquired.instance_key, LOCK_DIR);
+
+  process.stderr.write(`[viber-channel] startup: acquiring conversation (project=${auth.project_id}, target=${auth.target_conversation_id ?? "null"}, session=${SESSION_FILE})\n`);
+
+  // Join the conversation with the instance_token. A 401 means the instance was
+  // revoked (the token is durable — no expiry case): re-register a fresh instance
+  // ONCE (a NEW instance_id, the correct post-revocation outcome) and retry. A
+  // second failure falls through to the catch below.
+  let minted: ConversationMintResponse;
+  try {
+    minted = await acquireConversation(
+      SESSION_FILE,
+      BASE_URL,
+      auth.project_id,
+      instanceToken,
+      auth.client_fingerprint,
+      label,
+      auth.target_conversation_id ?? null,
+      REATTACH_WINDOW_SECONDS,
+    );
+  } catch (err) {
+    if (err instanceof ConversationMintError && err.status === 401) {
+      process.stderr.write(
+        `[viber-channel] instance token rejected (401 revoked) — re-registering a fresh instance once\n`,
+      );
+      const reg = await registerInstance(
+        BASE_URL,
+        auth.project_id,
+        auth.project_token,
+        auth.client_fingerprint,
+      );
+      persistInstanceCredentials(authFilePath(), reg.instance_id, reg.instance_token);
+      instanceToken = reg.instance_token;
+      OWN_INSTANCE_ID = reg.instance_id;
+      SESSION_FILE = sessionFilePath(LOCK_BASE_URL, reg.instance_id, LOCK_DIR);
+      minted = await acquireConversation(
+        SESSION_FILE,
+        BASE_URL,
+        auth.project_id,
+        instanceToken,
+        auth.client_fingerprint,
+        label,
+        auth.target_conversation_id ?? null,
+        REATTACH_WINDOW_SECONDS,
+      );
+    } else {
+      throw err;
     }
   }
 
+  // project_token / instance_token are stable, long-lived credentials (#274/#269);
+  // neither is rotated by the mint response. The membership conversation_token
+  // (below) is the short-lived tier and self-refreshes.
+
   CONVERSATION_TOKEN = minted.conversation_token;
   VOICE_BASE_URL = minted.ws_url;
   CONVERSATION_ID = minted.conversation_id;
 
+  // #280 step-27: hold the instance control stream open for the WHOLE session —
+  // it IS the "online" presence signal (step-02). Without it this agent never
+  // shows online in the control plane (sidebar Agents) and is not invitable.
+  // Pushed `join` events are logged but not acted on (an interactive session
+  // stays bound to its own conversation — option A); a `stop` (revoke) is
+  // logged only: the conversation-token path already fails closed.
+  if (OWN_INSTANCE_ID !== "") {
+    const controlStream = runPersistentControlStream(
+      { baseUrl: BASE_URL, instanceId: OWN_INSTANCE_ID, instanceToken },
+      {
+        log: (m) => process.stderr.write(m),
+        onJoin: (pushed) =>
+          process.stderr.write(
+            `[viber-channel] control stream: join for ${pushed.conversation_id} ignored — interactive session keeps its own conversation\n`,
+          ),
+        onStop: (reason) =>
+          process.stderr.write(`[viber-channel] control stream stopped (${reason})\n`),
+      },
+    );
+    // Presence-only consumer: firstJoin ALWAYS settles (rejected at loop end) —
+    // observe it so an ignored join/stop never becomes an unhandled rejection.
+    controlStream.firstJoin.catch(() => {});
+    controlStream.done.catch(() => {});
+  }
+
   // Schedule silent token refresh ahead of expiry (#237 step-03). On success
   // we mutate CONVERSATION_TOKEN in place — getHeaders() reads it by closure,
   // so subsequent SSE reconnects and send_message calls pick up the new token
@@ -481,20 +685,29 @@ try {
   );
   scheduler.start(minted.expires_at);
 } catch (err) {
-  if (err instanceof ReverifyRequiredError) {
-    await mcp.notification({
-      method: "notifications/claude/channel",
-      params: {
-        content: `⚠️ Re-verification required (reason: ${err.reason}). Visit ${err.url} to re-authenticate, then restart this channel.`,
-        meta: { source: "system", type: "reverify_required", url: err.url },
-      },
-    });
-    process.exit(2);
-  }
+  // The conversation mint failed. With the stable-token model (#274) a revoked
+  // or otherwise invalid project_token yields HTTP 401 — there is no reverify
+  // dance and no rotation, so the only recovery is to re-run the connect flow.
+  // Network errors and unexpected 5xx land here too; the message stays generic
+  // enough to cover them while pointing at the most common cause. The stderr
+  // line below is invisible in the Claude Code UI, which only sees the MCP
+  // server die ("tools fetch failed") — surface an actionable notification so
+  // the user knows what to do instead of failing opaquely. Clean exit, no retry.
   process.stderr.write(`[viber-channel] ${String(err)}\n`);
   process.stderr.write(
-    `[viber-channel] If your project_token is no longer valid, run the connect flow again at https://viber.dgypx.dev/projects.\n`
+    `[viber-channel] If your project_token is no longer valid, run the connect flow again at ${BASE_URL}/projects.\n`
   );
+  await mcp.notification({
+    method: "notifications/claude/channel",
+    params: {
+      content:
+        `⚠️ Could not start the voice channel: ${String(err)}. ` +
+        `If your project_token was revoked, reconnect at ${BASE_URL}/projects and run ` +
+        `\`bunx viber-channel connect <url>\` again, then restart this channel. ` +
+        `Otherwise this may be a temporary network issue — restart the channel to retry.`,
+      meta: { source: "system", type: "project_token_invalid" },
+    },
+  });
   process.exit(1);
 }
 
@@ -539,6 +752,11 @@ async function pushTranscript(text: string, lang: string): Promise<void> {
   });
 }
 
+// Drops the persisted echo of a user transcript already delivered ephemerally
+// (the conversation event bus delivers it twice when a web UI is open — #221
+// mechanism, surfaced by the #254 Active section that keeps the UI open).
+const messageDedup = new MessageDedup();
+
 /**
  * Forward a saved conversation message from the event bus to Claude.
  *
@@ -554,8 +772,21 @@ async function pushMessage(msg: {
   id?: string | null;
   source?: string;
   artifact?: { content: string; format?: "markdown" | "code" | "json" | "html" } | null;
+  sender_instance_id?: string | null;
 }): Promise<void> {
   process.stderr.write(`[viber-channel] pushMessage ENTER: "${msg.content.slice(0, 60)}"\n`);
+  // Never echo this channel's OWN posted messages back to Claude (#280 step-16):
+  // send_message posts as this instance, and the conversation SSE replays it.
+  if (isOwnMessage(msg.sender_instance_id, OWN_INSTANCE_ID)) {
+    process.stderr.write(`[viber-channel] dropping own posted message (self-echo)\n`);
+    return;
+  }
+  if (messageDedup.isDuplicate(msg)) {
+    process.stderr.write(
+      `[viber-channel] dropping duplicate persisted message (already delivered ephemerally)\n`,
+    );
+    return;
+  }
   // MCP notification handler (Claude Code v2.1.143) validates meta with Zod;
   // null fields are rejected as invalid type. Omit message_id when missing.
   const meta: Record<string, unknown> = { source: msg.source ?? "conversation" };
@@ -632,7 +863,8 @@ async function sseLoop(): Promise<void> {
           break;
 
         case "stop":
-          process.stderr.write(`[viber-channel] Received stop signal, exiting.\n`);
+          process.stderr.write(`[viber-channel] Received stop signal, clearing session handle and exiting.\n`);
+          clearHandle(SESSION_FILE);
           scheduler?.cancel();
           releaseLock();
           process.exit(0);
@@ -665,6 +897,7 @@ async function sseLoop(): Promise<void> {
                 role?: string;
                 timestamp?: string;
                 artifact?: { content: string; format?: "markdown" | "code" | "json" | "html" } | null;
+                sender_instance_id?: string | null;
               };
               if (msg.content) {
                 await pushMessage(msg);