"**/node_modules/**"

],

"overrides": [

{

"files": ["src/security/**"],

"rules": {

"eslint/no-warning-comments": "off",

"oxc/no-map-spread": "off"

}

},

{

"files": [

"**/*.test.ts",

mimetype?: string;

}): string {

const fallbackName = resolveWhatsAppDefaultDocumentFileName(params.mimetype);

// eslint-disable-next-line no-control-regex

const stripped = params.fileName?.replace(/[\x00-\x1f\x7f]/g, "").trim();

const stripped = stripAsciiControlCharacters(params.fileName ?? "").trim();

return stripped || fallbackName;

}

function stripAsciiControlCharacters(value: string): string {

let stripped = "";

for (const char of value) {

const code = char.charCodeAt(0);

if (code > 0x1f && code !== 0x7f) {

stripped += char;

}

}

return stripped;

}

process.stderr.write(`[openclaw mcp] ${String(chunk)}`);

});

const rawMessages: unknown[] = [];

// The MCP stdio transport here exposes a writable onmessage callback at

// runtime, not an EventTarget-style addEventListener API.

// oxlint-disable-next-line unicorn/prefer-add-event-listener

transport.onmessage = (message) => {

Reflect.set(transport, "onmessage", (message: unknown) => {

pushBounded(rawMessages, message, MCP_RAW_MESSAGE_RETAIN_LIMIT);

};

});

const client = new Client({ name: "docker-mcp-channels", version: "1.0.0" });

await connectMcpWithTimeout(client, transport, MCP_CONNECT_TIMEOUT_MS);

/** Strip null bytes from paths to prevent ENOTDIR errors. */

function stripNullBytes(s: string): string {

// eslint-disable-next-line no-control-regex

return s.replace(/\0/g, "");

return s.split("\0").join("");

}

const AUTO_FALLBACK_PRIMARY_PROBE_INTERVAL_MS = 5 * 60 * 1000;

* "photo---1c77ce17-20b9-4546-be64-6e36a9adcb2c.png"

* "图片---1c77ce17-20b9-4546-be64-6e36a9adcb2c.png"

*/

// eslint-disable-next-line no-control-regex

const MEDIA_URI_REGEX = /\bmedia:\/\/inbound\/([^\]\s/\\\x00]+)/;

const MEDIA_URI_REGEX = /\bmedia:\/\/inbound\/([^\]\s/\\]+)/;

/**

* Result of detecting an image reference in text.

// This must be tested before the extension-based path regex because the

// URI has no file extension suffix in its base form.

const mediaUriMatch = content.match(MEDIA_URI_REGEX);

if (mediaUriMatch) {

if (mediaUriMatch && !mediaUriMatch[1].includes("\0")) {

const uri = `media://inbound/${mediaUriMatch[1]}`;

const dedupeKey = normalizeRefForDedupe(uri);

if (!seen.has(dedupeKey)) {

if (!trimmed) {

return undefined;

}

// Prevent prompt injection via control/newline characters in system prompt hints.

// eslint-disable-next-line no-control-regex

if (/[\r\n\u0000-\u001F\u007F\u0085\u2028\u2029]/.test(trimmed)) {

if (hasPromptUnsafeControlCharacter(trimmed)) {

return undefined;

}

if (!/^[A-Za-z0-9._\-/:]+$/.test(trimmed)) {

return trimmed;

}

function hasPromptUnsafeControlCharacter(value: string): boolean {

for (const char of value) {

const code = char.charCodeAt(0);

if (code <= 0x1f || code === 0x7f || code === 0x85 || code === 0x2028 || code === 0x2029) {

return true;

}

}

return false;

}

async function cleanupProvisionalSession(

childSessionKey: string,

options?: {

description?: string;

};

// Omitted generic means "plugin with some account shape", not "plugin whose

// account is literally Record<string, unknown>".

// Omitted generic means "plugin with some account shape"; using unknown makes

// callback parameters contravariant and rejects concrete plugin implementations.

// oxlint-disable-next-line typescript/no-explicit-any

export type ChannelPlugin<ResolvedAccount = any, Probe = unknown, Audit = unknown> = {

id: ChannelId;

* Channel sections are plugin-owned and keyed by arbitrary channel ids.

* Keep the lookup permissive so augmented channel configs remain ergonomic at call sites.

*/

// eslint-disable-next-line @typescript-eslint/no-explicit-any

// Plugin-owned channel sections are open-world config; narrowing this breaks

// SDK config-write helpers that accept account-shaped channel records.

// oxlint-disable-next-line typescript/no-explicit-any

[key: string]: any;

}

function activeClientSocketsToPort(port: number): Socket[] {

// Node has no public active-handle API; this regression must prove the probe

// promise does not resolve while the client-side socket handle is still live.

// oxlint-disable no-underscore-dangle

const handles =

(process as typeof process & { _getActiveHandles?: () => unknown[] })._getActiveHandles?.() ??

[];

// oxlint-enable no-underscore-dangle

const getActiveHandles = Reflect.get(process, "_getActiveHandles") as

| (() => unknown[])

| undefined;

const handles = getActiveHandles?.() ?? [];

return handles.filter(

(handle): handle is Socket => handle instanceof Socket && handle.remotePort === port,

);

return findings;

}

const smallModels = models

.map((entry) => {

const paramB = inferParamBFromIdOrName(entry.id);

if (!paramB || paramB > SMALL_MODEL_PARAM_B_MAX) {

return null;

}

return { ...entry, paramB };

})

.filter((entry): entry is { id: string; source: string; paramB: number } => Boolean(entry));

const smallModels: Array<{ id: string; source: string; paramB: number }> = [];

for (const entry of models) {

const paramB = inferParamBFromIdOrName(entry.id);

if (paramB && paramB <= SMALL_MODEL_PARAM_B_MAX) {

smallModels.push({ id: entry.id, source: entry.source, paramB });

}

}

if (smallModels.length === 0) {

return findings;