chore(frontend): introduce prettier + eslint and prune unused code

- Add Prettier 3 with prettier-plugin-organize-imports (sorts/removes unused imports)
- Add ESLint 10 flat config with typescript-eslint + eslint-plugin-vue + eslint-config-prettier
- Add root scripts: format, format:check, lint, lint:fix
- Reformat 257 files across admin-web, ops-web, desktop-client, packages
- Remove unused locals/exports flagged by --noUnusedLocals/--noUnusedParameters
- Fix duplicate localTabLabel key, surrogate-pair regex u-flag, NBSP literal in regex
- Skip server/ (Go) and apps/browser-extension/ (deprecated per ADR)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

packages/publisher-platforms/src/jianshu.ts

@@ -1,193 +1,193 @@
 type JianshuCurrentUserResponse = {
-  id?: number;
-  nickname?: string;
-  avatar?: string;
-  preferred_note_type?: "plain" | "markdown";
-};
+  id?: number
+  nickname?: string
+  avatar?: string
+  preferred_note_type?: 'plain' | 'markdown'
+}
 
 type JianshuNotebookSummary = {
-  id?: number;
-  name?: string;
-};
+  id?: number
+  name?: string
+}
 
 type JianshuNoteCreateResponse = {
-  id?: number;
-  slug?: string;
-};
+  id?: number
+  slug?: string
+}
 
 type JianshuTokenResponse = {
-  token?: string;
-  key?: string;
-};
+  token?: string
+  key?: string
+}
 
 type JianshuQiniuResponse = {
-  url?: string;
-};
+  url?: string
+}
 
 type JianshuPublicizeResponse = {
-  id?: number;
-  slug?: string;
-  error?: Array<{ message?: string }>;
-};
+  id?: number
+  slug?: string
+  error?: Array<{ message?: string }>
+}
 
-export type JianshuNoteType = "plain" | "markdown";
+export type JianshuNoteType = 'plain' | 'markdown'
 
 export interface JianshuMediaSnapshot {
-  platformUid: string | null;
-  screenName: string | null;
-  avatarUrl: string | null;
-  preferredNoteType: JianshuNoteType;
+  platformUid: string | null
+  screenName: string | null
+  avatarUrl: string | null
+  preferredNoteType: JianshuNoteType
 }
 
 export interface JianshuPublishArticleInput {
-  title: string;
-  html: string;
-  markdown: string | null;
-  coverAssetUrl?: string | null;
+  title: string
+  html: string
+  markdown: string | null
+  coverAssetUrl?: string | null
 }
 
 export interface JianshuPublishTransport {
-  fetchJson<T>(input: string, init?: RequestInit): Promise<T>;
-  fetchImageBlob(sourceUrl: string): Promise<Blob | null>;
+  fetchJson<T>(input: string, init?: RequestInit): Promise<T>
+  fetchImageBlob(sourceUrl: string): Promise<Blob | null>
   reportProgress?(
     stage:
-      | "media_info"
-      | "fetch_notebook"
-      | "create_note"
-      | "upload_content_images"
-      | "save_content"
-      | "upload_cover"
-      | "publish",
-  ): void;
+      | 'media_info'
+      | 'fetch_notebook'
+      | 'create_note'
+      | 'upload_content_images'
+      | 'save_content'
+      | 'upload_cover'
+      | 'publish',
+  ): void
 }
 
 export type JianshuPublishResult =
   | {
-      success: true;
-      status: "success";
-      articleId: string;
-      mediaName: string;
-      externalManageUrl: string;
-      externalArticleUrl: string | null;
-      message: string;
+      success: true
+      status: 'success'
+      articleId: string
+      mediaName: string
+      externalManageUrl: string
+      externalArticleUrl: string | null
+      message: string
     }
   | {
-      success: false;
-      status: "failed";
+      success: false
+      status: 'failed'
       code:
-        | "jianshu_not_logged_in"
-        | "article_content_empty"
-        | "jianshu_no_notebook"
-        | "jianshu_create_note_failed"
-        | "jianshu_publish_failed";
-      message: string;
-    };
+        | 'jianshu_not_logged_in'
+        | 'article_content_empty'
+        | 'jianshu_no_notebook'
+        | 'jianshu_create_note_failed'
+        | 'jianshu_publish_failed'
+      message: string
+    }
 
