ants-move 0.0.1

package/dist/index.js

@@ -0,0 +1,2214 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+
+// src/cli.ts
+import { Command, CommanderError } from "commander";
+import { ZodError } from "zod";
+
+// src/hn/command.ts
+import { z } from "zod";
+
+// src/output.ts
+import { stripVTControlCharacters } from "util";
+import { table } from "table";
+function sanitizeTableCell(value) {
+  return stripVTControlCharacters(String(value)).replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ").replace(/ +/g, " ").trim();
+}
+function renderSafeTable(rows) {
+  return table(rows.map((row) => row.map(sanitizeTableCell)));
+}
+
+// src/hn/output.ts
+function renderHackerNewsStoriesAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result
+    },
+    null,
+    2
+  );
+}
+function renderHackerNewsStoriesAsTable(result) {
+  return renderSafeTable([
+    ["id", "title", "author", "score", "comments", "time", "url"],
+    ...result.items.map((item) => [
+      String(item.id),
+      item.title,
+      item.author ?? "",
+      item.score === void 0 ? "" : String(item.score),
+      item.commentCount === void 0 ? "" : String(item.commentCount),
+      item.time?.iso ?? "",
+      item.url
+    ])
+  ]);
+}
+function renderHackerNewsSearchAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result
+    },
+    null,
+    2
+  );
+}
+function renderHackerNewsSearchAsTable(result) {
+  return renderSafeTable([
+    ["id", "title", "author", "score", "comments", "time", "url"],
+    ...result.items.map((item) => [
+      String(item.id),
+      item.title,
+      item.author ?? "",
+      item.score === void 0 ? "" : String(item.score),
+      item.commentCount === void 0 ? "" : String(item.commentCount),
+      item.time?.iso ?? "",
+      item.url
+    ])
+  ]);
+}
+function renderHackerNewsCommandErrorAsJson(code, message, details) {
+  return JSON.stringify(
+    {
+      ok: false,
+      error: {
+        code,
+        message,
+        ...details === void 0 ? {} : { details }
+      }
+    },
+    null,
+    2
+  );
+}
+
+// src/hn/types.ts
+var HackerNewsCommandError = class extends Error {
+  constructor(code, message, exitCode, details) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+    this.name = "HackerNewsCommandError";
+  }
+};
+
+// src/hn/service.ts
+var SUPPORTED_SOURCES = /* @__PURE__ */ new Set(["top", "new", "best"]);
+var HackerNewsService = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async stories(options) {
+    const source = parseSource(options.source);
+    const limit = normalizeLimit(options.limit);
+    const runtimeResult = await this.dependencies.runtime.fetchStories({
+      limit,
+      source
+    });
+    return {
+      ...runtimeResult,
+      meta: {
+        limit,
+        totalItems: runtimeResult.items.length
+      }
+    };
+  }
+  async search(options) {
+    const query = normalizeQuery(options.query);
+    const limit = normalizeLimit(options.limit);
+    const sort = options.sort ?? "relevance";
+    const runtimeResult = await this.dependencies.runtime.fetchSearch({
+      limit,
+      query,
+      sort
+    });
+    return {
+      ...runtimeResult,
+      meta: {
+        limit,
+        sort,
+        totalItems: runtimeResult.items.length
+      }
+    };
+  }
+};
+function parseSource(source) {
+  if (SUPPORTED_SOURCES.has(source)) {
+    return source;
+  }
+  throw new HackerNewsCommandError(
+    "HN_INVALID_SOURCE",
+    "Hacker News list only supports top, new, and best.",
+    2,
+    {
+      source,
+      supportedSources: [...SUPPORTED_SOURCES]
+    }
+  );
+}
+function normalizeLimit(limit) {
+  const value = limit ?? 30;
+  if (!Number.isInteger(value) || value < 1 || value > 100) {
+    throw new HackerNewsCommandError(
+      "HN_INVALID_LIMIT",
+      "Hacker News limit must be an integer between 1 and 100.",
+      2,
+      {
+        limit: value
+      }
+    );
+  }
+  return value;
+}
+function normalizeQuery(query) {
+  const value = query.trim();
+  if (value.length === 0) {
+    throw new HackerNewsCommandError(
+      "HN_INVALID_QUERY",
+      "Hacker News search query must not be empty.",
+      2
+    );
+  }
+  return value;
+}
+
+// src/hn/command.ts
+var storiesOptionsSchema = z.object({
+  format: z.enum(["json", "table"]).default("json"),
+  limit: z.number().int().default(30),
+  table: z.boolean().optional()
+});
+var searchOptionsSchema = z.object({
+  format: z.enum(["json", "table"]).default("json"),
+  limit: z.number().int().default(30),
+  sort: z.enum(["relevance", "date"]).default("relevance"),
+  table: z.boolean().optional()
+});
+function registerHackerNewsCommands(program, dependencies) {
+  const hn = program.command("hn").alias("hackernews").description("Fetch Hacker News stories and search results.");
+  const service = new HackerNewsService({ runtime: dependencies.runtime });
+  for (const source of ["top", "new", "best"]) {
+    hn.command(source).option("--limit <limit>", "number of stories to fetch", parseLimit, 30).option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (options) => {
+      const parsed = storiesOptionsSchema.parse(applyTableShortcut(options));
+      const result = await service.stories({
+        limit: parsed.limit,
+        source
+      });
+      dependencies.stdout(
+        parsed.format === "table" ? `${renderHackerNewsStoriesAsTable(result)}
+` : `${renderHackerNewsStoriesAsJson(result)}
+`
+      );
+    });
+  }
+  hn.command("search").argument("<query>", "search query").option("--limit <limit>", "number of search results to fetch", parseLimit, 30).option("--sort <sort>", "search sort: relevance or date", "relevance").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (query, options) => {
+    const parsed = searchOptionsSchema.parse(applyTableShortcut(options));
+    const result = await service.search({
+      limit: parsed.limit,
+      query,
+      sort: parsed.sort
+    });
+    dependencies.stdout(
+      parsed.format === "table" ? `${renderHackerNewsSearchAsTable(result)}
+` : `${renderHackerNewsSearchAsJson(result)}
+`
+    );
+  });
+}
+function handleHackerNewsCommandError(error, dependencies) {
+  if (error instanceof HackerNewsCommandError) {
+    dependencies.stderr(
+      `${renderHackerNewsCommandErrorAsJson(error.code, error.message, error.details)}
+`
+    );
+    return error.exitCode;
+  }
+  return void 0;
+}
+function parseLimit(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new HackerNewsCommandError(
+      "HN_INVALID_LIMIT",
+      "Hacker News limit must be an integer between 1 and 100.",
+      2,
+      {
+        limit: value
+      }
+    );
+  }
+  return parsed;
+}
+function applyTableShortcut(options) {
+  if (options.table) {
+    return {
+      ...options,
+      format: "table"
+    };
+  }
+  return {
+    ...options,
+    format: options.format
+  };
+}
+
+// src/hn/runtime.ts
+var FIREBASE_BASE_URL = "https://hacker-news.firebaseio.com/v0";
+var ALGOLIA_BASE_URL = "https://hn.algolia.com/api/v1";
+var DEFAULT_DETAIL_CONCURRENCY = 8;
+var DEFAULT_DETAIL_RESPONSE_BYTES = 256 * 1024;
+var DEFAULT_MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var SOURCE_TO_ENDPOINT = {
+  best: "beststories",
+  new: "newstories",
+  top: "topstories"
+};
+function createDefaultHackerNewsRuntime(options = {}) {
+  const dependencies = {
+    detailConcurrency: normalizeDetailConcurrency(options.detailConcurrency),
+    fetch: options.fetch ?? fetch,
+    maxResponseBytes: options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES,
+    requestTimeoutMs: options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS
+  };
+  return {
+    fetchSearch: async (request) => fetchSearch(dependencies, request),
+    fetchStories: async (request) => fetchStories(dependencies, request)
+  };
+}
+function normalizeDetailConcurrency(value) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return DEFAULT_DETAIL_CONCURRENCY;
+  }
+  return Math.max(1, Math.min(DEFAULT_DETAIL_CONCURRENCY, Math.floor(value)));
+}
+async function fetchStories(dependencies, options) {
+  const endpoint = SOURCE_TO_ENDPOINT[options.source];
+  const ids = await fetchJson(
+    dependencies,
+    `${FIREBASE_BASE_URL}/${endpoint}.json`
+  );
+  const candidateIds = [...new Set(ids.slice(0, options.limit * 2))];
+  const rawItems = await mapOrderedBounded(
+    candidateIds,
+    dependencies.detailConcurrency,
+    async (id) => fetchJson(
+      dependencies,
+      `${FIREBASE_BASE_URL}/item/${id}.json`,
+      Math.min(dependencies.maxResponseBytes, DEFAULT_DETAIL_RESPONSE_BYTES)
+    )
+  );
+  return {
+    items: rawItems.flatMap(mapFirebaseItem).slice(0, options.limit),
+    source: options.source
+  };
+}
+async function fetchSearch(dependencies, options) {
+  const params = new URLSearchParams({
+    hitsPerPage: String(options.limit),
+    query: options.query,
+    tags: "story"
+  });
+  const endpoint = options.sort === "date" ? "search_by_date" : "search";
+  const response = await fetchJson(
+    dependencies,
+    `${ALGOLIA_BASE_URL}/${endpoint}?${params.toString()}`
+  );
+  return {
+    items: response.hits.flatMap(mapAlgoliaHit).slice(0, options.limit),
+    query: options.query
+  };
+}
+async function fetchJson(dependencies, url, maxResponseBytes = dependencies.maxResponseBytes) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), dependencies.requestTimeoutMs);
+  try {
+    let response;
+    try {
+      response = await dependencies.fetch(url, {
+        headers: {
+          accept: "application/json",
+          "user-agent": "ants-move/0.1 HackerNews collector"
+        },
+        signal: controller.signal
+      });
+    } catch (error) {
+      throw new HackerNewsCommandError(
+        "HN_FETCH_FAILED",
+        "Failed to fetch Hacker News data.",
+        2,
+        {
+          cause: error instanceof Error ? error.message : String(error),
+          url
+        }
+      );
+    }
+    if (!response.ok) {
+      await cancelResponseBody(response);
+      throw new HackerNewsCommandError(
+        "HN_FETCH_FAILED",
+        `Failed to fetch Hacker News data. HTTP ${response.status}.`,
+        2,
+        { url }
+      );
+    }
+    const body = await readBoundedBody(response, maxResponseBytes, url);
+    try {
+      return JSON.parse(new TextDecoder().decode(body));
+    } catch {
+      throw new HackerNewsCommandError(
+        "HN_PARSE_FAILED",
+        "Failed to parse Hacker News JSON.",
+        2,
+        { url }
+      );
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function readBoundedBody(response, maxBytes, url) {
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+    await cancelResponseBody(response);
+    throw responseTooLarge(url, maxBytes);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    return new Uint8Array();
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    totalBytes += value.byteLength;
+    if (totalBytes > maxBytes) {
+      await reader.cancel().catch(() => void 0);
+      throw responseTooLarge(url, maxBytes);
+    }
+    chunks.push(value);
+  }
+  const body = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+async function cancelResponseBody(response) {
+  await response.body?.cancel().catch(() => void 0);
+}
+function responseTooLarge(url, maxBytes) {
+  return new HackerNewsCommandError(
+    "HN_RESPONSE_TOO_LARGE",
+    "Hacker News response exceeded the configured size limit.",
+    2,
+    { maxBytes, url }
+  );
+}
+async function mapOrderedBounded(values, concurrency, map) {
+  if (values.length === 0) {
+    return [];
+  }
+  const results = new Array(values.length);
+  let nextIndex = 0;
+  let firstError;
+  const worker = async () => {
+    while (firstError === void 0) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= values.length) return;
+      try {
+        results[index] = await map(values[index], index);
+      } catch (error) {
+        firstError ??= error;
+      }
+    }
+  };
+  const workerCount = Math.max(1, Math.min(
+    Math.floor(concurrency),
+    values.length
+  ));
+  await Promise.all(Array.from({ length: workerCount }, worker));
+  if (firstError !== void 0) {
+    throw firstError;
+  }
+  return results;
+}
+function mapFirebaseItem(item) {
+  if (!item || item.deleted || item.dead || item.type !== "story" || !item.id || !item.title) {
+    return [];
+  }
+  return [
+    createItem({
+      id: item.id,
+      title: item.title,
+      url: item.url ?? `https://news.ycombinator.com/item?id=${item.id}`,
+      ...optional("author", item.by),
+      ...optional("commentCount", item.descendants),
+      ...optional("score", item.score),
+      ...optional("text", item.text),
+      ...optional("timeSeconds", item.time)
+    })
+  ];
+}
+function mapAlgoliaHit(hit) {
+  const id = hit.story_id ?? parseNumericId(hit.objectID);
+  if (!id || !hit.title) {
+    return [];
+  }
+  return [
+    createItem({
+      id,
+      title: hit.title,
+      url: hit.url ?? `https://news.ycombinator.com/item?id=${id}`,
+      ...optional("author", hit.author),
+      ...optional("commentCount", hit.num_comments),
+      ...optional("score", hit.points),
+      ...optional("timeSeconds", hit.created_at_i)
+    })
+  ];
+}
+function createItem(input) {
+  const item = {
+    id: input.id,
+    title: input.title,
+    type: "story",
+    url: input.url
+  };
+  if (input.author !== void 0) item.author = input.author;
+  if (input.commentCount !== void 0) item.commentCount = input.commentCount;
+  if (input.score !== void 0) item.score = input.score;
+  if (input.text !== void 0) item.text = input.text;
+  if (input.timeSeconds !== void 0) {
+    item.time = {
+      iso: new Date(input.timeSeconds * 1e3).toISOString(),
+      seconds: input.timeSeconds
+    };
+  }
+  return item;
+}
+function optional(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function parseNumericId(value) {
+  if (!value || !/^\d+$/.test(value)) {
+    return void 0;
+  }
+  return Number(value);
+}
+
+// src/36kr/command.ts
+import { z as z2 } from "zod";
+
+// src/36kr/output.ts
+function renderKr36ArticleAsJson(article) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: article
+    },
+    null,
+    2
+  );
+}
+function renderKr36InformationListAsJson(list) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: list
+    },
+    null,
+    2
+  );
+}
+function renderKr36InformationListAsTable(list) {
+  return renderSafeTable([
+    ["id", "title", "author", "publishTime", "url"],
+    ...list.items.map((item) => [
+      String(item.id),
+      item.title,
+      item.authorName ?? "",
+      item.publishTime?.local ?? "",
+      item.url
+    ])
+  ]);
+}
+function renderKr36CommandErrorAsJson(code, message, details) {
+  return JSON.stringify(
+    {
+      ok: false,
+      error: {
+        code,
+        message,
+        ...details === void 0 ? {} : { details }
+      }
+    },
+    null,
+    2
+  );
+}
+
+// src/36kr/types.ts
+var Kr36CommandError = class extends Error {
+  constructor(code, message, exitCode, details) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+    this.name = "Kr36CommandError";
+  }
+};
+
+// src/36kr/service.ts
+var KR36_BROWSER_HEADERS = {
+  Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+  "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+  "Cache-Control": "no-cache",
+  Pragma: "no-cache",
+  Referer: "https://36kr.com/",
+  "Sec-Fetch-Dest": "document",
+  "Sec-Fetch-Mode": "navigate",
+  "Sec-Fetch-Site": "same-origin",
+  "Sec-Fetch-User": "?1",
+  "Upgrade-Insecure-Requests": "1",
+  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+};
+var KR36_INFORMATION_ENDPOINT = "https://gateway.36kr.com/api/mis/nav/ifm/subNav/flow";
+var KR36_ARTICLE_MAX_RETAINED_BYTES = 20 * 1024 * 1024;
+var KR36_INFORMATION_MAX_RETAINED_BYTES = 5 * 1024 * 1024;
+var KR36_INFORMATION_PAGE_SIZE = 30;
+var KR36_SUPPORTED_CHANNELS = /* @__PURE__ */ new Set(["AI", "technology"]);
+var KR36_JSON_HEADERS = {
+  Accept: "application/json, text/plain, */*",
+  "Accept-Language": KR36_BROWSER_HEADERS["Accept-Language"],
+  "Content-Type": "application/json;charset=UTF-8",
+  Origin: "https://36kr.com",
+  "User-Agent": KR36_BROWSER_HEADERS["User-Agent"]
+};
+var Kr36ArticleService = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  async getArticle(articleId) {
+    assertArticleId(articleId);
+    const request = buildKr36ArticleRequest(articleId);
+    const html = await this.runtime.fetchArticleHtml(request);
+    const initialState = parseInitialState(html);
+    const articleDetail = initialState.articleDetail;
+    const rawArticle = articleDetail?.articleDetailData?.data;
+    if (!rawArticle) {
+      throw new Kr36CommandError(
+        "KR36_PARSE_ERROR",
+        "36kr article data was not found in window.initialState.",
+        2
+      );
+    }
+    const contentHtml = rawArticle.widgetContent ?? "";
+    const recommend = articleDetail?.articleRecommendData ?? {};
+    const publishTime = rawArticle.publishTime ?? 0;
+    const article = {
+      author: buildAuthor(rawArticle, recommend),
+      content: {
+        html: contentHtml,
+        paragraphs: extractParagraphs(contentHtml)
+      },
+      id: String(rawArticle.itemId ?? articleId),
+      imageSources: rawArticle.imgSources ?? [],
+      images: extractImages(contentHtml),
+      latestArticles: (articleDetail?.latestArticle?.articleLatestList ?? []).map((item) => ({
+        id: item.id,
+        title: item.title
+      })),
+      newestArticles: (recommend.newestItemList ?? []).map((item) => {
+        const listItem = {
+          id: item.itemId,
+          title: item.itemTitle
+        };
+        if (item.itemContent !== void 0) {
+          listItem.content = item.itemContent;
+        }
+        if (item.publishTime !== void 0) {
+          listItem.publishTime = item.publishTime;
+        }
+        if (item.itemRoute !== void 0) {
+          listItem.route = item.itemRoute;
+        }
+        return listItem;
+      }),
+      organizations: articleDetail?.organArticleData?.data?.organizationList ?? [],
+      publishTime: {
+        iso: publishTime ? new Date(publishTime).toISOString() : "",
+        local: publishTime ? formatChinaTime(publishTime) : "",
+        ms: publishTime
+      },
+      relatedArticles: (recommend.relateArticleList ?? []).map((item) => {
+        const listItem = {
+          id: item.itemId,
+          title: item.widgetTitle
+        };
+        const author = item.author ?? item.authorName;
+        if (author !== void 0) {
+          listItem.author = author;
+        }
+        if (item.widgetImage !== void 0) {
+          listItem.image = item.widgetImage;
+        }
+        if (item.route !== void 0) {
+          listItem.route = item.route;
+        }
+        return listItem;
+      }),
+      request,
+      stats: buildStats(articleDetail?.likeCount, articleDetail?.favoriteCount, recommend),
+      summary: rawArticle.summary ?? "",
+      title: rawArticle.widgetTitle ?? "",
+      url: request.url
+    };
+    if (rawArticle.companyCertifyNick !== void 0) {
+      article.companyCertifyNick = rawArticle.companyCertifyNick;
+    }
+    if (rawArticle.popinImage !== void 0) {
+      article.coverImage = rawArticle.popinImage;
+    }
+    if (recommend.nextItem) {
+      article.nextArticle = {
+        id: recommend.nextItem.itemId,
+        title: recommend.nextItem.itemTitle
+      };
+      if (recommend.nextItem.itemContent !== void 0) {
+        article.nextArticle.content = recommend.nextItem.itemContent;
+      }
+      if (recommend.nextItem.publishTime !== void 0) {
+        article.nextArticle.publishTime = recommend.nextItem.publishTime;
+      }
+      if (recommend.nextItem.itemRoute !== void 0) {
+        article.nextArticle.route = recommend.nextItem.itemRoute;
+      }
+    }
+    if (rawArticle.sourceType !== void 0) {
+      article.sourceType = rawArticle.sourceType;
+    }
+    const retainedBytes = Buffer.byteLength(JSON.stringify(article), "utf8");
+    if (retainedBytes > KR36_ARTICLE_MAX_RETAINED_BYTES) {
+      throw new Kr36CommandError(
+        "KR36_RESOURCE_LIMIT",
+        "36kr article result exceeded the configured size limit.",
+        2,
+        {
+          maxRetainedBytes: KR36_ARTICLE_MAX_RETAINED_BYTES,
+          retainedBytes
+        }
+      );
+    }
+    return article;
+  }
+  async getInformationList(options) {
+    const channel = parseInformationChannel(options.channel);
+    const pageLimit = normalizePages(options.pages);
+    const firstPageRequest = buildKr36InformationFirstPageRequest(channel);
+    const firstPageHtml = await this.runtime.fetchArticleHtml(firstPageRequest);
+    const firstPageState = parseInitialState(firstPageHtml);
+    const firstPageList = firstPageState.information?.informationList;
+    if (!firstPageList) {
+      throw new Kr36CommandError(
+        "KR36_PARSE_ERROR",
+        "36kr information list data was not found in window.initialState.",
+        2
+      );
+    }
+    const firstPageItems = mapInformationPageItems(firstPageList.itemList ?? []);
+    let retainedBytes = addInformationRetainedBytes(0, firstPageItems);
+    const items = [...firstPageItems];
+    let pageCallback = firstPageList.pageCallback ?? "";
+    let hasNextPage = firstPageList.hasNextPage ?? 0;
+    let fetchedPages = 1;
+    while (fetchedPages < pageLimit && hasNextPage && pageCallback) {
+      const request = buildKr36InformationNextPageRequest(channel, pageCallback);
+      const response = parseInformationFlowResponse(await this.runtime.fetchJson(request));
+      const nextList = response.data ?? {};
+      const nextItems = mapInformationPageItems(nextList.itemList ?? []);
+      retainedBytes = addInformationRetainedBytes(retainedBytes, nextItems);
+      items.push(...nextItems);
+      pageCallback = nextList.pageCallback ?? "";
+      hasNextPage = nextList.hasNextPage ?? 0;
+      fetchedPages += 1;
+    }
+    return {
+      channel,
+      items,
+      meta: {
+        fetchedPages,
+        hasNextPage,
+        nextPageCallback: pageCallback,
+        pageSize: KR36_INFORMATION_PAGE_SIZE,
+        totalItems: items.length
+      },
+      request: {
+        firstPage: firstPageRequest,
+        nextPageEndpoint: KR36_INFORMATION_ENDPOINT
+      }
+    };
+  }
+};
+function buildKr36ArticleUrl(articleId) {
+  assertArticleId(articleId);
+  return `https://36kr.com/p/${articleId}?f=rss`;
+}
+function buildKr36ArticleRequest(articleId) {
+  return {
+    headers: KR36_BROWSER_HEADERS,
+    url: buildKr36ArticleUrl(articleId)
+  };
+}
+function buildKr36InformationFirstPageRequest(channel) {
+  return {
+    headers: KR36_BROWSER_HEADERS,
+    url: `https://36kr.com/information/${channel}/`
+  };
+}
+function buildKr36InformationNextPageRequest(channel, pageCallback, timestamp = Date.now()) {
+  return {
+    body: {
+      partner_id: "web",
+      timestamp,
+      param: {
+        subnavType: 1,
+        subnavNick: channel,
+        pageSize: KR36_INFORMATION_PAGE_SIZE,
+        pageEvent: 1,
+        pageCallback,
+        siteId: 1,
+        platformId: 2
+      }
+    },
+    headers: {
+      ...KR36_JSON_HEADERS,
+      Referer: `https://36kr.com/information/${channel}/`
+    },
+    url: KR36_INFORMATION_ENDPOINT
+  };
+}
+function assertArticleId(articleId) {
+  if (!/^\d+$/.test(articleId)) {
+    throw new Kr36CommandError(
+      "KR36_INVALID_ARTICLE_ID",
+      "36kr article id must contain digits only.",
+      2,
+      {
+        articleId
+      }
+    );
+  }
+}
+function parseInformationChannel(channel) {
+  if (KR36_SUPPORTED_CHANNELS.has(channel)) {
+    return channel;
+  }
+  throw new Kr36CommandError(
+    "KR36_INVALID_CHANNEL",
+    "36kr list only supports AI and technology channels.",
+    2,
+    {
+      channel,
+      supportedChannels: [...KR36_SUPPORTED_CHANNELS]
+    }
+  );
+}
+function normalizePages(pages) {
+  const value = pages ?? 1;
+  if (!Number.isInteger(value) || value < 1 || value > 20) {
+    throw new Kr36CommandError(
+      "KR36_INVALID_PAGES",
+      "36kr list pages must be an integer between 1 and 20.",
+      2,
+      {
+        pages: value
+      }
+    );
+  }
+  return value;
+}
+function parseInitialState(html) {
+  const match = /window\.initialState=(\{[\s\S]*?\})\s*;?\s*<\/script>/.exec(html);
+  if (!match?.[1]) {
+    throw new Kr36CommandError(
+      "KR36_PARSE_ERROR",
+      "window.initialState was not found in the 36kr article page.",
+      2
+    );
+  }
+  try {
+    return JSON.parse(match[1]);
+  } catch (error) {
+    throw new Kr36CommandError(
+      "KR36_PARSE_ERROR",
+      "Failed to parse window.initialState from the 36kr article page.",
+      2,
+      {
+        cause: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
+}
+function extractImages(html) {
+  return [...html.matchAll(/<img\b[^>]*>/gi)].map((match, index) => {
+    const tag = match[0];
+    return {
+      index: index + 1,
+      size: getAttribute(tag, "data-img-size-val"),
+      url: getAttribute(tag, "src") ?? ""
+    };
+  }).filter((image) => image.url);
+}
+function parseInformationFlowResponse(jsonText) {
+  try {
+    const response = JSON.parse(jsonText);
+    if (response.code !== 0) {
+      throw new Kr36CommandError(
+        "KR36_REQUEST_FAILED",
+        response.msg || "36kr information flow request failed.",
+        1,
+        {
+          code: response.code
+        }
+      );
+    }
+    return response;
+  } catch (error) {
+    if (error instanceof Kr36CommandError) {
+      throw error;
+    }
+    throw new Kr36CommandError(
+      "KR36_PARSE_ERROR",
+      "Failed to parse 36kr information flow response.",
+      2,
+      {
+        cause: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
+}
+function mapInformationItems(items) {
+  return items.map((item) => {
+    const material = item.templateMaterial ?? {};
+    const mapped = {
+      id: item.itemId,
+      title: material.widgetTitle ?? "",
+      url: `https://36kr.com/p/${item.itemId}`
+    };
+    if (material.authorName !== void 0) {
+      mapped.authorName = material.authorName;
+    }
+    if (material.authorRoute !== void 0) {
+      mapped.authorRoute = material.authorRoute;
+    }
+    if (material.widgetImage !== void 0) {
+      mapped.image = material.widgetImage;
+    }
+    if (material.publishTime !== void 0) {
+      mapped.publishTime = {
+        iso: new Date(material.publishTime).toISOString(),
+        local: formatChinaTime(material.publishTime),
+        ms: material.publishTime
+      };
+    }
+    if (item.route !== void 0) {
+      mapped.route = item.route;
+    }
+    if (material.summary !== void 0) {
+      mapped.summary = material.summary;
+    }
+    return mapped;
+  });
+}
+function mapInformationPageItems(items) {
+  if (items.length > KR36_INFORMATION_PAGE_SIZE) {
+    throw new Kr36CommandError(
+      "KR36_RESOURCE_LIMIT",
+      "36kr information response exceeded the configured item limit.",
+      2,
+      {
+        maxItemsPerPage: KR36_INFORMATION_PAGE_SIZE,
+        receivedItems: items.length
+      }
+    );
+  }
+  return mapInformationItems(items);
+}
+function addInformationRetainedBytes(retainedBytes, items) {
+  const nextRetainedBytes = retainedBytes + Buffer.byteLength(JSON.stringify(items), "utf8");
+  if (nextRetainedBytes > KR36_INFORMATION_MAX_RETAINED_BYTES) {
+    throw new Kr36CommandError(
+      "KR36_RESOURCE_LIMIT",
+      "36kr information results exceeded the configured size limit.",
+      2,
+      {
+        maxRetainedBytes: KR36_INFORMATION_MAX_RETAINED_BYTES,
+        retainedBytes: nextRetainedBytes
+      }
+    );
+  }
+  return nextRetainedBytes;
+}
+function extractParagraphs(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, "\n").split(/\n+/).map((value) => decodeHtmlEntities(value).trim()).filter(Boolean);
+}
+function getAttribute(tag, name) {
+  const match = new RegExp(`${name}=["']([^"']+)["']`, "i").exec(tag);
+  return match?.[1] ?? null;
+}
+function decodeHtmlEntities(value) {
+  return value.replace(/&nbsp;/g, " ").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+function buildStats(likeCount, favoriteCount, recommend) {
+  return {
+    authorArticleCount: recommend.statArticle ?? 0,
+    collect: recommend.statCollect ?? 0,
+    comment: recommend.statComment ?? 0,
+    favoriteCount: favoriteCount ?? 0,
+    likeCount: likeCount ?? 0,
+    praise: recommend.statPraise ?? 0
+  };
+}
+function buildAuthor(rawArticle, recommend) {
+  const author = {
+    name: rawArticle.author ?? recommend.authorName ?? ""
+  };
+  const face = rawArticle.authorFace ?? recommend.authorFace;
+  if (face !== void 0) {
+    author.face = face;
+  }
+  if (rawArticle.authorId !== void 0) {
+    author.id = rawArticle.authorId;
+  }
+  if (rawArticle.authorRoute !== void 0) {
+    author.route = rawArticle.authorRoute;
+  }
+  if (recommend.authorSummary !== void 0) {
+    author.summary = recommend.authorSummary;
+  }
+  if (recommend.authorTitle !== void 0) {
+    author.title = recommend.authorTitle;
+  }
+  return author;
+}
+function formatChinaTime(timestampMs) {
+  const formatter = new Intl.DateTimeFormat("sv-SE", {
+    day: "2-digit",
+    hour: "2-digit",
+    hour12: false,
+    minute: "2-digit",
+    month: "2-digit",
+    second: "2-digit",
+    timeZone: "Asia/Shanghai",
+    year: "numeric"
+  });
+  return formatter.format(new Date(timestampMs));
+}
+
+// src/36kr/command.ts
+var articleOptionsSchema = z2.object({
+  format: z2.enum(["json"]).default("json")
+});
+var informationListOptionsSchema = z2.object({
+  format: z2.enum(["json", "table"]).default("json"),
+  pages: z2.number().int().min(1).max(20).default(1),
+  table: z2.boolean().optional()
+});
+function registerKr36Commands(program, dependencies) {
+  const kr36 = program.command("36kr").description("Fetch and parse 36kr content.");
+  const articleService = new Kr36ArticleService(dependencies.runtime);
+  kr36.command("article").argument("<articleId>", "36kr article id").option("--format <format>", "output format", "json").action(async (articleId, options) => {
+    articleOptionsSchema.parse(options);
+    const article = await articleService.getArticle(articleId);
+    dependencies.stdout(`${renderKr36ArticleAsJson(article)}
+`);
+  });
+  kr36.command("list").argument("<channel>", "36kr information channel: AI or technology").option("--pages <pages>", "number of pages to fetch", parsePages, 1).option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (channel, options) => {
+    const parsed = informationListOptionsSchema.parse(applyTableShortcut2(options));
+    const list = await articleService.getInformationList({
+      channel,
+      pages: parsed.pages
+    });
+    dependencies.stdout(
+      parsed.format === "table" ? `${renderKr36InformationListAsTable(list)}
+` : `${renderKr36InformationListAsJson(list)}
+`
+    );
+  });
+}
+function handleKr36CommandError(error, dependencies) {
+  if (error instanceof Kr36CommandError) {
+    dependencies.stderr(
+      `${renderKr36CommandErrorAsJson(error.code, error.message, error.details)}
+`
+    );
+    return error.exitCode;
+  }
+  return void 0;
+}
+function parsePages(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new Kr36CommandError(
+      "KR36_INVALID_PAGES",
+      "36kr list pages must be an integer between 1 and 20.",
+      2,
+      {
+        pages: value
+      }
+    );
+  }
+  return parsed;
+}
+function applyTableShortcut2(options) {
+  if (options.table) {
+    return {
+      ...options,
+      format: "table"
+    };
+  }
+  return {
+    ...options,
+    format: options.format
+  };
+}
+
+// src/36kr/runtime.ts
+import { execFile as nodeExecFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(nodeExecFile);
+function createDefaultKr36Runtime(options = {}) {
+  const execFile = options.execFile ?? execFileAsync;
+  return {
+    fetchArticleHtml: async (request) => fetchWithCurl(execFile, request),
+    fetchJson: async (request) => fetchWithCurl(execFile, request)
+  };
+}
+async function fetchWithCurl(execFile, request) {
+  const args = [
+    "--silent",
+    "--show-error",
+    "--location",
+    "--compressed",
+    "--connect-timeout",
+    "10",
+    "--max-time",
+    "45",
+    ...Object.entries(request.headers).flatMap(([name, value]) => [
+      "--header",
+      `${name}: ${value}`
+    ]),
+    ..."body" in request ? ["--data-raw", JSON.stringify(request.body)] : [],
+    request.url
+  ];
+  try {
+    const result = await execFile("curl", args, {
+      encoding: "utf8",
+      maxBuffer: 20 * 1024 * 1024
+    });
+    return result.stdout;
+  } catch (error) {
+    const execError = error;
+    const failureReason = execError.stderr?.trim() || "curl request failed.";
+    throw new Kr36CommandError(
+      "KR36_REQUEST_FAILED",
+      `Failed to fetch 36kr page: ${failureReason}`,
+      1,
+      {
+        curlExitCode: execError.code,
+        url: request.url
+      }
+    );
+  }
+}
+
+// src/toutiao/command.ts
+import { z as z3 } from "zod";
+
+// src/toutiao/output.ts
+function renderToutiaoListAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result
+    },
+    null,
+    2
+  );
+}
+function renderToutiaoListAsTable(result) {
+  return renderSafeTable([
+    ["id", "title", "author", "publishTime", "comments", "url"],
+    ...result.items.map((item) => [
+      item.id,
+      item.title,
+      item.authorName ?? "",
+      item.publishTime?.local ?? "",
+      item.commentCount === void 0 ? "" : String(item.commentCount),
+      item.url
+    ])
+  ]);
+}
+function renderToutiaoArticleAsJson(article) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: article
+    },
+    null,
+    2
+  );
+}
+function renderToutiaoAuthorAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result
+    },
+    null,
+    2
+  );
+}
+function renderToutiaoAuthorAsTable(result) {
+  return renderSafeTable([
+    ["id", "title", "author", "publishTime", "comments", "url"],
+    ...result.items.map((item) => [
+      item.id,
+      item.title,
+      item.authorName ?? "",
+      item.publishTime?.local ?? "",
+      item.commentCount === void 0 ? "" : String(item.commentCount),
+      item.url
+    ])
+  ]);
+}
+function renderToutiaoCommandErrorAsJson(code, message, details) {
+  return JSON.stringify(
+    {
+      ok: false,
+      error: {
+        code,
+        message,
+        ...details === void 0 ? {} : { details }
+      }
+    },
+    null,
+    2
+  );
+}
+
+// src/toutiao/types.ts
+var ToutiaoCommandError = class extends Error {
+  constructor(code, message, exitCode, details) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+    this.name = "ToutiaoCommandError";
+  }
+};
+
+// src/toutiao/service.ts
+var SUPPORTED_SOURCES2 = /* @__PURE__ */ new Set([
+  "tech",
+  "AI",
+  "\u5149\u523B\u673A",
+  "\u82AF\u7247",
+  "\u534A\u5BFC\u4F53"
+]);
+var MAX_AUTHOR_CONTENT_ARTICLES = 100;
+var MAX_AUTHOR_CONTENT_RETAINED_BYTES = 10 * 1024 * 1024;
+var ToutiaoService = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async article(input) {
+    const url = buildToutiaoArticleUrl(input);
+    return this.dependencies.runtime.withSession(
+      async (session) => session.fetchArticle({ input, url })
+    );
+  }
+  async author(input, options = {}) {
+    const authorToken = buildToutiaoAuthorToken(input);
+    const pages = normalizePages2(options.pages);
+    const url = buildToutiaoAuthorUrl(authorToken);
+    const withContent = options.withContent ?? false;
+    return this.dependencies.runtime.withSession(async (session) => {
+      const runtimeResult = await session.fetchAuthorArticles({
+        authorToken,
+        pages,
+        url
+      });
+      const result = {
+        ...runtimeResult,
+        meta: {
+          fetchedPages: pages,
+          totalItems: runtimeResult.items.length,
+          withContent
+        },
+        request: {
+          input,
+          url
+        }
+      };
+      if (!withContent) {
+        return result;
+      }
+      if (runtimeResult.items.length > MAX_AUTHOR_CONTENT_ARTICLES) {
+        throw new ToutiaoCommandError(
+          "TOUTIAO_RESOURCE_LIMIT",
+          "Toutiao author content collection supports at most 100 articles per invocation.",
+          2,
+          {
+            totalItems: runtimeResult.items.length
+          }
+        );
+      }
+      const articles = [];
+      let retainedBytes = 0;
+      for (const item of runtimeResult.items) {
+        const article = await session.fetchArticle({
+          input: item.id,
+          url: buildToutiaoArticleUrl(item.url || item.id)
+        });
+        const nextRetainedBytes = retainedBytes + Buffer.byteLength(JSON.stringify(article), "utf8");
+        if (nextRetainedBytes > MAX_AUTHOR_CONTENT_RETAINED_BYTES) {
+          throw new ToutiaoCommandError(
+            "TOUTIAO_RESOURCE_LIMIT",
+            "Toutiao author content exceeded the configured size limit.",
+            2,
+            {
+              maxRetainedBytes: MAX_AUTHOR_CONTENT_RETAINED_BYTES,
+              retainedBytes: nextRetainedBytes
+            }
+          );
+        }
+        retainedBytes = nextRetainedBytes;
+        articles.push(article);
+      }
+      result.articles = articles;
+      result.meta.totalArticles = articles.length;
+      return result;
+    });
+  }
+  async list(options) {
+    const source = parseSource2(options.source);
+    const pages = normalizePages2(options.pages);
+    return this.dependencies.runtime.withSession(async (session) => {
+      const runtimeResult = source === "tech" ? await session.fetchTechnologyChannel({ pages }) : await session.fetchKeywordInformation({
+        keyword: source,
+        pages,
+        source
+      });
+      return {
+        ...runtimeResult,
+        meta: {
+          fetchedPages: pages,
+          totalItems: runtimeResult.items.length
+        }
+      };
+    });
+  }
+};
+function buildToutiaoAuthorToken(input) {
+  const trimmed = input.trim();
+  if (/^[A-Za-z0-9._-]+$/.test(trimmed) && trimmed.length >= 12) {
+    return trimmed;
+  }
+  try {
+    const url = new URL(trimmed);
+    const token = /\/c\/user\/token\/([^/?#]+)/.exec(url.pathname)?.[1];
+    if (token && isToutiaoHost(url.hostname)) {
+      return decodeURIComponent(token);
+    }
+  } catch {
+  }
+  throw new ToutiaoCommandError(
+    "TOUTIAO_INVALID_AUTHOR",
+    "Toutiao author must be a user token or a /c/user/token/<token>/ homepage URL.",
+    2,
+    {
+      input
+    }
+  );
+}
+function buildToutiaoAuthorUrl(authorToken) {
+  return `https://www.toutiao.com/c/user/token/${encodeURIComponent(authorToken)}/`;
+}
+function buildToutiaoArticleUrl(input) {
+  const trimmed = input.trim();
+  if (/^\d+$/.test(trimmed)) {
+    return `https://www.toutiao.com/article/${trimmed}/`;
+  }
+  try {
+    const url = new URL(trimmed);
+    const id = /(?:article|group)\/(\d+)/.exec(url.pathname)?.[1] ?? /^\/a(\d+)/.exec(url.pathname)?.[1];
+    if (id && isToutiaoHost(url.hostname)) {
+      return `https://www.toutiao.com/article/${id}/`;
+    }
+    const nextUrl = url.searchParams.get("url");
+    if (nextUrl) {
+      return buildToutiaoArticleUrl(nextUrl);
+    }
+  } catch {
+  }
+  throw new ToutiaoCommandError(
+    "TOUTIAO_INVALID_ARTICLE",
+    "Toutiao article must be a numeric id or a toutiao article/group URL.",
+    2,
+    {
+      input
+    }
+  );
+}
+function isToutiaoHost(hostname) {
+  return hostname === "www.toutiao.com" || hostname === "toutiao.com";
+}
+function parseSource2(source) {
+  if (SUPPORTED_SOURCES2.has(source)) {
+    return source;
+  }
+  throw new ToutiaoCommandError(
+    "TOUTIAO_INVALID_SOURCE",
+    "Toutiao list only supports tech, AI, \u5149\u523B\u673A, \u82AF\u7247, and \u534A\u5BFC\u4F53.",
+    2,
+    {
+      source,
+      supportedSources: [...SUPPORTED_SOURCES2]
+    }
+  );
+}
+function normalizePages2(pages) {
+  const value = pages ?? 1;
+  if (!Number.isInteger(value) || value < 1 || value > 5) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_INVALID_PAGES",
+      "Toutiao list pages must be an integer between 1 and 5.",
+      2,
+      {
+        pages: value
+      }
+    );
+  }
+  return value;
+}
+
+// src/toutiao/command.ts
+var listOptionsSchema = z3.object({
+  format: z3.enum(["json", "table"]).default("json"),
+  pages: z3.number().int().min(1).max(5).default(1),
+  table: z3.boolean().optional()
+});
+var articleOptionsSchema2 = z3.object({
+  format: z3.enum(["json"]).default("json")
+});
+var authorOptionsSchema = z3.object({
+  format: z3.enum(["json", "table"]).default("json"),
+  pages: z3.number().int().min(1).max(5).default(1),
+  table: z3.boolean().optional(),
+  withContent: z3.boolean().default(false)
+});
+function registerToutiaoCommands(program, dependencies) {
+  const toutiao = program.command("toutiao").description("Fetch Toutiao channel and search content.");
+  const service = new ToutiaoService({ runtime: dependencies.runtime });
+  toutiao.command("article").argument("<article>", "Toutiao article id or URL").option("--format <format>", "output format", "json").action(async (article, options) => {
+    articleOptionsSchema2.parse(options);
+    const result = await service.article(article);
+    dependencies.stdout(`${renderToutiaoArticleAsJson(result)}
+`);
+  });
+  toutiao.command("list").argument("<source>", "Toutiao source: tech, AI, \u5149\u523B\u673A, \u82AF\u7247, or \u534A\u5BFC\u4F53").option("--pages <pages>", "number of pages to fetch", parsePages2, 1).option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (source, options) => {
+    const parsed = listOptionsSchema.parse(applyTableShortcut3(options));
+    const result = await service.list({
+      pages: parsed.pages,
+      source
+    });
+    dependencies.stdout(
+      parsed.format === "table" ? `${renderToutiaoListAsTable(result)}
+` : `${renderToutiaoListAsJson(result)}
+`
+    );
+  });
+  toutiao.command("author").argument("<author>", "Toutiao author token or /c/user/token/<token>/ homepage URL").option("--pages <pages>", "number of pages to fetch", parsePages2, 1).option("--with-content", "also fetch detail content for each author article").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (author, options) => {
+    const parsed = authorOptionsSchema.parse(applyTableShortcut3(options));
+    const result = await service.author(author, {
+      pages: parsed.pages,
+      withContent: parsed.withContent
+    });
+    dependencies.stdout(
+      parsed.format === "table" ? `${renderToutiaoAuthorAsTable(result)}
+` : `${renderToutiaoAuthorAsJson(result)}
+`
+    );
+  });
+}
+function handleToutiaoCommandError(error, dependencies) {
+  if (error instanceof ToutiaoCommandError) {
+    dependencies.stderr(
+      `${renderToutiaoCommandErrorAsJson(error.code, error.message, error.details)}
+`
+    );
+    return error.exitCode;
+  }
+  return void 0;
+}
+function parsePages2(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_INVALID_PAGES",
+      "Toutiao list pages must be an integer between 1 and 5.",
+      2,
+      {
+        pages: value
+      }
+    );
+  }
+  return parsed;
+}
+function applyTableShortcut3(options) {
+  if (options.table) {
+    return {
+      ...options,
+      format: "table"
+    };
+  }
+  return {
+    ...options,
+    format: options.format
+  };
+}
+
+// src/toutiao/runtime.ts
+var TOUTIAO_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36";
+var TECH_CHANNEL_ID = 3189398999;
+var DEFAULT_DEADLINE_MS = 10 * 60 * 1e3;
+var MAX_ARTICLE_TEXT_BYTES = 1024 * 1024;
+var MAX_FEED_ITEMS_PER_RESPONSE = 100;
+var MAX_FEED_RESPONSE_BYTES = 5 * 1024 * 1024;
+var MAX_SEARCH_TEXT_BYTES = 1024 * 1024;
+var BLOCKED_RESOURCE_TYPES = /* @__PURE__ */ new Set(["font", "image", "media"]);
+function createDefaultToutiaoRuntime(options = {}) {
+  const deadlineMs = options.deadlineMs ?? DEFAULT_DEADLINE_MS;
+  const playwrightLoader = options.loadPlaywright ?? loadPlaywright;
+  return {
+    withSession: async (operation) => {
+      let browser;
+      let browserClosed = false;
+      let context;
+      let deadlineTriggered = false;
+      let operationPromise;
+      let lifecyclePromise;
+      const createTimeoutError = () => new ToutiaoCommandError(
+        "TOUTIAO_TIMEOUT",
+        "Toutiao collection exceeded the command deadline.",
+        1,
+        { deadlineMs }
+      );
+      const ensureWithinDeadline = () => {
+        if (deadlineTriggered) {
+          throw createTimeoutError();
+        }
+      };
+      lifecyclePromise = (async () => {
+        try {
+          let playwright;
+          try {
+            playwright = await playwrightLoader();
+          } catch {
+            ensureWithinDeadline();
+            throw new ToutiaoCommandError(
+              "TOUTIAO_BROWSER_UNAVAILABLE",
+              "Toutiao collection requires Playwright to be installed.",
+              2
+            );
+          }
+          ensureWithinDeadline();
+          try {
+            browser = await playwright.chromium.launch({ headless: true });
+          } catch {
+            ensureWithinDeadline();
+            throw new ToutiaoCommandError(
+              "TOUTIAO_BROWSER_UNAVAILABLE",
+              "Toutiao collection requires Playwright Chromium to be installed.",
+              2
+            );
+          }
+          if (deadlineTriggered) {
+            browserClosed = true;
+            await browser.close().catch(() => void 0);
+            throw createTimeoutError();
+          }
+          context = await browser.newContext({
+            locale: "zh-CN",
+            userAgent: TOUTIAO_USER_AGENT
+          });
+          ensureWithinDeadline();
+          const page = await context.newPage();
+          ensureWithinDeadline();
+          await page.route("**/*", async (route) => {
+            if (BLOCKED_RESOURCE_TYPES.has(route.request().resourceType())) {
+              await route.abort();
+              return;
+            }
+            await route.continue();
+          });
+          ensureWithinDeadline();
+          operationPromise = Promise.resolve().then(
+            () => operation(createToutiaoSession(page))
+          );
+          return await operationPromise;
+        } finally {
+          await context?.close().catch(() => void 0);
+          if (!browserClosed) {
+            await browser?.close().catch(() => void 0);
+          }
+        }
+      })();
+      return await new Promise((resolve, reject) => {
+        const deadlineTimer = setTimeout(() => {
+          deadlineTriggered = true;
+          void (async () => {
+            if (browser !== void 0) {
+              browserClosed = true;
+              await browser.close().catch(() => void 0);
+            }
+            if (operationPromise !== void 0) {
+              await operationPromise.then(
+                () => void 0,
+                () => void 0
+              );
+              await lifecyclePromise.then(
+                () => void 0,
+                () => void 0
+              );
+            }
+            reject(createTimeoutError());
+          })();
+        }, deadlineMs);
+        void lifecyclePromise.then(
+          (value) => {
+            if (!deadlineTriggered) {
+              clearTimeout(deadlineTimer);
+              resolve(value);
+            }
+          },
+          (error) => {
+            if (!deadlineTriggered) {
+              clearTimeout(deadlineTimer);
+              reject(error);
+            }
+          }
+        );
+      });
+    }
+  };
+}
+function createToutiaoSession(page) {
+  return {
+    fetchArticle: async (request) => fetchArticle(page, request),
+    fetchAuthorArticles: async (options) => fetchAuthorArticles(page, options),
+    fetchKeywordInformation: async (options) => fetchKeywordInformation(page, options),
+    fetchTechnologyChannel: async (options) => fetchTechnologyChannel(page, options)
+  };
+}
+async function fetchArticle(page, request) {
+  await page.goto(request.url, {
+    timeout: 45e3,
+    waitUntil: "domcontentloaded"
+  });
+  await page.waitForTimeout(5e3);
+  const title = await page.locator("h1").first().innerText({ timeout: 5e3 }).catch(() => "");
+  const paragraphs = await page.locator("article p").evaluateAll(
+    (nodes) => nodes.map((node) => (node.textContent ?? "").trim()).filter(Boolean)
+  );
+  const bodyText = await page.locator("body").innerText({ timeout: 5e3 });
+  const extractedTextBytes = Math.max(
+    Buffer.byteLength(title, "utf8"),
+    Buffer.byteLength(bodyText, "utf8"),
+    paragraphs.reduce(
+      (total, paragraph) => total + Buffer.byteLength(paragraph, "utf8"),
+      0
+    )
+  );
+  if (extractedTextBytes > MAX_ARTICLE_TEXT_BYTES) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_RESOURCE_LIMIT",
+      "Toutiao article text exceeded the configured size limit.",
+      2,
+      {
+        maxTextBytes: MAX_ARTICLE_TEXT_BYTES,
+        textBytes: extractedTextBytes
+      }
+    );
+  }
+  const metadata = extractArticleMetadata(bodyText, title);
+  const id = extractArticleId(request.url) ?? extractArticleId(request.input) ?? "";
+  if (!id || !title || paragraphs.length === 0) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_PARSE_ERROR",
+      "Toutiao article page did not expose title and content.",
+      2,
+      {
+        input: request.input,
+        url: request.url
+      }
+    );
+  }
+  const article = {
+    content: {
+      paragraphs,
+      text: paragraphs.join("\n")
+    },
+    id,
+    request,
+    title,
+    url: page.url()
+  };
+  if (metadata.authorName !== void 0) {
+    article.authorName = metadata.authorName;
+  }
+  if (metadata.publishTimeText !== void 0) {
+    article.publishTimeText = metadata.publishTimeText;
+  }
+  return article;
+}
+async function fetchTechnologyChannel(page, options) {
+  const feedResponses = await collectFeedResponses(
+    page,
+    options.pages,
+    (response) => response.url().includes("/api/pc/list/feed"),
+    async () => {
+      await page.goto(
+        `https://www.toutiao.com/?channel=tech&source=ch&channel_id=${TECH_CHANNEL_ID}`,
+        {
+          timeout: 45e3,
+          waitUntil: "domcontentloaded"
+        }
+      );
+    }
+  );
+  const selectedResponses = feedResponses.slice(0, options.pages);
+  const items = deduplicateItems(
+    selectedResponses.flatMap((response) => mapFeedItems(response.data ?? []))
+  );
+  const lastResponse = selectedResponses.at(-1);
+  if (items.length === 0) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_PARSE_ERROR",
+      "Toutiao technology channel did not return feed items.",
+      2
+    );
+  }
+  const result = {
+    hasMore: lastResponse?.has_more ?? false,
+    items,
+    source: "tech"
+  };
+  addNextPage(result, lastResponse);
+  return result;
+}
+async function fetchAuthorArticles(page, options) {
+  const feedResponses = await collectFeedResponses(
+    page,
+    options.pages,
+    (response) => isAuthorFeedResponseUrl(response.url(), options.authorToken),
+    async () => {
+      await page.goto(options.url, {
+        timeout: 45e3,
+        waitUntil: "domcontentloaded"
+      });
+    }
+  );
+  const selectedResponses = feedResponses.slice(0, options.pages);
+  const items = deduplicateItems(
+    selectedResponses.flatMap((response) => mapFeedItems(response.data ?? []))
+  );
+  const lastResponse = selectedResponses.at(-1);
+  if (items.length === 0) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_PARSE_ERROR",
+      "Toutiao author homepage did not return article feed items.",
+      2,
+      {
+        authorToken: options.authorToken,
+        url: options.url
+      }
+    );
+  }
+  const result = {
+    authorToken: options.authorToken,
+    hasMore: lastResponse?.has_more ?? false,
+    items
+  };
+  addNextPage(result, lastResponse);
+  return result;
+}
+async function collectFeedResponses(page, pages, accepts, navigate) {
+  const feedResponses = [];
+  const maxResponseParses = pages * 2;
+  const pendingResponses = /* @__PURE__ */ new Set();
+  const queuedResponses = [];
+  let firstResourceError;
+  let startedResponseParses = 0;
+  const startQueuedResponses = () => {
+    while (firstResourceError === void 0 && queuedResponses.length > 0 && feedResponses.length + pendingResponses.size < pages && startedResponseParses < maxResponseParses) {
+      startResponseParse(queuedResponses.shift());
+    }
+  };
+  const startResponseParse = (response) => {
+    startedResponseParses += 1;
+    const pending = parseFeedResponse(response).then((feedResponse) => {
+      feedResponses.push(feedResponse);
+    }).catch((error) => {
+      if (error instanceof ToutiaoCommandError) {
+        firstResourceError ??= error;
+      }
+    }).finally(() => {
+      pendingResponses.delete(pending);
+      startQueuedResponses();
+    });
+    pendingResponses.add(pending);
+  };
+  const handler = (response) => {
+    if (!accepts(response) || firstResourceError !== void 0 || feedResponses.length >= pages || startedResponseParses + queuedResponses.length >= maxResponseParses) {
+      return;
+    }
+    if (feedResponses.length + pendingResponses.size < pages) {
+      startResponseParse(response);
+      return;
+    }
+    queuedResponses.push(response);
+  };
+  page.on("response", handler);
+  try {
+    await navigate();
+    await waitForFeedResponses(
+      page,
+      feedResponses,
+      pages,
+      () => firstResourceError !== void 0
+    );
+    while (pendingResponses.size > 0) {
+      await Promise.allSettled([...pendingResponses]);
+    }
+    if (firstResourceError !== void 0) {
+      throw firstResourceError;
+    }
+    return feedResponses;
+  } finally {
+    page.off("response", handler);
+    queuedResponses.length = 0;
+    while (pendingResponses.size > 0) {
+      await Promise.allSettled([...pendingResponses]);
+    }
+  }
+}
+async function parseFeedResponse(response) {
+  const declaredLength = Number(await response.headerValue("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_FEED_RESPONSE_BYTES) {
+    throw feedResponseTooLarge();
+  }
+  const body = await response.body();
+  if (body.byteLength > MAX_FEED_RESPONSE_BYTES) {
+    throw feedResponseTooLarge();
+  }
+  const feedResponse = JSON.parse(body.toString("utf8"));
+  if (Array.isArray(feedResponse.data) && feedResponse.data.length > MAX_FEED_ITEMS_PER_RESPONSE) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_RESOURCE_LIMIT",
+      "Toutiao feed response exceeded the configured item limit.",
+      2,
+      { maxItems: MAX_FEED_ITEMS_PER_RESPONSE }
+    );
+  }
+  return feedResponse;
+}
+function feedResponseTooLarge() {
+  return new ToutiaoCommandError(
+    "TOUTIAO_RESPONSE_TOO_LARGE",
+    "Toutiao feed response exceeded the configured size limit.",
+    2,
+    { maxBytes: MAX_FEED_RESPONSE_BYTES }
+  );
+}
+async function fetchKeywordInformation(page, options) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  let blocked = false;
+  for (let pageIndex = 0; pageIndex < options.pages; pageIndex += 1) {
+    const url = buildSearchUrl(options.keyword, pageIndex);
+    await page.goto(url, {
+      timeout: 45e3,
+      waitUntil: "domcontentloaded"
+    });
+    await page.waitForTimeout(5e3);
+    blocked = blocked || await page.locator("#pc_captcha").count() > 0;
+    for (const item of await extractSearchItemsFromPage(page, options.keyword)) {
+      if (seen.has(item.id)) {
+        continue;
+      }
+      seen.add(item.id);
+      items.push(item);
+    }
+  }
+  if (blocked && items.length === 0) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_VERIFICATION_REQUIRED",
+      "Toutiao search requires browser verification before returning usable results.",
+      1,
+      {
+        keyword: options.keyword
+      }
+    );
+  }
+  if (items.length === 0) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_PARSE_ERROR",
+      "Toutiao search page did not expose result items.",
+      2,
+      {
+        keyword: options.keyword
+      }
+    );
+  }
+  return {
+    hasMore: true,
+    items,
+    keyword: options.keyword,
+    source: options.source
+  };
+}
+function buildSearchUrl(keyword, pageIndex) {
+  const params = new URLSearchParams({
+    action_type: pageIndex === 0 ? "search" : "pagination",
+    cur_tab_title: "news",
+    dvpf: "pc",
+    from: "news",
+    keyword,
+    page_num: String(pageIndex),
+    pd: "information",
+    source: pageIndex === 0 ? "input" : "pagination"
+  });
+  return `https://so.toutiao.com/search?${params.toString()}`;
+}
+async function waitForFeedResponses(page, responses, pages, shouldStop) {
+  for (let attempt = 0; attempt < 45 && responses.length < pages && !shouldStop(); attempt += 1) {
+    await page.waitForTimeout(1e3);
+    if (responses.length < pages && !shouldStop()) {
+      await page.mouse.wheel(0, 4e3);
+    }
+  }
+}
+function mapFeedItems(items) {
+  return items.flatMap((item) => {
+    const id = String(item.group_id ?? item.item_id ?? item.id ?? "");
+    const title = item.title ?? item.Title ?? "";
+    if (!id || !title) {
+      return [];
+    }
+    const mapped = {
+      id,
+      title,
+      url: normalizeArticleUrl(item.article_url ?? item.display_url ?? item.source_url, id)
+    };
+    const abstract = item.Abstract ?? item.abstract;
+    if (abstract !== void 0) {
+      mapped.abstract = abstract;
+    }
+    if (item.comment_count !== void 0) {
+      mapped.commentCount = item.comment_count;
+    }
+    if (item.image_url !== void 0) {
+      mapped.image = item.image_url;
+    }
+    const authorName = item.media_name ?? item.source;
+    if (authorName !== void 0) {
+      mapped.authorName = authorName;
+    }
+    if (item.source_url !== void 0) {
+      mapped.sourceUrl = item.source_url;
+    }
+    if (item.behot_time !== void 0) {
+      mapped.publishTime = {
+        iso: new Date(item.behot_time * 1e3).toISOString(),
+        local: formatChinaTime2(item.behot_time),
+        seconds: item.behot_time
+      };
+    }
+    return [mapped];
+  });
+}
+function deduplicateItems(items) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    if (seen.has(item.id)) {
+      return false;
+    }
+    seen.add(item.id);
+    return true;
+  });
+}
+function addNextPage(result, response) {
+  const next = {};
+  if (response?.next?.max_behot_time !== void 0) {
+    next.maxBehotTime = response.next.max_behot_time;
+  }
+  if (response?.offset !== void 0) {
+    next.offset = response.offset;
+  }
+  if (Object.keys(next).length > 0) {
+    result.next = next;
+  }
+}
+function normalizeArticleUrl(value, id) {
+  if (!value) {
+    return `https://www.toutiao.com/article/${id}/`;
+  }
+  try {
+    const url = new URL(value, "https://www.toutiao.com");
+    return parseToutiaoArticleLink(url.toString())?.url ?? `https://www.toutiao.com/article/${id}/`;
+  } catch {
+    return `https://www.toutiao.com/article/${id}/`;
+  }
+}
+async function extractSearchItemsFromPage(page, keyword) {
+  const anchors = await page.locator("a").evaluateAll(
+    (nodes) => nodes.slice(0, 300).map((node) => ({
+      href: node.href.slice(0, 2048),
+      text: (node.textContent ?? "").trim().replace(/\s+/g, " ").slice(0, 1e3)
+    }))
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const anchor of anchors) {
+    const articleLink = parseToutiaoArticleLink(anchor.href);
+    if (!articleLink || !anchor.text || anchor.text.length < 6 || seen.has(articleLink.id)) {
+      continue;
+    }
+    seen.add(articleLink.id);
+    items.push({
+      id: articleLink.id,
+      title: anchor.text.slice(0, 180),
+      url: articleLink.url
+    });
+    if (items.length >= 30) {
+      break;
+    }
+  }
+  if (items.length > 0) {
+    return items;
+  }
+  const bodyText = await page.locator("body").innerText({ timeout: 5e3 });
+  const textBytes = Buffer.byteLength(bodyText, "utf8");
+  if (textBytes > MAX_SEARCH_TEXT_BYTES) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_RESOURCE_LIMIT",
+      "Toutiao search text exceeded the configured size limit.",
+      2,
+      {
+        maxTextBytes: MAX_SEARCH_TEXT_BYTES,
+        textBytes
+      }
+    );
+  }
+  return extractSearchItemsFromText(bodyText, keyword);
+}
+function extractSearchItemsFromText(text, keyword) {
+  const blockedPrefixes = /* @__PURE__ */ new Set([
+    "\u65E0\u969C\u788D \u4ECA\u65E5\u5934\u6761\u9996\u9875 \u767B\u5F55 \u7EFC\u5408 \u8D44\u8BAF \u89C6\u9891 \u56FE\u7247 \u7528\u6237 \u5C0F\u89C6\u9891 \u5FAE\u5934\u6761 \u97F3\u4E50 \u53BB\u6296\u97F3\u641C"
+  ]);
+  const lines = text.split(/\n+/).map((line) => line.trim()).filter((line) => line.length >= 12 && !blockedPrefixes.has(line));
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const line of lines) {
+    const normalized = line.replace(/\s+/g, " ");
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    items.push({
+      id: createSearchItemId(keyword, normalized, items.length),
+      title: normalized.slice(0, 180),
+      url: `https://so.toutiao.com/search?keyword=${encodeURIComponent(keyword)}&pd=information&dvpf=pc&source=input`
+    });
+    if (items.length >= 30) {
+      break;
+    }
+  }
+  return items;
+}
+function parseToutiaoArticleLink(href, depth = 0) {
+  if (depth > 3) {
+    return void 0;
+  }
+  const directId = extractArticleId(href);
+  if (directId) {
+    return {
+      id: directId,
+      url: `https://www.toutiao.com/article/${directId}/`
+    };
+  }
+  try {
+    const url = new URL(href);
+    const nextUrl = url.searchParams.get("url");
+    if (nextUrl) {
+      return parseToutiaoArticleLink(nextUrl, depth + 1);
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function extractArticleMetadata(bodyText, title) {
+  const lines = bodyText.split(/\n+/).map((line) => line.trim()).filter(Boolean);
+  const titleIndex = lines.findIndex((line) => line === title);
+  const metadataLine = titleIndex >= 0 ? lines[titleIndex + 1] : void 0;
+  const match = metadataLine?.match(/^(.+?)·(.+)$/);
+  if (!match?.[1] || !match[2]) {
+    return {};
+  }
+  return {
+    authorName: match[2],
+    publishTimeText: match[1]
+  };
+}
+function extractArticleId(value) {
+  return /(?:article|group)\/(\d+)/.exec(value)?.[1] ?? /\/a(\d+)/.exec(value)?.[1] ?? (/^\d+$/.test(value) ? value : void 0);
+}
+function isAuthorFeedResponseUrl(value, authorToken) {
+  try {
+    const url = new URL(value);
+    const isProfileArticleFeed = url.pathname.includes("/api/pc/list/feed") && (url.searchParams.get("category") === "pc_profile_article" || url.searchParams.get("author_token") === authorToken);
+    const isProfileAllFeed = url.pathname.includes("/api/pc/list/user/feed") && url.searchParams.get("category") === "profile_all" && url.searchParams.get("token") === authorToken;
+    return isProfileArticleFeed || isProfileAllFeed;
+  } catch {
+    return value.includes("/api/pc/list/feed") && (value.includes("pc_profile_article") || value.includes(authorToken)) || value.includes("/api/pc/list/user/feed") && value.includes("profile_all") && value.includes(authorToken);
+  }
+}
+function createSearchItemId(keyword, value, index) {
+  let hash = 2166136261;
+  const input = `${keyword}:${index}:${value}`;
+  for (const char of input) {
+    hash ^= char.charCodeAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `search-${(hash >>> 0).toString(16)}`;
+}
+function formatChinaTime2(timestampSeconds) {
+  return new Intl.DateTimeFormat("sv-SE", {
+    day: "2-digit",
+    hour: "2-digit",
+    hour12: false,
+    minute: "2-digit",
+    month: "2-digit",
+    second: "2-digit",
+    timeZone: "Asia/Shanghai",
+    year: "numeric"
+  }).format(new Date(timestampSeconds * 1e3));
+}
+async function loadPlaywright() {
+  return await import("playwright");
+}
+
+// src/cli.ts
+function createCli(options = {}) {
+  const io = {
+    stderr: options.stderr ?? ((value) => process.stderr.write(value)),
+    stdout: options.stdout ?? ((value) => process.stdout.write(value))
+  };
+  const program = new Command().name("ants").description("Move data between systems with composable collectors.").showHelpAfterError().exitOverride();
+  program.configureOutput({
+    outputError: () => void 0,
+    writeErr: () => void 0,
+    writeOut: (value) => io.stdout(value)
+  });
+  registerKr36Commands(program, {
+    runtime: options.kr36Runtime ?? createDefaultKr36Runtime(),
+    stderr: io.stderr,
+    stdout: io.stdout
+  });
+  registerHackerNewsCommands(program, {
+    runtime: options.hackerNewsRuntime ?? createDefaultHackerNewsRuntime(),
+    stderr: io.stderr,
+    stdout: io.stdout
+  });
+  registerToutiaoCommands(program, {
+    runtime: options.toutiaoRuntime ?? createDefaultToutiaoRuntime(),
+    stderr: io.stderr,
+    stdout: io.stdout
+  });
+  return {
+    run: async (args) => {
+      try {
+        await program.parseAsync(args, { from: "user" });
+        return 0;
+      } catch (error) {
+        if (error instanceof CommanderError && error.exitCode === 0) {
+          return 0;
+        }
+        const toutiaoExitCode = handleToutiaoCommandError(error, io);
+        if (toutiaoExitCode !== void 0) {
+          return toutiaoExitCode;
+        }
+        const hackerNewsExitCode = handleHackerNewsCommandError(error, io);
+        if (hackerNewsExitCode !== void 0) {
+          return hackerNewsExitCode;
+        }
+        const kr36ExitCode = handleKr36CommandError(error, io);
+        if (kr36ExitCode !== void 0) {
+          return kr36ExitCode;
+        }
+        if (error instanceof ZodError || error instanceof CommanderError) {
+          const message = error instanceof ZodError ? error.issues[0]?.message ?? "Invalid command arguments." : error.message;
+          writeCliError(io, "INVALID_ARGUMENT", message);
+          return 2;
+        }
+        writeCliError(
+          io,
+          "INTERNAL_ERROR",
+          "An unexpected internal error occurred."
+        );
+        return 1;
+      }
+    }
+  };
+}
+function writeCliError(io, code, message) {
+  io.stderr(`${JSON.stringify({
+    ok: false,
+    error: {
+      code,
+      message
+    }
+  }, null, 2)}
+`);
+}
+
+// src/index.ts
+function isMainEntrypoint(moduleUrl, argv) {
+  const scriptPath = argv[1];
+  if (!scriptPath) {
+    return false;
+  }
+  return realpathSync(fileURLToPath(moduleUrl)) === realpathSync(scriptPath);
+}
+if (isMainEntrypoint(import.meta.url, process.argv)) {
+  const cli = createCli();
+  void cli.run(process.argv.slice(2)).then((exitCode) => {
+    process.exitCode = exitCode;
+  });
+}
+export {
+  createCli,
+  isMainEntrypoint
+};
+//# sourceMappingURL=index.js.map