geo/packages/publisher-platforms/src/jianshu.ts

type JianshuCurrentUserResponse = {
  id?: number
  nickname?: string
  avatar?: string
  preferred_note_type?: 'plain' | 'markdown'
}

type JianshuNotebookSummary = {
  id?: number
  name?: string
}

type JianshuNoteCreateResponse = {
  id?: number
  slug?: string
}

type JianshuTokenResponse = {
  token?: string
  key?: string
}

type JianshuQiniuResponse = {
  url?: string
}

type JianshuPublicizeResponse = {
  id?: number
  slug?: string
  error?: Array<{ message?: string }>
}

export type JianshuNoteType = 'plain' | 'markdown'

export interface JianshuMediaSnapshot {
  platformUid: string | null
  screenName: string | null
  avatarUrl: string | null
  preferredNoteType: JianshuNoteType
}

export interface JianshuPublishArticleInput {
  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>
  reportProgress?(
    stage:
      | '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: false
      status: 'failed'
      code:
        | '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'

function randomFilenameStem(): string {
  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',
    Referer: `${JIANSHU_ORIGIN}/`,
    Origin: JIANSHU_ORIGIN,
    ...extra,
  }
}

function jianshuJsonHeaders(extra: Record<string, string> = {}): Record<string, string> {
  return jianshuApiHeaders({
    '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
      if (apiMessage) {
        return apiMessage
      }
    } catch {
      // not JSON — fall through to raw message
    }
    return error.message
  }
  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
}

function escapeMarkdownAlt(value: string): string {
  return value.replace(/\\/g, '\\\\').replace(/\]/g, '\\]')
}

function markdownImageFromHtmlTag(imgTag: string): string {
  const src = extractHtmlAttribute(imgTag, 'src')
  if (!src) {
    return imgTag
  }

  const alt = extractHtmlAttribute(imgTag, 'alt') ?? ''
  return `![${escapeMarkdownAlt(alt)}](${src})`
}

export function renderJianshuHtmlImagesAsMarkdown(content: string): string {
  if (!/<img\b/i.test(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()
}

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)

  if (!me?.id) {
    return null
  }

  return {
    platformUid: String(me.id),
    screenName: me.nickname ?? null,
    avatarUrl: me.avatar ?? null,
    preferredNoteType: me.preferred_note_type === 'markdown' ? 'markdown' : 'plain',
  }
}

async function fetchPrimaryNotebookId(
  fetchJson: <T>(input: string, init?: RequestInit) => Promise<T>,
): Promise<number | null> {
  const notebooks = await fetchJson<JianshuNotebookSummary[]>(
    `${JIANSHU_ORIGIN}/author/notebooks`,
    {
      method: 'GET',
      headers: jianshuApiHeaders(),
    },
  ).catch(() => null)

  const first = notebooks?.find((item) => typeof item?.id === 'number')
  return first?.id ?? null
}

async function createNote(
  fetchJson: <T>(input: string, init?: RequestInit) => Promise<T>,
  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)
}

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 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
  }

  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' },
      body: form,
    })
    .catch(() => null)

  return uploaded?.url ?? null
}

function collectImageSources(content: string): string[] {
  const sources = new Set<string>()
  for (const match of content.matchAll(/<img\b[^>]*src=(['"])(.*?)\1[^>]*>/gi)) {
    const src = match[2]?.trim()
    if (src) {
      sources.add(src)
    }
  }
  for (const match of content.matchAll(/!\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g)) {
    const src = match[1]?.trim()
    if (src) {
      sources.add(src)
    }
  }
  return [...sources]
}

async function processContentImages(
  transport: JianshuPublishTransport,
  content: string,
): Promise<string> {
  const sources = collectImageSources(content)
  if (!sources.length) {
    return content
  }

  const replacements = new Map<string, string>()
  for (const source of sources) {
    if (/jianshu\.io|sfx\.jianshu/i.test(source)) {
      continue
    }
    const uploaded = await uploadImageToQiniu(transport, source)
    if (uploaded) {
      replacements.set(source, uploaded)
    }
  }

  let next = content
  for (const [from, to] of replacements.entries()) {
    next = next.split(from).join(to)
  }
  return renderJianshuHtmlImagesAsMarkdown(next)
}

async function attachCoverImage(
  transport: JianshuPublishTransport,
  noteId: number,
  coverAssetUrl: string,
): Promise<void> {
  const coverUrl = await uploadImageToQiniu(transport, coverAssetUrl)
  if (!coverUrl) {
    return
  }
  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: '',
        cover_image_urls: [coverUrl],
      }),
    })
    .catch(() => null)
}

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)
}

function buildExternalManageUrl(notebookId: number, noteId: number): string {
  return `${JIANSHU_ORIGIN}/writer#/notebooks/${notebookId}/notes/${noteId}`
}

function buildExternalArticleUrl(slug: string | null | undefined): string | null {
  return slug ? `${JIANSHU_ORIGIN}/p/${slug}` : null
}

function sanitizeJianshuHtml(html: string): string {
  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(/<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(/\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
    if (!/<thead\b/i.test(body) && !/<tbody\b/i.test(body)) {
      body = `<tbody>${body}</tbody>`
    }
    return `<table${attrs}>${body}</table>`
  })

  return next.trim()
}

function pickContent(
  input: JianshuPublishArticleInput,
  noteType: JianshuNoteType,
): { content: string; usedMarkdown: boolean } {
  if (noteType === 'markdown') {
    const md = input.markdown?.trim()
    if (md) {
      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)
  if (!media?.platformUid) {
    return {
      success: false,
      status: 'failed',
      code: 'jianshu_not_logged_in',
      message: '未检测到简书登录态',
    }
  }

  const { content } = pickContent(input, media.preferredNoteType)
  if (!content) {
    return {
      success: false,
      status: 'failed',
      code: 'article_content_empty',
      message: 'html_content/markdown_content is empty',
    }
  }

  transport.reportProgress?.('fetch_notebook')
  const notebookId = await fetchPrimaryNotebookId(transport.fetchJson)
  if (!notebookId) {
    return {
      success: false,
      status: 'failed',
      code: 'jianshu_no_notebook',
      message: '没有找到文集，请先在简书创建一个文集',
    }
  }

  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: '创建文章失败',
    }
  }

  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?.('save_content')
    await transport.fetchJson<unknown>(`${JIANSHU_ORIGIN}/author/notes/${noteId}`, {
      method: 'PUT',
      headers: jianshuJsonHeaders(),
      body: JSON.stringify({
        id: noteId,
        autosave_control: 1,
        title: input.title,
        content: processedContent,
      }),
    })

    if (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',
        headers: jianshuJsonHeaders(),
      })
      .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 || '发布失败，请稍后重试',
      }
    }

    publishOk = true
    if (publicize.slug) {
      createdSlug = publicize.slug
    }
  } catch (error) {
    if (!publishOk) {
      await softDestroyNote(transport, noteId)
    }
    return {
      success: false,
      status: 'failed',
      code: 'jianshu_publish_failed',
      message: error instanceof Error ? error.message : 'jianshu_publish_failed',
    }
  }

  return {
    success: true,
    status: 'success',
    articleId: String(noteId),
    mediaName: media.screenName ?? '',
    externalManageUrl: buildExternalManageUrl(notebookId, noteId),
    externalArticleUrl: buildExternalArticleUrl(createdSlug),
    message: '简书发布成功。',
  }
}