-const JIANSHU_ORIGIN = "https://www.jianshu.com";
-const QINIU_UPLOAD_ENDPOINT = "https://upload.qiniup.com";
+const JIANSHU_ORIGIN = 'https://www.jianshu.com'
+const QINIU_UPLOAD_ENDPOINT = 'https://upload.qiniup.com'
 
 function randomFilenameStem(): string {
-  const ts = Date.now().toString(36);
-  const rand = Math.random().toString(36).slice(2, 10);
-  return `${ts}-${rand}`;
+  const ts = Date.now().toString(36)
+  const rand = Math.random().toString(36).slice(2, 10)
+  return `${ts}-${rand}`
 }
 
 function jianshuApiHeaders(extra: Record<string, string> = {}): Record<string, string> {
   return {
-    Accept: "application/json",
+    Accept: 'application/json',
     Referer: `${JIANSHU_ORIGIN}/`,
     Origin: JIANSHU_ORIGIN,
     ...extra,
-  };
+  }
 }
 
 function jianshuJsonHeaders(extra: Record<string, string> = {}): Record<string, string> {
   return jianshuApiHeaders({
-    "Content-Type": "application/json",
+    'Content-Type': 'application/json',
     ...extra,
-  });
+  })
 }
 
 function parseJianshuErrorMessage(error: unknown, fallback: string): string {
   if (error instanceof Error && error.message) {
     try {
       const parsed = JSON.parse(error.message) as {
-        error?: Array<{ message?: string }>;
-        message?: string;
-      };
-      const apiMessage = parsed?.error?.[0]?.message ?? parsed?.message;
+        error?: Array<{ message?: string }>
+        message?: string
+      }
+      const apiMessage = parsed?.error?.[0]?.message ?? parsed?.message
       if (apiMessage) {
-        return apiMessage;
+        return apiMessage
       }
     } catch {
       // not JSON — fall through to raw message
     }
-    return error.message;
+    return error.message
   }
