gewe-openclaw 2026.3.13 → 2026.3.23

package/src/inbound.ts

@@ -2,8 +2,13 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import type { OpenClawConfig, ReplyPayload, RuntimeEnv } from "openclaw/plugin-sdk";
-import { logInboundDrop, resolveControlCommandGate } from "openclaw/plugin-sdk";
+import {
+  logInboundDrop,
+  resolveControlCommandGate,
+  type OpenClawConfig,
+  type ReplyPayload,
+  type RuntimeEnv,
+} from "./openclaw-compat.js";
 
 import {
   buildGeweInboundMediaPayload,
@@ -12,23 +17,49 @@ import {
 import type { GeweDownloadQueue } from "./download-queue.js";
 import { downloadGeweFile, downloadGeweImage, downloadGeweVideo, downloadGeweVoice } from "./download.js";
 import { deliverGewePayload } from "./delivery.js";
-import { resolveGeweReplyOptions } from "./reply-options.js";
+import { applyGeweReplyModeToPayload, resolveGeweReplyOptions } from "./reply-options.js";
+import { rememberGeweDirectoryObservation } from "./directory-cache.js";
 import { getGeweRuntime } from "./runtime.js";
 import { ensureRustSilkBinary } from "./silk.js";
+import { readGeweAllowFromStore, redeemGewePairCode } from "./pairing-store.js";
 import {
   normalizeGeweAllowlist,
   resolveGeweAllowlistMatch,
+  resolveGeweDmMatch,
+  resolveGeweDmReplyMode,
+  resolveGeweDmTriggerMode,
   resolveGeweGroupAllow,
   resolveGeweGroupMatch,
-  resolveGeweMentionGate,
-  resolveGeweRequireMention,
+  resolveGeweGroupReplyMode,
+  resolveGeweGroupTriggerMode,
+  resolveGeweTriggerGate,
 } from "./policy.js";
-import type { CoreConfig, GeweInboundMessage, ResolvedGeweAccount } from "./types.js";
-import { extractAppMsgType, extractFileName, extractLinkDetails } from "./xml.js";
+import type {
+  CoreConfig,
+  GeweDmReplyMode,
+  GeweGroupReplyMode,
+  GeweInboundMessage,
+  ResolvedGeweAccount,
+} from "./types.js";
+import {
+  extractAppMsgType,
+  extractFileName,
+  extractLinkDetails,
+  extractQuoteDetails,
+  extractQuoteSummary,
+  type GeweQuoteDetails,
+} from "./xml.js";
 import { CHANNEL_ID } from "./constants.js";
+import { rememberGeweQuoteReplyContext } from "./quote-context-cache.js";
 
 type PreparedInbound = {
   rawBody: string;
+  messageType: number;
+  rawXml?: string;
+  appMsgXml?: string;
+  appMsgType?: number;
+  quoteXml?: string;
+  quoteDetails?: GeweQuoteDetails;
   commandAuthorized: boolean;
   isGroup: boolean;
   senderId: string;
@@ -36,6 +67,8 @@ type PreparedInbound = {
   groupId?: string;
   groupName?: string;
   groupSystemPrompt?: string;
+  groupSkillFilter?: string[];
+  replyMode: GeweGroupReplyMode | GeweDmReplyMode;
   route: ReturnType<ReturnType<typeof getGeweRuntime>["channel"]["routing"]["resolveAgentRoute"]>;
   storePath: string;
   toWxid: string;
@@ -49,6 +82,11 @@ type PreparedInbound = {
 type NormalizedInboundEntry = {
   message: GeweInboundMessage;
   rawBody: string;
+  rawXml?: string;
+  appMsgXml?: string;
+  appMsgType?: number;
+  quoteXml?: string;
+  quoteDetails?: GeweQuoteDetails;
   download?: {
     msgType: number;
     xml: string;
@@ -58,6 +96,10 @@ type NormalizedInboundEntry = {
 const DEFAULT_VOICE_SAMPLE_RATE = 24000;
 const DEFAULT_VOICE_DECODE_TIMEOUT_MS = 30_000;
 const SILK_HEADER = "#!SILK_V3";
+const GEWE_PAIR_CODE_REGEX = /^[A-HJ-NP-Z2-9]{8}$/i;
+const GEWE_PAIR_CODE_PREFIX_REGEX = /^配对码\s*[:：]?\s*([A-HJ-NP-Z2-9]{8})$/i;
+const GEWE_PAIR_CODE_SUCCESS_REPLY = "配对成功，已加入允许列表。请重新发送上一条消息。";
+const GEWE_PAIR_CODE_INVALID_REPLY = "配对码无效或已过期。";
 
 function resolveMediaPlaceholder(msgType: number): string {
   if (msgType === 3) return "<media:image>";
@@ -67,6 +109,20 @@ function resolveMediaPlaceholder(msgType: number): string {
   return "";
 }
 
+function resolveAppMsgPlaceholder(appType?: number): string {
+  return typeof appType === "number" ? `<appmsg:${appType}>` : "<appmsg>";
+}
+
+function resolveGewePairCodeCandidate(rawBody: string): string | null {
+  const trimmed = rawBody.trim();
+  if (!trimmed) return null;
+  if (GEWE_PAIR_CODE_REGEX.test(trimmed)) {
+    return trimmed.toUpperCase();
+  }
+  const prefixed = trimmed.match(GEWE_PAIR_CODE_PREFIX_REGEX);
+  return prefixed?.[1]?.toUpperCase() ?? null;
+}
+
 function looksLikeSilkVoice(params: {
   buffer: Buffer;
   contentType?: string | null;
@@ -299,25 +355,56 @@ function normalizeInboundEntry(params: {
 
   if (msgType === 49 && xml) {
     const appType = extractAppMsgType(xml);
+    if (appType === 57 || /<refermsg>/i.test(xml)) {
+      return {
+        message,
+        rawBody: extractQuoteSummary(xml)?.body || resolveAppMsgPlaceholder(appType),
+        rawXml: xml,
+        appMsgXml: xml,
+        appMsgType: appType,
+        quoteXml: xml,
+        quoteDetails: extractQuoteDetails(xml),
+      };
+    }
     if (appType === 5) {
       return {
         message,
         rawBody: resolveLinkBody(xml) || rawBodyCandidate,
+        rawXml: xml,
+        appMsgXml: xml,
+        appMsgType: appType,
       };
     }
     if (appType === 74) {
-      runtime.log?.("gewe: file notification received (skip download)");
-      return null;
+      runtime.log?.("gewe: file notification received (preserve xml, skip download)");
+      return {
+        message,
+        rawBody: resolveAppMsgPlaceholder(appType),
+        rawXml: xml,
+        appMsgXml: xml,
+        appMsgType: appType,
+      };
     }
     if (appType !== 6) {
-      runtime.log?.(`gewe: unhandled appmsg type ${appType ?? "unknown"}`);
-      return null;
+      runtime.log?.(`gewe: preserve appmsg type ${appType ?? "unknown"} without download`);
+      return {
+        message,
+        rawBody: resolveAppMsgPlaceholder(appType),
+        rawXml: xml,
+        appMsgXml: xml,
+        appMsgType: appType,
+      };
     }
   }
 
   return {
     message,
     rawBody: rawBodyCandidate,
+    rawXml: xml,
+    appMsgXml: msgType === 49 && xml ? xml : undefined,
+    appMsgType: msgType === 49 && xml ? extractAppMsgType(xml) : undefined,
+    quoteXml: undefined,
+    quoteDetails: undefined,
     download:
       (msgType === 3 || msgType === 34 || msgType === 43 || msgType === 49) && xml
         ? { msgType, xml }
@@ -448,7 +535,48 @@ async function dispatchGeweInbound(params: {
     MessageSids: prepared.messageSids,
     MessageSidFirst: prepared.messageSidFirst,
     MessageSidLast: prepared.messageSidLast,
+    MsgType: prepared.messageType,
     ...mediaPayload,
+    ...(prepared.rawXml ? { GeWeXml: prepared.rawXml } : {}),
+    ...(prepared.appMsgXml ? { GeWeAppMsgXml: prepared.appMsgXml } : {}),
+    ...(typeof prepared.appMsgType === "number"
+      ? { GeWeAppMsgType: prepared.appMsgType }
+      : {}),
+    ...(prepared.quoteXml ? { GeWeQuoteXml: prepared.quoteXml } : {}),
+    ...(prepared.quoteDetails?.title ? { GeWeQuoteTitle: prepared.quoteDetails.title } : {}),
+    ...(typeof prepared.quoteDetails?.referType === "number"
+      ? { GeWeQuoteType: prepared.quoteDetails.referType }
+      : {}),
+    ...(prepared.quoteDetails?.svrid ? { GeWeQuoteSvrid: prepared.quoteDetails.svrid } : {}),
+    ...(prepared.quoteDetails?.fromUsr ? { GeWeQuoteFromUsr: prepared.quoteDetails.fromUsr } : {}),
+    ...(prepared.quoteDetails?.chatUsr ? { GeWeQuoteChatUsr: prepared.quoteDetails.chatUsr } : {}),
+    ...(prepared.quoteDetails?.displayName
+      ? { GeWeQuoteDisplayName: prepared.quoteDetails.displayName }
+      : {}),
+    ...(prepared.quoteDetails?.content
+      ? { GeWeQuoteContent: prepared.quoteDetails.content }
+      : {}),
+    ...(prepared.quoteDetails?.partialText?.start
+      ? { GeWeQuotePartialStart: prepared.quoteDetails.partialText.start }
+      : {}),
+    ...(prepared.quoteDetails?.partialText?.end
+      ? { GeWeQuotePartialEnd: prepared.quoteDetails.partialText.end }
+      : {}),
+    ...(typeof prepared.quoteDetails?.partialText?.startIndex === "number"
+      ? { GeWeQuotePartialStartIndex: prepared.quoteDetails.partialText.startIndex }
+      : {}),
+    ...(typeof prepared.quoteDetails?.partialText?.endIndex === "number"
+      ? { GeWeQuotePartialEndIndex: prepared.quoteDetails.partialText.endIndex }
+      : {}),
+    ...(prepared.quoteDetails?.partialText?.quoteMd5
+      ? { GeWeQuotePartialQuoteMd5: prepared.quoteDetails.partialText.quoteMd5 }
+      : {}),
+    ...(prepared.quoteDetails?.partialText?.text
+      ? { GeWeQuotePartialText: prepared.quoteDetails.partialText.text }
+      : {}),
+    ...(prepared.quoteDetails?.msgSource
+      ? { GeWeQuoteMsgSource: prepared.quoteDetails.msgSource }
+      : {}),
     GroupSystemPrompt: prepared.groupSystemPrompt,
     OriginatingChannel: CHANNEL_ID,
     OriginatingTo: `${CHANNEL_ID}:${prepared.toWxid}`,
@@ -463,14 +591,31 @@ async function dispatchGeweInbound(params: {
     },
   });
 
+  rememberGeweQuoteReplyContext({
+    accountId: account.accountId,
+    messageId: prepared.messageSid,
+    svrid: prepared.quoteDetails?.svrid,
+    partialText: prepared.quoteDetails?.partialText,
+  });
+  const repliedRef = { value: false };
+
   await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
     ctx: ctxPayload,
     cfg: config as OpenClawConfig,
-    replyOptions: resolveGeweReplyOptions(account),
+    replyOptions: resolveGeweReplyOptions(account, {
+      skillFilter: prepared.groupSkillFilter,
+    }),
     dispatcherOptions: {
       deliver: async (payload: ReplyPayload) => {
+        const nextPayload = applyGeweReplyModeToPayload(payload, {
+          mode: prepared.replyMode,
+          isGroup: prepared.isGroup,
+          senderId: prepared.senderId,
+          defaultReplyToId: prepared.messageSid,
+          repliedRef,
+        });
         await deliverGewePayload({
-          payload,
+          payload: nextPayload,
           account,
           cfg: config as OpenClawConfig,
           toWxid: prepared.toWxid,
@@ -540,6 +685,12 @@ export async function handleGeweInboundBatch(params: {
   }
 
   statusSink?.({ lastInboundAt: Date.now() });
+  rememberGeweDirectoryObservation({
+    accountId: account.accountId,
+    senderId,
+    senderName,
+    groupId,
+  });
 
   const dmPolicy = account.config.dmPolicy ?? "pairing";
   const defaultGroupPolicy = config.channels?.defaults?.groupPolicy;
@@ -547,9 +698,14 @@ export async function handleGeweInboundBatch(params: {
 
   const configAllowFrom = normalizeGeweAllowlist(account.config.allowFrom);
   const configGroupAllowFrom = normalizeGeweAllowlist(account.config.groupAllowFrom);
-  const storeAllowFrom = await core.channel.pairing
-    .readAllowFromStore(CHANNEL_ID)
-    .catch(() => []);
+  const storeAllowFrom = await readGeweAllowFromStore({
+    accountId: account.accountId,
+  }).catch((err) => {
+    runtime.error?.(
+      `gewe: failed reading local allowFrom store for ${account.accountId}: ${String(err)}`,
+    );
+    return [];
+  });
   const storeAllowList = normalizeGeweAllowlist(storeAllowFrom);
 
   const groupMatch = isGroup
@@ -559,17 +715,27 @@ export async function handleGeweInboundBatch(params: {
         groupName: undefined,
       })
     : undefined;
+  const dmMatch = !isGroup
+    ? resolveGeweDmMatch({
+        dms: account.config.dms,
+        senderId,
+        senderName,
+      })
+    : undefined;
 
   if (isGroup && groupMatch && !groupMatch.allowed) {
     runtime.log?.(`gewe: drop group ${groupId} (not allowlisted)`);
     return;
   }
-  if (groupMatch?.groupConfig?.enabled === false) {
+  if (groupMatch?.groupConfig?.enabled === false || groupMatch?.wildcardConfig?.enabled === false) {
     runtime.log?.(`gewe: drop group ${groupId} (disabled)`);
     return;
   }
 
-  const roomAllowFrom = normalizeGeweAllowlist(groupMatch?.groupConfig?.allowFrom);
+  const directRoomAllowFrom = normalizeGeweAllowlist(groupMatch?.groupConfig?.allowFrom);
+  const wildcardRoomAllowFrom = normalizeGeweAllowlist(groupMatch?.wildcardConfig?.allowFrom);
+  const roomAllowFrom =
+    directRoomAllowFrom.length > 0 ? directRoomAllowFrom : wildcardRoomAllowFrom;
   const baseGroupAllowFrom =
     configGroupAllowFrom.length > 0 ? configGroupAllowFrom : configAllowFrom;
   const effectiveAllowFrom = [...configAllowFrom, ...storeAllowList].filter(Boolean);
@@ -627,26 +793,28 @@ export async function handleGeweInboundBatch(params: {
       }).allowed;
       if (!dmAllowed) {
         if (dmPolicy === "pairing") {
-          const { code, created } = await core.channel.pairing.upsertPairingRequest({
-            channel: CHANNEL_ID,
-            id: senderId,
-            meta: { name: senderName || undefined },
-          });
-          if (created) {
+          const pairCode = resolveGewePairCodeCandidate(rawBodyCandidate);
+          if (pairCode) {
+            const redeemed = await redeemGewePairCode({
+              accountId: account.accountId,
+              code: pairCode,
+              id: senderId,
+            }).catch((err) => {
+              runtime.error?.(`gewe: pair code redeem failed for ${senderId}: ${String(err)}`);
+              return null;
+            });
             try {
               await deliverGewePayload({
-                payload: { text: core.channel.pairing.buildPairingReply({
-                  channel: CHANNEL_ID,
-                  idLine: `Your WeChat id: ${senderId}`,
-                  code,
-                }) },
+                payload: {
+                  text: redeemed ? GEWE_PAIR_CODE_SUCCESS_REPLY : GEWE_PAIR_CODE_INVALID_REPLY,
+                },
                 account,
                 cfg: config as OpenClawConfig,
                 toWxid,
                 statusSink: (patch) => statusSink?.(patch),
               });
             } catch (err) {
-              runtime.error?.(`gewe: pairing reply failed for ${senderId}: ${String(err)}`);
+              runtime.error?.(`gewe: pair code reply failed for ${senderId}: ${String(err)}`);
             }
           }
         }
@@ -667,25 +835,38 @@ export async function handleGeweInboundBatch(params: {
   }
 
   const mentionRegexes = core.channel.mentions.buildMentionRegexes(config as OpenClawConfig);
-  const wasMentioned = mentionRegexes.length
+  const wasAtTriggered = mentionRegexes.length
     ? core.channel.mentions.matchesMentionPatterns(rawBodyCandidate, mentionRegexes)
     : false;
-  const shouldRequireMention = isGroup
-    ? resolveGeweRequireMention({
+  const latestQuote = entries.at(-1)?.quoteDetails;
+  const wasQuoteTriggered = Boolean(
+    latestQuote &&
+      (!isGroup || latestQuote.fromUsr?.trim() === lastMessage.botWxid.trim()),
+  );
+  const triggerMode = isGroup
+    ? resolveGeweGroupTriggerMode({
         groupConfig: groupMatch?.groupConfig,
         wildcardConfig: groupMatch?.wildcardConfig,
       })
-    : false;
-  const mentionGate = resolveGeweMentionGate({
+    : resolveGeweDmTriggerMode({
+        dmConfig: dmMatch?.dmConfig,
+        wildcardConfig: dmMatch?.wildcardConfig,
+      });
+  const triggerGate = resolveGeweTriggerGate({
     isGroup,
-    requireMention: shouldRequireMention,
-    wasMentioned,
+    triggerMode,
+    wasAtTriggered,
+    wasQuoteTriggered,
     allowTextCommands,
     hasControlCommand,
     commandAuthorized,
   });
-  if (isGroup && mentionGate.shouldSkip) {
-    runtime.log?.(`gewe: drop group ${groupId} (no mention)`);
+  if (triggerGate.shouldSkip) {
+    runtime.log?.(
+      isGroup
+        ? `gewe: drop group ${groupId} (trigger=${triggerMode})`
+        : `gewe: drop DM sender ${senderId} (trigger=${triggerMode})`,
+    );
     return;
   }
 
@@ -694,7 +875,7 @@ export async function handleGeweInboundBatch(params: {
     channel: CHANNEL_ID,
     accountId: account.accountId,
     peer: {
-      kind: isGroup ? "group" : "dm",
+      kind: isGroup ? "group" : "direct",
       id: isGroup ? groupId ?? "" : senderId,
     },
   });
@@ -705,13 +886,39 @@ export async function handleGeweInboundBatch(params: {
 
   const prepared: PreparedInbound = {
     rawBody: rawBodyCandidate,
+    messageType: lastMessage.msgType,
+    rawXml: entries.at(-1)?.rawXml,
+    appMsgXml: entries.at(-1)?.appMsgXml,
+    appMsgType: entries.at(-1)?.appMsgType,
+    quoteXml: entries.at(-1)?.quoteXml,
+    quoteDetails: entries.at(-1)?.quoteDetails,
     commandAuthorized,
     isGroup,
     senderId,
     senderName: senderName || undefined,
     groupId,
     groupName: undefined,
-    groupSystemPrompt: groupMatch?.groupConfig?.systemPrompt?.trim() || undefined,
+    groupSystemPrompt: isGroup
+      ? groupMatch?.groupConfig?.systemPrompt?.trim() ||
+        groupMatch?.wildcardConfig?.systemPrompt?.trim() ||
+        undefined
+      : dmMatch?.dmConfig?.systemPrompt?.trim() ||
+        dmMatch?.wildcardConfig?.systemPrompt?.trim() ||
+        undefined,
+    groupSkillFilter: isGroup
+      ? groupMatch?.groupConfig?.skills ?? groupMatch?.wildcardConfig?.skills
+      : dmMatch?.dmConfig?.skills ?? dmMatch?.wildcardConfig?.skills,
+    replyMode: isGroup
+      ? resolveGeweGroupReplyMode({
+          groupConfig: groupMatch?.groupConfig,
+          wildcardConfig: groupMatch?.wildcardConfig,
+          autoQuoteReply: account.config.autoQuoteReply,
+        })
+      : resolveGeweDmReplyMode({
+          dmConfig: dmMatch?.dmConfig,
+          wildcardConfig: dmMatch?.wildcardConfig,
+          autoQuoteReply: account.config.autoQuoteReply,
+        }),
     route,
     storePath,
     toWxid,

package/src/media-server.ts

@@ -1,59 +1,23 @@
-import { createReadStream, existsSync } from "node:fs";
+import { createReadStream } from "node:fs";
 import fs from "node:fs/promises";
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
-import os from "node:os";
 import path from "node:path";
 
-import { detectMime } from "openclaw/plugin-sdk";
+import { detectMime } from "./openclaw-compat.js";
+import { resolveOpenClawStateDir } from "./state-paths.js";
 
 export const DEFAULT_MEDIA_HOST = "0.0.0.0";
 export const DEFAULT_MEDIA_PORT = 18787;
 export const DEFAULT_MEDIA_PATH = "/gewe-media";
 
-function normalizePath(value: string): string {
+export function normalizeMediaPath(value: string): string {
   const trimmed = value.trim() || "/";
   if (trimmed === "/") return "/";
   return trimmed.startsWith("/") ? trimmed.replace(/\/+$/, "") : `/${trimmed.replace(/\/+$/, "")}`;
 }
 
-function resolveUserPath(input: string): string {
-  const trimmed = input.trim();
-  if (!trimmed) return trimmed;
-  if (trimmed.startsWith("~")) {
-    const expanded = trimmed.replace(/^~(?=$|[\\/])/, os.homedir());
-    return path.resolve(expanded);
-  }
-  return path.resolve(trimmed);
-}
-
-function resolveConfigDir(
-  env: NodeJS.ProcessEnv = process.env,
-  homedir: () => string = os.homedir,
-): string {
-  const override = env.OPENCLAW_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
-  if (override) return resolveUserPath(override);
-  const legacyDirs = [".clawdbot", ".moltbot", ".moldbot"].map((dir) =>
-    path.join(homedir(), dir),
-  );
-  const newDir = path.join(homedir(), ".openclaw");
-  try {
-    if (existsSync(newDir)) return newDir;
-    const existingLegacy = legacyDirs.find((dir) => {
-      try {
-        return existsSync(dir);
-      } catch {
-        return false;
-      }
-    });
-    if (existingLegacy) return existingLegacy;
-  } catch {
-    // best-effort
-  }
-  return newDir;
-}
-
 function resolveMediaDir() {
-  return path.join(resolveConfigDir(), "media");
+  return path.join(resolveOpenClawStateDir(), "media");
 }
 
 function resolveBaseUrl(req: IncomingMessage): string {
@@ -74,67 +38,83 @@ export type GeweMediaServerOptions = {
   abortSignal?: AbortSignal;
 };
 
+export async function maybeHandleGeweMediaRequest(params: {
+  req: IncomingMessage;
+  res: ServerResponse;
+  path?: string;
+  mediaBaseDir?: string;
+}): Promise<boolean> {
+  if (!params.req.url) {
+    return false;
+  }
+
+  const basePath = normalizeMediaPath(params.path ?? DEFAULT_MEDIA_PATH);
+  const url = new URL(params.req.url, resolveBaseUrl(params.req));
+  if (!url.pathname.startsWith(`${basePath}/`)) {
+    return false;
+  }
+
+  if (params.req.method !== "GET" && params.req.method !== "HEAD") {
+    params.res.writeHead(405);
+    params.res.end();
+    return true;
+  }
+
+  const id = decodeURIComponent(url.pathname.slice(basePath.length + 1));
+  if (!isSafeMediaId(id)) {
+    params.res.writeHead(400);
+    params.res.end();
+    return true;
+  }
+
+  const mediaBaseDir = params.mediaBaseDir ?? path.join(resolveMediaDir(), "outbound");
+  const filePath = path.join(mediaBaseDir, id);
+  const stat = await fs.stat(filePath).catch(() => null);
+  if (!stat || !stat.isFile()) {
+    params.res.writeHead(404);
+    params.res.end();
+    return true;
+  }
+
+  const contentType = await detectMime({ filePath }).catch(() => undefined);
+  const headers: Record<string, string> = {
+    "Content-Length": String(stat.size),
+    "Cache-Control": "private, max-age=60",
+  };
+  if (contentType) headers["Content-Type"] = contentType;
+
+  params.res.writeHead(200, headers);
+  if (params.req.method === "HEAD") {
+    params.res.end();
+    return true;
+  }
+
+  const stream = createReadStream(filePath);
+  stream.on("error", () => {
+    if (!params.res.headersSent) params.res.writeHead(500);
+    params.res.end();
+  });
+  stream.pipe(params.res);
+  return true;
+}
+
 export function createGeweMediaServer(
   opts: GeweMediaServerOptions,
 ): { server: Server; start: () => Promise<void>; stop: () => void } {
   const host = opts.host ?? DEFAULT_MEDIA_HOST;
   const port = opts.port ?? DEFAULT_MEDIA_PORT;
-  const basePath = normalizePath(opts.path ?? DEFAULT_MEDIA_PATH);
   const mediaBaseDir = path.join(resolveMediaDir(), "outbound");
 
   const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
-    if (!req.url) {
-      res.writeHead(404);
-      res.end();
-      return;
-    }
-    if (req.method !== "GET" && req.method !== "HEAD") {
-      res.writeHead(405);
-      res.end();
-      return;
-    }
-
-    const url = new URL(req.url, resolveBaseUrl(req));
-    if (!url.pathname.startsWith(`${basePath}/`)) {
-      res.writeHead(404);
-      res.end();
-      return;
-    }
-
-    const id = decodeURIComponent(url.pathname.slice(basePath.length + 1));
-    if (!isSafeMediaId(id)) {
-      res.writeHead(400);
-      res.end();
-      return;
-    }
-
-    const filePath = path.join(mediaBaseDir, id);
-    const stat = await fs.stat(filePath).catch(() => null);
-    if (!stat || !stat.isFile()) {
-      res.writeHead(404);
-      res.end();
-      return;
-    }
-
-    const contentType = await detectMime({ filePath }).catch(() => undefined);
-    const headers: Record<string, string> = {
-      "Content-Length": String(stat.size),
-      "Cache-Control": "private, max-age=60",
-    };
-    if (contentType) headers["Content-Type"] = contentType;
-
-    res.writeHead(200, headers);
-    if (req.method === "HEAD") {
-      res.end();
-      return;
-    }
-
-    const stream = createReadStream(filePath);
-    stream.on("error", () => {
-      if (!res.headersSent) res.writeHead(500);
-      res.end();
+    const handled = await maybeHandleGeweMediaRequest({
+      req,
+      res,
+      path: opts.path,
+      mediaBaseDir,
     });
-    stream.pipe(res);
+    if (handled) return;
+    res.writeHead(404);
+    res.end();
   });
 
   const start = (): Promise<void> =>