Merge pull request #4651 from yuting0624/fix/status-command-line-crash

fix(line): resolve TypeError in status command when LINE is enabled

CHANGELOG.md

@@ -74,6 +74,7 @@ Status: stable.
 
 ### Fixes
 - Telegram: use undici fetch for per-account proxy dispatcher. (#4456) Thanks @spiceoogway.
+- Telegram: fix HTML nesting for overlapping styles and links. (#4578) Thanks @ThanhNguyxn.
 - Telegram: avoid silent empty replies by tracking normalization skips before fallback. (#3796)
 - Telegram: accept numeric messageId/chatId in react action and honor channelId fallback. (#4533) Thanks @Ayush10.
 - Telegram: scope native skill commands to bound agent per bot. (#4360) Thanks @robhparker.

extensions/line/src/channel.ts

@@ -4,6 +4,7 @@ import {
   LineConfigSchema,
   processLineMessage,
   type ChannelPlugin,
+  type ChannelStatusIssue,
   type OpenClawConfig,
   type LineConfig,
   type LineChannelData,
@@ -560,19 +561,26 @@ export const linePlugin: ChannelPlugin<ResolvedLineAccount> = {
       lastStopAt: null,
       lastError: null,
     },
-    collectStatusIssues: ({ account }) => {
-      const issues: Array<{ level: "error" | "warning"; message: string }> = [];
-      if (!account.channelAccessToken?.trim()) {
-        issues.push({
-          level: "error",
-          message: "LINE channel access token not configured",
-        });
-      }
-      if (!account.channelSecret?.trim()) {
-        issues.push({
-          level: "error",
-          message: "LINE channel secret not configured",
-        });
+    collectStatusIssues: (accounts) => {
+      const issues: ChannelStatusIssue[] = [];
+      for (const account of accounts) {
+        const accountId = account.accountId ?? DEFAULT_ACCOUNT_ID;
+        if (!account.channelAccessToken?.trim()) {
+          issues.push({
+            channel: "line",
+            accountId,
+            kind: "config",
+            message: "LINE channel access token not configured",
+          });
+        }
+        if (!account.channelSecret?.trim()) {
+          issues.push({
+            channel: "line",
+            accountId,
+            kind: "config",
+            message: "LINE channel secret not configured",
+          });
+        }
       }
       return issues;
     },

src/agents/auth-health.test.ts

@@ -52,11 +52,39 @@ describe("buildAuthHealthSummary", () => {
     );
 
     expect(statuses["anthropic:ok"]).toBe("ok");
-    expect(statuses["anthropic:expiring"]).toBe("expiring");
-    expect(statuses["anthropic:expired"]).toBe("expired");
+    // OAuth credentials with refresh tokens are auto-renewable, so they report "ok"
+    expect(statuses["anthropic:expiring"]).toBe("ok");
+    expect(statuses["anthropic:expired"]).toBe("ok");
     expect(statuses["anthropic:api"]).toBe("static");
 
     const provider = summary.providers.find((entry) => entry.provider === "anthropic");
-    expect(provider?.status).toBe("expired");
+    expect(provider?.status).toBe("ok");
+  });
+
+  it("reports expired for OAuth without a refresh token", () => {
+    vi.spyOn(Date, "now").mockReturnValue(now);
+    const store = {
+      version: 1,
+      profiles: {
+        "google:no-refresh": {
+          type: "oauth" as const,
+          provider: "google-antigravity",
+          access: "access",
+          refresh: "",
+          expires: now - 10_000,
+        },
+      },
+    };
+
+    const summary = buildAuthHealthSummary({
+      store,
+      warnAfterMs: DEFAULT_OAUTH_WARN_MS,
+    });
+
+    const statuses = Object.fromEntries(
+      summary.profiles.map((profile) => [profile.profileId, profile.status]),
+    );
+
+    expect(statuses["google:no-refresh"]).toBe("expired");
   });
 });

src/agents/auth-health.ts

@@ -123,7 +123,16 @@ function buildProfileHealth(params: {
     };
   }
 
-  const { status, remainingMs } = resolveOAuthStatus(credential.expires, now, warnAfterMs);
+  const hasRefreshToken = typeof credential.refresh === "string" && credential.refresh.length > 0;
+  const { status: rawStatus, remainingMs } = resolveOAuthStatus(
+    credential.expires,
+    now,
+    warnAfterMs,
+  );
+  // OAuth credentials with a valid refresh token auto-renew on first API call,
+  // so don't warn about access token expiration.
+  const status =
+    hasRefreshToken && (rawStatus === "expired" || rawStatus === "expiring") ? "ok" : rawStatus;
   return {
     profileId,
     provider: credential.provider,

src/markdown/render.ts

@@ -69,7 +69,6 @@ export function renderMarkdownWithMarkers(ir: MarkdownIR, options: RenderOptions
   }
 
   const linkStarts = new Map<number, RenderLink[]>();
-  const linkEnds = new Map<number, RenderLink[]>();
   if (options.buildLink) {
     for (const link of ir.links) {
       if (link.start === link.end) continue;
@@ -80,47 +79,78 @@ export function renderMarkdownWithMarkers(ir: MarkdownIR, options: RenderOptions
       const openBucket = linkStarts.get(rendered.start);
       if (openBucket) openBucket.push(rendered);
       else linkStarts.set(rendered.start, [rendered]);
-      const closeBucket = linkEnds.get(rendered.end);
-      if (closeBucket) closeBucket.push(rendered);
-      else linkEnds.set(rendered.end, [rendered]);
     }
   }
 
   const points = [...boundaries].sort((a, b) => a - b);
-  const stack: MarkdownStyleSpan[] = [];
+  // Unified stack for both styles and links, tracking close string and end position
+  const stack: { close: string; end: number }[] = [];
+  type OpeningItem =
+    | { end: number; open: string; close: string; kind: "link"; index: number }
+    | {
+        end: number;
+        open: string;
+        close: string;
+        kind: "style";
+        style: MarkdownStyle;
+        index: number;
+      };
   let out = "";
 
   for (let i = 0; i < points.length; i += 1) {
     const pos = points[i];
 
+    // Close ALL elements (styles and links) in LIFO order at this position
     while (stack.length && stack[stack.length - 1]?.end === pos) {
-      const span = stack.pop();
-      if (!span) break;
-      const marker = styleMarkers[span.style];
-      if (marker) out += marker.close;
+      const item = stack.pop();
+      if (item) out += item.close;
     }
 
-    const closingLinks = linkEnds.get(pos);
-    if (closingLinks && closingLinks.length > 0) {
-      for (const link of closingLinks) {
-        out += link.close;
-      }
-    }
+    const openingItems: OpeningItem[] = [];
 
     const openingLinks = linkStarts.get(pos);
     if (openingLinks && openingLinks.length > 0) {
-      for (const link of openingLinks) {
-        out += link.open;
+      for (const [index, link] of openingLinks.entries()) {
+        openingItems.push({
+          end: link.end,
+          open: link.open,
+          close: link.close,
+          kind: "link",
+          index,
+        });
       }
     }
 
     const openingStyles = startsAt.get(pos);
     if (openingStyles) {
-      for (const span of openingStyles) {
+      for (const [index, span] of openingStyles.entries()) {
         const marker = styleMarkers[span.style];
         if (!marker) continue;
-        stack.push(span);
-        out += marker.open;
+        openingItems.push({
+          end: span.end,
+          open: marker.open,
+          close: marker.close,
+          kind: "style",
+          style: span.style,
+          index,
+        });
+      }
+    }
+
+    if (openingItems.length > 0) {
+      openingItems.sort((a, b) => {
+        if (a.end !== b.end) return b.end - a.end;
+        if (a.kind !== b.kind) return a.kind === "link" ? -1 : 1;
+        if (a.kind === "style" && b.kind === "style") {
+          return (STYLE_RANK.get(a.style) ?? 0) - (STYLE_RANK.get(b.style) ?? 0);
+        }
+        return a.index - b.index;
+      });
+
+      // Open outer spans first (larger end) so LIFO closes stay valid for same-start overlaps.
+      for (const item of openingItems) {
+        out += item.open;
+        stack.push({ close: item.close, end: item.end });
       }
     }
 

src/telegram/format.test.ts

@@ -47,4 +47,26 @@ describe("markdownToTelegramHtml", () => {
     const res = markdownToTelegramHtml("```js\nconst x = 1;\n```");
     expect(res).toBe("<pre><code>const x = 1;\n</code></pre>");
   });
+
+  it("properly nests overlapping bold and autolink (#4071)", () => {
+    const res = markdownToTelegramHtml("**start https://example.com** end");
+    expect(res).toMatch(
+      /<b>start <a href="https:\/\/example\.com">https:\/\/example\.com<\/a><\/b> end/,
+    );
+  });
+
+  it("properly nests link inside bold", () => {
+    const res = markdownToTelegramHtml("**bold [link](https://example.com) text**");
+    expect(res).toBe('<b>bold <a href="https://example.com">link</a> text</b>');
+  });
+
+  it("properly nests bold wrapping a link with trailing text", () => {
+    const res = markdownToTelegramHtml("**[link](https://example.com) rest**");
+    expect(res).toBe('<b><a href="https://example.com">link</a> rest</b>');
+  });
+
+  it("properly nests bold inside a link", () => {
+    const res = markdownToTelegramHtml("[**bold**](https://example.com)");
+    expect(res).toBe('<a href="https://example.com"><b>bold</b></a>');
+  });
 });