-  return fallback;
+  return fallback
 }
 
 function extractHtmlAttribute(sourceTag: string, attributeName: string): string | null {
-  const matcher = new RegExp(`\\s${attributeName}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i");
-  const match = matcher.exec(sourceTag);
-  const value = match?.[1] ?? match?.[2] ?? match?.[3] ?? "";
-  const trimmed = value.trim();
-  return trimmed ? trimmed : null;
+  const matcher = new RegExp(
+    `\\s${attributeName}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`,
+    'i',
+  )
+  const match = matcher.exec(sourceTag)
+  const value = match?.[1] ?? match?.[2] ?? match?.[3] ?? ''
+  const trimmed = value.trim()
+  return trimmed ? trimmed : null
 }
 
 function escapeMarkdownAlt(value: string): string {
-  return value.replace(/\\/g, "\\\\").replace(/\]/g, "\\]");
+  return value.replace(/\\/g, '\\\\').replace(/\]/g, '\\]')
 }
 
 function markdownImageFromHtmlTag(imgTag: string): string {
-  const src = extractHtmlAttribute(imgTag, "src");
+  const src = extractHtmlAttribute(imgTag, 'src')
   if (!src) {
-    return imgTag;
+    return imgTag
   }
 
-  const alt = extractHtmlAttribute(imgTag, "alt") ?? "";
-  return `![${escapeMarkdownAlt(alt)}](${src})`;
+  const alt = extractHtmlAttribute(imgTag, 'alt') ?? ''
+  return `![${escapeMarkdownAlt(alt)}](${src})`
 }
 
 export function renderJianshuHtmlImagesAsMarkdown(content: string): string {
   if (!/<img\b/i.test(content)) {
-    return content;
+    return content
   }
 
   let next = content.replace(
     /<p\b[^>]*>\s*(<img\b[^>]*\/?>)\s*<\/p>/gi,
     (_match, imgTag: string) => `\n\n${markdownImageFromHtmlTag(imgTag)}\n\n`,
-  );
+  )
 
   next = next.replace(
     /<img\b[^>]*\/?>/gi,
     (imgTag) => `\n\n${markdownImageFromHtmlTag(imgTag)}\n\n`,
-  );
+  )
 
-  return next.replace(/\n{3,}/g, "\n\n").trim();
+  return next.replace(/\n{3,}/g, '\n\n').trim()
 }
 
 export async function fetchJianshuMediaSnapshot(
   fetchJson: <T>(input: string, init?: RequestInit) => Promise<T>,
 ): Promise<JianshuMediaSnapshot | null> {
-  const me = await fetchJson<JianshuCurrentUserResponse>(
-    `${JIANSHU_ORIGIN}/author/current_user`,
-    {
-      method: "GET",
-      headers: jianshuApiHeaders(),
-    },
-  ).catch(() => null);
+  const me = await fetchJson<JianshuCurrentUserResponse>(`${JIANSHU_ORIGIN}/author/current_user`, {
+    method: 'GET',
+    headers: jianshuApiHeaders(),
+  }).catch(() => null)
 
   if (!me?.id) {
-    return null;
+    return null
   }
 
   return {
     platformUid: String(me.id),
     screenName: me.nickname ?? null,
     avatarUrl: me.avatar ?? null,
-    preferredNoteType: me.preferred_note_type === "markdown" ? "markdown" : "plain",
-  };
+    preferredNoteType: me.preferred_note_type === 'markdown' ? 'markdown' : 'plain',
+  }
 }
 
 async function fetchPrimaryNotebookId(
@@ -196,13 +196,13 @@ async function fetchPrimaryNotebookId(
   const notebooks = await fetchJson<JianshuNotebookSummary[]>(
     `${JIANSHU_ORIGIN}/author/notebooks`,
     {
-      method: "GET",
+      method: 'GET',
       headers: jianshuApiHeaders(),
     },
-  ).catch(() => null);
+  ).catch(() => null)
 
-  const first = notebooks?.find((item) => typeof item?.id === "number");
-  return first?.id ?? null;
+  const first = notebooks?.find((item) => typeof item?.id === 'number')
+  return first?.id ?? null
 }
 
 async function createNote(
@@ -210,102 +210,100 @@ async function createNote(
   notebookId: number,
   title: string,
 ): Promise<JianshuNoteCreateResponse | null> {
-  return await fetchJson<JianshuNoteCreateResponse>(
-    `${JIANSHU_ORIGIN}/author/notes`,
-    {
-      method: "POST",
-      headers: jianshuJsonHeaders(),
-      body: JSON.stringify({
-        notebook_id: notebookId,
-        title,
-        at_bottom: true,
-      }),
-    },
-  ).catch(() => null);
+  return await fetchJson<JianshuNoteCreateResponse>(`${JIANSHU_ORIGIN}/author/notes`, {
+    method: 'POST',
+    headers: jianshuJsonHeaders(),
+    body: JSON.stringify({
+      notebook_id: notebookId,
+      title,
+      at_bottom: true,
+    }),
+  }).catch(() => null)
 }
 
 async function uploadImageToQiniu(
   transport: JianshuPublishTransport,
   sourceUrl: string,
 ): Promise<string | null> {
-  const blob = await transport.fetchImageBlob(sourceUrl);
-  if (!blob || !blob.type.startsWith("image/")) {
-    return null;
+  const blob = await transport.fetchImageBlob(sourceUrl)
+  if (!blob || !blob.type.startsWith('image/')) {
+    return null
   }
 
-  const filename = `${randomFilenameStem()}.png`;
-  const token = await transport.fetchJson<JianshuTokenResponse>(
-    `${JIANSHU_ORIGIN}/upload_images/token.json?filename=${encodeURIComponent(filename)}`,
-    {
-      method: "GET",
-      headers: jianshuApiHeaders(),
-    },
-  ).catch(() => null);
+  const filename = `${randomFilenameStem()}.png`
+  const token = await transport
+    .fetchJson<JianshuTokenResponse>(
+      `${JIANSHU_ORIGIN}/upload_images/token.json?filename=${encodeURIComponent(filename)}`,
+      {
+        method: 'GET',
+        headers: jianshuApiHeaders(),
+      },
+    )
+    .catch(() => null)
 
   if (!token?.token || !token.key) {
-    return null;
+    return null
   }
 
-  const form = new FormData();
-  form.append("token", token.token);
-  form.append("key", token.key);
-  form.append("file", blob, filename);
-  form.append("x:protocol", "https");
+  const form = new FormData()
+  form.append('token', token.token)
+  form.append('key', token.key)
+  form.append('file', blob, filename)
+  form.append('x:protocol', 'https')
 
-  const uploaded = await transport.fetchJson<JianshuQiniuResponse>(
-    QINIU_UPLOAD_ENDPOINT,
-    {
-      method: "POST",
-      headers: { Accept: "application/json" },
+  const uploaded = await transport
+    .fetchJson<JianshuQiniuResponse>(QINIU_UPLOAD_ENDPOINT, {
+      method: 'POST',
+      headers: { Accept: 'application/json' },
       body: form,
-    },
-  ).catch(() => null);
+    })
+    .catch(() => null)
 
-  return uploaded?.url ?? null;
+  return uploaded?.url ?? null
 }
 
 function collectImageSources(content: string): string[] {
-  const sources = new Set<string>();
+  const sources = new Set<string>()
   for (const match of content.matchAll(/<img\b[^>]*src=(['"])(.*?)\1[^>]*>/gi)) {
-    const src = match[2]?.trim();
+    const src = match[2]?.trim()
     if (src) {
-      sources.add(src);
+      sources.add(src)
     }
   }
   for (const match of content.matchAll(/!\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g)) {
-    const src = match[1]?.trim();
+    const src = match[1]?.trim()
     if (src) {
-      sources.add(src);
+      sources.add(src)
     }
   }
-  return [...sources];
+  return [...sources]
 }
 
 async function processContentImages(
   transport: JianshuPublishTransport,
   content: string,
 ): Promise<string> {
-  const sources = collectImageSources(content);
+  const sources = collectImageSources(content)
   if (!sources.length) {
-    return content;
+    return content
   }
 
-  const replacements = new Map<string, string>();
+  const replacements = new Map<string, string>()
   for (const source of sources) {
     if (/jianshu\.io|sfx\.jianshu/i.test(source)) {
-      continue;
+      continue
     }
-    const uploaded = await uploadImageToQiniu(transport, source);
+    const uploaded = await uploadImageToQiniu(transport, source)
     if (uploaded) {
-      replacements.set(source, uploaded);
+      replacements.set(source, uploaded)
     }
   }
 
-  let next = content;
+  let next = content
   for (const [from, to] of replacements.entries()) {
-    next = next.split(from).join(to);
+    next = next.split(from).join(to)
   }
-  return renderJianshuHtmlImagesAsMarkdown(next);
+  return renderJianshuHtmlImagesAsMarkdown(next)
 }
 
 async function attachCoverImage(
@@ -313,145 +311,143 @@ async function attachCoverImage(
   noteId: number,
   coverAssetUrl: string,
 ): Promise<void> {
-  const coverUrl = await uploadImageToQiniu(transport, coverAssetUrl);
+  const coverUrl = await uploadImageToQiniu(transport, coverAssetUrl)
   if (!coverUrl) {
-    return;
+    return
   }
-  await transport.fetchJson<unknown>(
-    `${JIANSHU_ORIGIN}/author/notes/${noteId}/update_cover_images`,
-    {
-      method: "POST",
-      headers: jianshuJsonHeaders({ "Content-Type": "application/json; charset=UTF-8" }),
+  await transport
+    .fetchJson<unknown>(`${JIANSHU_ORIGIN}/author/notes/${noteId}/update_cover_images`, {
+      method: 'POST',
+      headers: jianshuJsonHeaders({ 'Content-Type': 'application/json; charset=UTF-8' }),
       body: JSON.stringify({
         flow_type: 14,
-        abbr: "",
+        abbr: '',
         cover_image_urls: [coverUrl],
       }),
-    },
-  ).catch(() => null);
+    })
+    .catch(() => null)
 }
 
-async function softDestroyNote(
-  transport: JianshuPublishTransport,
-  noteId: number,
-): Promise<void> {
-  await transport.fetchJson<unknown>(
-    `${JIANSHU_ORIGIN}/author/notes/${noteId}/soft_destroy`,
-    {
-      method: "POST",
+async function softDestroyNote(transport: JianshuPublishTransport, noteId: number): Promise<void> {
+  await transport
+    .fetchJson<unknown>(`${JIANSHU_ORIGIN}/author/notes/${noteId}/soft_destroy`, {
+      method: 'POST',
       headers: jianshuApiHeaders(),
-    },
-  ).catch(() => null);
+    })
+    .catch(() => null)
 }
 
 function buildExternalManageUrl(notebookId: number, noteId: number): string {
-  return `${JIANSHU_ORIGIN}/writer#/notebooks/${notebookId}/notes/${noteId}`;
+  return `${JIANSHU_ORIGIN}/writer#/notebooks/${notebookId}/notes/${noteId}`
 }
 
 function buildExternalArticleUrl(slug: string | null | undefined): string | null {
-  return slug ? `${JIANSHU_ORIGIN}/p/${slug}` : null;
+  return slug ? `${JIANSHU_ORIGIN}/p/${slug}` : null
 }
 
 function sanitizeJianshuHtml(html: string): string {
-  let next = html;
+  let next = html
 
-  next = next.replace(/<(script|style|iframe|noscript|link|meta)\b[^>]*>[\s\S]*?<\/\1>/gi, "");
-  next = next.replace(/<(script|style|iframe|noscript|link|meta)\b[^>]*\/?>/gi, "");
+  next = next.replace(/<(script|style|iframe|noscript|link|meta)\b[^>]*>[\s\S]*?<\/\1>/gi, '')
+  next = next.replace(/<(script|style|iframe|noscript|link|meta)\b[^>]*\/?>/gi, '')
 
-  next = next.replace(/<section\b/gi, "<div").replace(/<\/section>/gi, "</div>");
+  next = next.replace(/<section\b/gi, '<div').replace(/<\/section>/gi, '</div>')
 
-  next = next.replace(/<figure[^>]*>\s*(<img\b[^>]*>)\s*(?:<figcaption[^>]*>[\s\S]*?<\/figcaption>)?\s*<\/figure>/gi, "$1");
+  next = next.replace(
+    /<figure[^>]*>\s*(<img\b[^>]*>)\s*(?:<figcaption[^>]*>[\s\S]*?<\/figcaption>)?\s*<\/figure>/gi,
+    '$1',
+  )
 
-  next = next.replace(/\son[a-z]+="[^"]*"/gi, "");
-  next = next.replace(/\sstyle="[^"]*"/gi, "");
-  next = next.replace(/\sclass="[^"]*"/gi, "");
-  next = next.replace(/\sdata-[a-z-]+="[^"]*"/gi, "");
+  next = next.replace(/\son[a-z]+="[^"]*"/gi, '')
+  next = next.replace(/\sstyle="[^"]*"/gi, '')
+  next = next.replace(/\sclass="[^"]*"/gi, '')
+  next = next.replace(/\sdata-[a-z-]+="[^"]*"/gi, '')
 
   next = next.replace(/<table\b([^>]*)>([\s\S]*?)<\/table>/gi, (_match, attrs, inner) => {
-    let body = inner;
+    let body = inner
     if (!/<thead\b/i.test(body) && !/<tbody\b/i.test(body)) {
-      body = `<tbody>${body}</tbody>`;
+      body = `<tbody>${body}</tbody>`
     }
-    return `<table${attrs}>${body}</table>`;
-  });
+    return `<table${attrs}>${body}</table>`
+  })
 
