Add Telegram multi-transport startup diagnostics

Dockerfile

@@ -6,7 +6,7 @@ FROM node:22-bookworm
 ARG OPENCLAW_VERSION=2026.3.11
 
 RUN apt-get update && \
-    DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends ca-certificates git && \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends ca-certificates curl git && \
     apt-get clean && rm -rf /var/lib/apt/lists/*
 
 ENV NODE_ENV=production
@@ -35,6 +35,11 @@ RUN printf '%s\n' \
     '  export OPENCLAW_HOME=/home/user' \
     '  mkdir -p /home/user/.openclaw' \
     'fi' \
+    'if [ -n "${OPENCLAW_TELEGRAM_PROXY}" ]; then' \
+    '  export HTTPS_PROXY="${HTTPS_PROXY:-$OPENCLAW_TELEGRAM_PROXY}"' \
+    '  export HTTP_PROXY="${HTTP_PROXY:-$OPENCLAW_TELEGRAM_PROXY}"' \
+    '  export ALL_PROXY="${ALL_PROXY:-$OPENCLAW_TELEGRAM_PROXY}"' \
+    'fi' \
     'node /app/setup-hf-config.mjs' \
     'node /app/import-auth-profiles.mjs' \
     'node /app/startup-notify.mjs >/tmp/openclaw-startup-notify.log 2>&1 || true' \

README.md

@@ -37,6 +37,7 @@ This Space runs the [OpenClaw](https://github.com/openclaw/openclaw) gateway so
    - **`OPENCLAW_TELEGRAM_INIT_NOTIFY_CHAT_IDS`** — (optional) Comma-separated chat IDs to receive startup notifications from the init script. Recommended if you want an explicit "boot completed" signal.
    - **`OPENCLAW_TELEGRAM_INIT_NOTIFY_MESSAGE`** — (optional) Extra plain-text line appended to the startup notification.
    - **`OPENCLAW_TELEGRAM_DROP_PENDING_UPDATES_ON_START`** — (optional) `1` / `0`; when startup finds a webhook and removes it, also drops queued Telegram updates. Default `0`.
+   - **`OPENCLAW_STARTUP_NOTIFY_TELEGRAM_TO`** — (optional) Single fallback chat ID for startup notifier when `OPENCLAW_TELEGRAM_INIT_NOTIFY_CHAT_IDS` is not set.
    - **`OPENCLAW_TELEGRAM_DM_POLICY`** / **`OPENCLAW_TELEGRAM_ALLOW_FROM`** / **`OPENCLAW_TELEGRAM_GROUP_POLICY`** / **`OPENCLAW_TELEGRAM_GROUP_ALLOW_FROM`** / **`OPENCLAW_TELEGRAM_REQUIRE_MENTION`** — (optional) Advanced Telegram access-control settings.
 4. **Build and run** — push to the Space repo; the Space will build and start the gateway. Startup writes config so the default model chain is `Qwen3-8B -> DeepSeek-R1 -> openai-codex/gpt-5.4`, the Control UI accepts token-only connections (no device pairing), and Supabase sync starts automatically when `SUPABASE_URL` + `SUPABASE_KEY` are present.
 
@@ -72,6 +73,7 @@ OPENCLAW_MODEL_FALLBACK_1=huggingface/deepseek-ai/DeepSeek-R1
 OPENCLAW_MODEL_FALLBACK_2=openai-codex/gpt-5.4
 OPENCLAW_CONTROL_UI_ALLOWED_ORIGINS=https://your-space.hf.space
 OPENCLAW_TELEGRAM_INIT_NOTIFY_CHAT_IDS=123456789,-1001234567890
+OPENCLAW_STARTUP_NOTIFY_TELEGRAM_TO=123456789
 OPENCLAW_TELEGRAM_INIT_NOTIFY_MESSAGE=HF Space boot completed
 OPENCLAW_TELEGRAM_DROP_PENDING_UPDATES_ON_START=0
 OPENCLAW_SUPABASE_TABLE=openclaw_state
@@ -82,8 +84,9 @@ Telegram startup notification notes:
 
 1. Ask the target user to start the bot first, or add the bot to the target group/channel before using that chat ID.
 2. Use numeric chat IDs when possible; they are less fragile than usernames.
-3. The init script validates the bot with `getMe`, clears any stale webhook, probes `getUpdates`, then sends multiple `sendMessage` variants tagged with their version name.
-4. Startup currently tests these send variants and includes the variant name in the message body: `json-html`, `json-plain`, `form-html`, `form-plain`, `get-plain`.
+3. The startup notifier now tries several network transports: `fetch-json`, `https-family4-json`, `https-family4-form`, `https-resolve4-json`, and `curl-json`.
+4. If no explicit startup chat ID is configured, the notifier falls back to `OPENCLAW_STARTUP_NOTIFY_TELEGRAM_TO`, then `OPENCLAW_TELEGRAM_ALLOW_FROM`, then recent `getUpdates` chat IDs.
+5. Startup messages are tagged with both `transport=` and `payload=` in the message body so you can report exactly which path worked.
 
 ## Keep it running 24/7
 
@@ -178,6 +181,7 @@ The startup script `setup-hf-config.mjs` reads the following from **Secrets** or
 | Telegram command menu | `channels.telegram.commands.native = off` | This HF wrapper disables Telegram command-menu registration to reduce noisy `setMyCommands` retries on constrained hosts |
 | `OPENCLAW_STARTUP_NOTIFY` | startup notify helper | `1` / `0`; send a best-effort Telegram startup notification |
 | `OPENCLAW_STARTUP_NOTIFY_TELEGRAM_TO` | startup notify helper | Optional explicit Telegram chat id; defaults to first `OPENCLAW_TELEGRAM_ALLOW_FROM` entry |
+| `OPENCLAW_TELEGRAM_API_HOST` | startup notify helper | Optional alternate Telegram Bot API host; default `api.telegram.org` |
 | `OPENCLAW_AUTH_PROFILES_JSON_B64` | startup auth import | Base64-encoded full `auth-profiles.json` exported from another OpenClaw host |
 | `OPENCLAW_AUTH_PROFILES_IMPORT_B64` | startup auth import | Alternate secret name for the same full `auth-profiles.json` import |
 | `OPENCLAW_OPENAI_CODEX_PROFILE_B64` | startup auth import | Base64-encoded JSON object for one `openai-codex:default` profile |

startup-notify.mjs

@@ -1,34 +1,337 @@
 #!/usr/bin/env node
-import os from 'node:os';
+import dns from "node:dns/promises";
+import https from "node:https";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 
+const execFileAsync = promisify(execFile);
 const token = process.env.TELEGRAM_BOT_TOKEN?.trim();
-const explicitChatId = process.env.OPENCLAW_STARTUP_NOTIFY_TELEGRAM_TO?.trim();
-const allowFrom = process.env.OPENCLAW_TELEGRAM_ALLOW_FROM?.split(',').map(s => s.trim()).filter(Boolean) || [];
-const chatId = explicitChatId || allowFrom[0];
-const initNotifyChatIds = process.env.OPENCLAW_TELEGRAM_INIT_NOTIFY_CHAT_IDS?.trim();
-const spaceHost = process.env.SPACE_HOST?.trim() || process.env.HF_SPACE_HOST?.trim() || '';
-const model = process.env.OPENCLAW_MODEL_PRIMARY?.trim() || process.env.OPENCLAW_DEFAULT_MODEL?.trim() || process.env.OPENCLAW_HF_DEFAULT_MODEL?.trim() || 'unknown';
-const where = process.env.HF_SPACE_ID?.trim() || process.env.SPACE_ID?.trim() || 'HF Space';
-const enabled = (process.env.OPENCLAW_STARTUP_NOTIFY ?? '1').trim().toLowerCase();
-if (['0','false','no','off'].includes(enabled)) process.exit(0);
-if (initNotifyChatIds) {
-  console.log('[openclaw-startup-notify] skipped legacy notifier because OPENCLAW_TELEGRAM_INIT_NOTIFY_CHAT_IDS is set');
+const enabled = (process.env.OPENCLAW_STARTUP_NOTIFY ?? "1").trim().toLowerCase();
+const apiHost = process.env.OPENCLAW_TELEGRAM_API_HOST?.trim() || "api.telegram.org";
+const apiBase = `https://${apiHost}`;
+const startupTimestamp = new Date().toISOString();
+
+if (["0", "false", "no", "off"].includes(enabled)) process.exit(0);
+if (!token) {
+  console.log("[openclaw-startup-notify] skipped token=0");
   process.exit(0);
 }
-if (!token || !chatId) {
-  console.log(`[openclaw-startup-notify] skipped token=${token ? 1 : 0} chat=${chatId ? 1 : 0}`);
-  process.exit(0);
+
+function parseCsv(raw) {
+  return raw ? raw.split(",").map((item) => item.trim()).filter(Boolean) : [];
 }
-const text = `OpenClaw 上線：${where}${spaceHost ? `\nHost: ${spaceHost}` : ''}\nModel: ${model}`;
-try {
-  const r = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ chat_id: chatId, text, disable_web_page_preview: true }),
+
+function dedupe(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function extractChatIdsFromUpdates(updates) {
+  const chatIds = [];
+  for (const update of updates || []) {
+    const messageChatId = update?.message?.chat?.id;
+    const editedMessageChatId = update?.edited_message?.chat?.id;
+    const callbackChatId = update?.callback_query?.message?.chat?.id;
+    const memberChatId = update?.my_chat_member?.chat?.id;
+    for (const value of [messageChatId, editedMessageChatId, callbackChatId, memberChatId]) {
+      if (value !== undefined && value !== null) chatIds.push(String(value));
+    }
+  }
+  return dedupe(chatIds);
+}
+
+function escapeHtml(raw) {
+  return String(raw)
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+}
+
+function buildMessages() {
+  const where = process.env.HF_SPACE_ID?.trim() || process.env.SPACE_ID?.trim() || "HF Space";
+  const spaceHost = process.env.SPACE_HOST?.trim() || process.env.HF_SPACE_HOST?.trim() || "";
+  const model =
+    process.env.OPENCLAW_MODEL_PRIMARY?.trim() ||
+    process.env.OPENCLAW_DEFAULT_MODEL?.trim() ||
+    process.env.OPENCLAW_HF_DEFAULT_MODEL?.trim() ||
+    "unknown";
+  const customMessage = process.env.OPENCLAW_TELEGRAM_INIT_NOTIFY_MESSAGE?.trim();
+  const htmlLines = [
+    "<b>OpenClaw startup notify</b>",
+    `Space: <code>${escapeHtml(where)}</code>`,
+    `Started: <code>${escapeHtml(startupTimestamp)}</code>`,
+    `Model: <code>${escapeHtml(model)}</code>`,
+  ];
+  if (spaceHost) htmlLines.push(`Host: <code>${escapeHtml(spaceHost)}</code>`);
+  if (customMessage) {
+    htmlLines.push("");
+    htmlLines.push(escapeHtml(customMessage));
+  }
+  const html = htmlLines.join("\n");
+  const plain = html
+    .replace(/<[^>]+>/g, "")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&amp;", "&");
+  return { html, plain };
+}
+
+async function fetchJson(url, init) {
+  const response = await fetch(url, init);
+  const data = await response.json().catch(() => null);
+  if (!response.ok || !data?.ok) {
+    throw new Error(data?.description || `${response.status} ${response.statusText}`.trim());
+  }
+  return data.result;
+}
+
+function httpsJsonRequest(url, { method = "POST", headers = {}, body, family, lookup, servername } = {}) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const req = https.request(
+      {
+        protocol: parsed.protocol,
+        hostname: parsed.hostname,
+        host: parsed.hostname,
+        port: parsed.port || 443,
+        path: `${parsed.pathname}${parsed.search}`,
+        method,
+        headers,
+        family,
+        lookup,
+        servername,
+      },
+      (res) => {
+        let raw = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          raw += chunk;
+        });
+        res.on("end", () => {
+          try {
+            const data = JSON.parse(raw || "null");
+            if (res.statusCode < 200 || res.statusCode >= 300 || !data?.ok) {
+              reject(new Error(data?.description || `${res.statusCode || 0} ${res.statusMessage || ""}`.trim()));
+              return;
+            }
+            resolve(data.result);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      },
+    );
+    req.on("error", reject);
+    req.setTimeout(15000, () => req.destroy(new Error("request timeout")));
+    if (body) req.write(body);
+    req.end();
   });
-  const body = await r.text();
-  console.log(`[openclaw-startup-notify] status=${r.status} body=${body.slice(0,300)}`);
-} catch (err) {
-  console.error(`[openclaw-startup-notify] failed ${err?.name || 'Error'}: ${err?.message || err}`);
+}
+
+async function curlJsonRequest(url, payload) {
+  const args = [
+    "--silent",
+    "--show-error",
+    "--max-time",
+    "20",
+    "-H",
+    "content-type: application/json",
+    "-d",
+    JSON.stringify(payload),
+    url,
+  ];
+  const { stdout } = await execFileAsync("curl", args, { timeout: 25000 });
+  const data = JSON.parse(stdout || "null");
+  if (!data?.ok) throw new Error(data?.description || "curl request failed");
+  return data.result;
+}
+
+function methodUrl(method) {
+  return `${apiBase}/bot${token}/${method}`;
+}
+
+const transports = {
+  "fetch-json": {
+    async call(method, payload = {}) {
+      return fetchJson(methodUrl(method), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+    },
+  },
+  "https-family4-json": {
+    async call(method, payload = {}) {
+      return httpsJsonRequest(methodUrl(method), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload),
+        family: 4,
+      });
+    },
+  },
+  "https-family4-form": {
+    async call(method, payload = {}) {
+      const body = new URLSearchParams(
+        Object.entries(payload).map(([key, value]) => [key, Array.isArray(value) ? JSON.stringify(value) : String(value)]),
+      ).toString();
+      return httpsJsonRequest(methodUrl(method), {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body,
+        family: 4,
+      });
+    },
+  },
+  "https-resolve4-json": {
+    async call(method, payload = {}) {
+      const addresses = await dns.resolve4(apiHost);
+      const ip = addresses[0];
+      if (!ip) throw new Error("no IPv4 address from resolve4");
+      const directUrl = `https://${ip}/bot${token}/${method}`;
+      return httpsJsonRequest(directUrl, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          host: apiHost,
+        },
+        body: JSON.stringify(payload),
+        lookup(hostname, options, callback) {
+          callback(null, ip, 4);
+        },
+        servername: apiHost,
+      });
+    },
+  },
+  "curl-json": {
+    async call(method, payload = {}) {
+      return curlJsonRequest(methodUrl(method), payload);
+    },
+  },
+};
+
+async function tryTransport(name, method, payload) {
+  try {
+    const result = await transports[name].call(method, payload);
+    console.log(`[openclaw-startup-notify] transport=${name} method=${method} status=ok`);
+    return { ok: true, result };
+  } catch (error) {
+    console.warn(
+      `[openclaw-startup-notify] transport=${name} method=${method} status=failed reason=${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+    return { ok: false, error };
+  }
+}
+
+async function discoverWorkingTransports() {
+  const order = Object.keys(transports);
+  const working = [];
+  for (const name of order) {
+    const probe = await tryTransport(name, "getMe", {});
+    if (probe.ok) working.push(name);
+  }
+  return working;
+}
+
+async function discoverChatIds(workingTransports) {
+  const configured = dedupe([
+    ...parseCsv(process.env.OPENCLAW_TELEGRAM_INIT_NOTIFY_CHAT_IDS?.trim()),
+    process.env.OPENCLAW_STARTUP_NOTIFY_TELEGRAM_TO?.trim(),
+    ...parseCsv(process.env.OPENCLAW_TELEGRAM_ALLOW_FROM?.trim()),
+  ]);
+  if (configured.length > 0) {
+    console.log(`[openclaw-startup-notify] chat_ids_source=configured count=${configured.length}`);
+    return configured;
+  }
+
+  for (const transport of workingTransports) {
+    const webhookInfo = await tryTransport(transport, "getWebhookInfo", {});
+    if (webhookInfo.ok) {
+      console.log(
+        `[openclaw-startup-notify] transport=${transport} webhook_url=${webhookInfo.result?.url || "-"} pending_updates=${
+          webhookInfo.result?.pending_update_count ?? 0
+        }`,
+      );
+    }
+    await tryTransport(transport, "deleteWebhook", { drop_pending_updates: false });
+    const updates = await tryTransport(transport, "getUpdates", {
+      timeout: 0,
+      limit: 10,
+      allowed_updates: ["message", "edited_message", "callback_query", "my_chat_member"],
+    });
+    if (updates.ok) {
+      const discovered = extractChatIdsFromUpdates(updates.result);
+      if (discovered.length > 0) {
+        console.log(`[openclaw-startup-notify] chat_ids_source=getUpdates transport=${transport} count=${discovered.length}`);
+        return discovered;
+      }
+    }
+  }
+
+  console.log("[openclaw-startup-notify] chat_ids_source=none count=0");
+  return [];
+}
+
+async function sendNotifications(workingTransports, chatIds) {
+  const { html, plain } = buildMessages();
+  const payloadVariants = [
+    {
+      name: "json-html",
+      build: (chatId, transport) => ({
+        chat_id: chatId,
+        text: `[startup transport=${transport} payload=json-html]\n${html}`,
+        parse_mode: "HTML",
+        disable_web_page_preview: true,
+      }),
+    },
+    {
+      name: "json-plain",
+      build: (chatId, transport) => ({
+        chat_id: chatId,
+        text: `[startup transport=${transport} payload=json-plain]\n${plain}`,
+        disable_web_page_preview: true,
+      }),
+    },
+  ];
+
+  for (const transport of workingTransports) {
+    for (const chatId of chatIds) {
+      for (const variant of payloadVariants) {
+        await delay(250);
+        const result = await tryTransport(transport, "sendMessage", variant.build(chatId, transport));
+        console.log(
+          `[openclaw-startup-notify] transport=${transport} chat=${chatId} payload=${variant.name} sent=${
+            result.ok ? "1" : "0"
+          }`,
+        );
+      }
+    }
+  }
+}
+
+try {
+  const workingTransports = await discoverWorkingTransports();
+  if (workingTransports.length === 0) {
+    console.warn("[openclaw-startup-notify] no working Telegram transport");
+    process.exit(0);
+  }
+  console.log(`[openclaw-startup-notify] working_transports=${workingTransports.join(",")}`);
+  const chatIds = await discoverChatIds(workingTransports);
+  if (chatIds.length === 0) {
+    console.warn("[openclaw-startup-notify] no chat ids available for startup notification");
+    process.exit(0);
+  }
+  await sendNotifications(workingTransports, chatIds);
+} catch (error) {
+  console.error(
+    `[openclaw-startup-notify] fatal ${
+      error instanceof Error ? `${error.name}: ${error.message}` : String(error)
+    }`,
+  );
   process.exit(0);
 }