-  return next.trim();
+  return next.trim()
 }
 
 function pickContent(
   input: JianshuPublishArticleInput,
   noteType: JianshuNoteType,
 ): { content: string; usedMarkdown: boolean } {
-  if (noteType === "markdown") {
-    const md = input.markdown?.trim();
+  if (noteType === 'markdown') {
+    const md = input.markdown?.trim()
     if (md) {
-      return { content: md, usedMarkdown: true };
+      return { content: md, usedMarkdown: true }
     }
   }
   return {
     content: sanitizeJianshuHtml(input.html.trim()),
     usedMarkdown: false,
-  };
+  }
 }
 
 export async function publishJianshuArticle(
   input: JianshuPublishArticleInput,
   transport: JianshuPublishTransport,
 ): Promise<JianshuPublishResult> {
-  transport.reportProgress?.("media_info");
-  const media = await fetchJianshuMediaSnapshot(transport.fetchJson);
+  transport.reportProgress?.('media_info')
+  const media = await fetchJianshuMediaSnapshot(transport.fetchJson)
   if (!media?.platformUid) {
     return {
       success: false,
-      status: "failed",
-      code: "jianshu_not_logged_in",
-      message: "未检测到简书登录态",
-    };
+      status: 'failed',
+      code: 'jianshu_not_logged_in',
+      message: '未检测到简书登录态',
+    }
   }
 
-  const { content } = pickContent(input, media.preferredNoteType);
+  const { content } = pickContent(input, media.preferredNoteType)
   if (!content) {
     return {
       success: false,
-      status: "failed",
-      code: "article_content_empty",
-      message: "html_content/markdown_content is empty",
-    };
+      status: 'failed',
+      code: 'article_content_empty',
+      message: 'html_content/markdown_content is empty',
+    }
   }
 
-  transport.reportProgress?.("fetch_notebook");
-  const notebookId = await fetchPrimaryNotebookId(transport.fetchJson);
+  transport.reportProgress?.('fetch_notebook')
+  const notebookId = await fetchPrimaryNotebookId(transport.fetchJson)
   if (!notebookId) {
     return {
       success: false,
-      status: "failed",
-      code: "jianshu_no_notebook",
-      message: "没有找到文集，请先在简书创建一个文集",
-    };
+      status: 'failed',
+      code: 'jianshu_no_notebook',
+      message: '没有找到文集，请先在简书创建一个文集',
+    }
   }
 
-  transport.reportProgress?.("create_note");
-  const note = await createNote(transport.fetchJson, notebookId, input.title);
+  transport.reportProgress?.('create_note')
+  const note = await createNote(transport.fetchJson, notebookId, input.title)
   if (!note?.id) {
     return {
       success: false,
-      status: "failed",
-      code: "jianshu_create_note_failed",
-      message: "创建文章失败",
-    };
+      status: 'failed',
+      code: 'jianshu_create_note_failed',
+      message: '创建文章失败',
+    }
   }
 
-  const noteId = note.id;
-  let createdSlug = note.slug ?? null;
-  let publishOk = false;
+  const noteId = note.id
+  let createdSlug = note.slug ?? null
+  let publishOk = false
 
   try {
-    transport.reportProgress?.("upload_content_images");
-    const processedContent = await processContentImages(transport, content);
+    transport.reportProgress?.('upload_content_images')
+    const processedContent = await processContentImages(transport, content)
 
-    transport.reportProgress?.("save_content");
+    transport.reportProgress?.('save_content')
     await transport.fetchJson<unknown>(`${JIANSHU_ORIGIN}/author/notes/${noteId}`, {
-      method: "PUT",
+      method: 'PUT',
       headers: jianshuJsonHeaders(),
       body: JSON.stringify({
         id: noteId,
@@ -459,56 +455,57 @@ export async function publishJianshuArticle(
         title: input.title,
         content: processedContent,
       }),
-    });
+    })
 
     if (input.coverAssetUrl?.trim()) {
-      transport.reportProgress?.("upload_cover");
-      await attachCoverImage(transport, noteId, input.coverAssetUrl.trim());
+      transport.reportProgress?.('upload_cover')
+      await attachCoverImage(transport, noteId, input.coverAssetUrl.trim())
     }
 
-    transport.reportProgress?.("publish");
-    const publicize = await transport.fetchJson<JianshuPublicizeResponse>(
-      `${JIANSHU_ORIGIN}/author/notes/${noteId}/publicize`,
-      {
-        method: "POST",
+    transport.reportProgress?.('publish')
+    const publicize = await transport
+      .fetchJson<JianshuPublicizeResponse>(`${JIANSHU_ORIGIN}/author/notes/${noteId}/publicize`, {
+        method: 'POST',
         headers: jianshuJsonHeaders(),
-      },
-    ).catch((error: unknown): JianshuPublicizeResponse => ({
-      error: [{ message: parseJianshuErrorMessage(error, "jianshu_publish_failed") }],
-    }));
+      })
+      .catch(
+        (error: unknown): JianshuPublicizeResponse => ({
+          error: [{ message: parseJianshuErrorMessage(error, 'jianshu_publish_failed') }],
+        }),
+      )
 
     if (publicize.error?.length) {
       return {
         success: false,
-        status: "failed",
-        code: "jianshu_publish_failed",
-        message: publicize.error[0]?.message || "发布失败，请稍后重试",
-      };
+        status: 'failed',
+        code: 'jianshu_publish_failed',
+        message: publicize.error[0]?.message || '发布失败，请稍后重试',
+      }
     }
 
-    publishOk = true;
+    publishOk = true
     if (publicize.slug) {
-      createdSlug = publicize.slug;
+      createdSlug = publicize.slug
     }
   } catch (error) {
     if (!publishOk) {
-      await softDestroyNote(transport, noteId);
+      await softDestroyNote(transport, noteId)
     }
     return {
       success: false,
-      status: "failed",
-      code: "jianshu_publish_failed",
-      message: error instanceof Error ? error.message : "jianshu_publish_failed",
-    };
+      status: 'failed',
+      code: 'jianshu_publish_failed',
+      message: error instanceof Error ? error.message : 'jianshu_publish_failed',
+    }
   }
 
   return {
     success: true,
-    status: "success",
+    status: 'success',
     articleId: String(noteId),
-    mediaName: media.screenName ?? "",
+    mediaName: media.screenName ?? '',
     externalManageUrl: buildExternalManageUrl(notebookId, noteId),
     externalArticleUrl: buildExternalArticleUrl(createdSlug),
-    message: "简书发布成功。",
-  };
+    message: '简书发布成功。',
+  }
 }