ai-zero-token 2.0.1 → 2.0.3

package/dist/core/services/github-image-bed-service.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+import crypto from "node:crypto";
+import { loadGithubImageBedStore, updateGithubImageBedToken, clearGithubImageBedStore } from "../store/github-image-bed-store.js";
+import {
+  appendGithubImageBedHistory,
+  clearGithubImageBedHistory,
+  findGithubImageBedHistoryItem,
+  listGithubImageBedHistory,
+  removeGithubImageBedHistoryItem
+} from "../store/github-image-bed-history-store.js";
+const DEFAULT_REPOSITORY = "azt-img-bed";
+const DEFAULT_PREFIX = "images";
+const GITHUB_API_BASE = "https://api.github.com";
+const GITHUB_API_VERSION = "2022-11-28";
+const USER_AGENT = "AI Zero Token";
+function serviceError(message, statusCode = 400) {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  return error;
+}
+function encodePath(pathValue) {
+  return pathValue.split("/").filter(Boolean).map((segment) => encodeURIComponent(segment)).join("/");
+}
+function sanitizeFileName(fileName) {
+  const trimmed = fileName.trim() || "image.png";
+  const normalized = trimmed.normalize("NFKD").replace(/[^\w.\-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "image.png";
+}
+function makeImagePath(fileName) {
+  const now = /* @__PURE__ */ new Date();
+  const yyyy = String(now.getFullYear());
+  const mm = String(now.getMonth() + 1).padStart(2, "0");
+  const dd = String(now.getDate()).padStart(2, "0");
+  const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+  const suffix = crypto.randomUUID().slice(0, 8);
+  const safeName = sanitizeFileName(fileName);
+  return `${DEFAULT_PREFIX}/${yyyy}/${mm}/${dd}/${stamp}-${suffix}-${safeName}`;
+}
+function parseDataUrl(dataUrl) {
+  const trimmed = dataUrl.trim();
+  const match = /^data:([^;]+);base64,(.+)$/i.exec(trimmed);
+  if (!match) {
+    throw serviceError("\u56FE\u7247\u5185\u5BB9\u5FC5\u987B\u662F data URL\u3002");
+  }
+  return {
+    mimeType: match[1] ?? "application/octet-stream",
+    bytes: Buffer.from(match[2] ?? "", "base64"),
+    base64: match[2] ?? ""
+  };
+}
+function buildRawUrl(owner, repository, branch, objectPath) {
+  return `https://raw.githubusercontent.com/${encodeURIComponent(owner)}/${encodeURIComponent(repository)}/${encodeURIComponent(branch)}/${encodePath(objectPath)}`;
+}
+async function requestGithubJson(token, path, options) {
+  const response = await fetch(`${GITHUB_API_BASE}${path}`, {
+    method: options?.method ?? "GET",
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Accept": "application/vnd.github+json",
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT,
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
+    },
+    body: typeof options?.body === "undefined" ? void 0 : JSON.stringify(options.body)
+  });
+  const text = await response.text();
+  let parsed = null;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = text;
+    }
+  }
+  if (!response.ok) {
+    const message = typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string" ? String(parsed.message) : typeof parsed === "string" ? parsed : `${response.status} ${response.statusText}`;
+    throw serviceError(`GitHub API \u8C03\u7528\u5931\u8D25: ${message}`, response.status);
+  }
+  return {
+    status: response.status,
+    data: parsed
+  };
+}
+function readConfigSummary(hasToken) {
+  return {
+    hasToken,
+    repository: DEFAULT_REPOSITORY,
+    pathPrefix: DEFAULT_PREFIX,
+    defaultBranch: "auto"
+  };
+}
+class GithubImageBedService {
+  async getConfig() {
+    const store = await loadGithubImageBedStore();
+    return readConfigSummary(Boolean(store.github.token));
+  }
+  async saveToken(token) {
+    const trimmed = token.trim();
+    if (!trimmed) {
+      throw serviceError("\u8BF7\u5148\u586B\u5199 GitHub token\u3002");
+    }
+    await updateGithubImageBedToken(trimmed);
+    return this.getConfig();
+  }
+  async clearToken() {
+    await clearGithubImageBedStore();
+    return this.getConfig();
+  }
+  async testConnection() {
+    const { token } = await this.requireToken();
+    const owner = await this.getCurrentLogin(token);
+    const repo = await this.ensureRepository(token, owner);
+    const branch = repo.default_branch?.trim() || "main";
+    return {
+      ok: true,
+      owner,
+      repository: DEFAULT_REPOSITORY,
+      repositoryUrl: repo.html_url || `https://github.com/${encodeURIComponent(owner)}/${encodeURIComponent(DEFAULT_REPOSITORY)}`,
+      branch,
+      publicUrl: repo.html_url || `https://github.com/${encodeURIComponent(owner)}/${encodeURIComponent(DEFAULT_REPOSITORY)}`,
+      createdRepository: false
+    };
+  }
+  async uploadImage(params) {
+    const { token } = await this.requireToken();
+    const owner = await this.getCurrentLogin(token);
+    const repo = await this.ensureRepository(token, owner);
+    const branch = repo.default_branch?.trim() || "main";
+    const parsed = parseDataUrl(params.dataUrl);
+    const objectPath = makeImagePath(params.filename);
+    const response = await requestGithubJson(token, `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(DEFAULT_REPOSITORY)}/contents/${encodePath(objectPath)}`, {
+      method: "PUT",
+      body: {
+        message: `upload ${params.filename}`,
+        content: parsed.base64,
+        branch
+      }
+    });
+    const content = response.data.content;
+    const downloadUrl = content?.download_url || buildRawUrl(owner, DEFAULT_REPOSITORY, branch, objectPath);
+    const htmlUrl = content?.html_url || `https://github.com/${encodeURIComponent(owner)}/${encodeURIComponent(DEFAULT_REPOSITORY)}/blob/${encodeURIComponent(branch)}/${encodePath(objectPath)}`;
+    return {
+      filename: params.filename,
+      path: objectPath,
+      url: downloadUrl,
+      htmlUrl,
+      downloadUrl,
+      owner,
+      repository: DEFAULT_REPOSITORY,
+      branch,
+      size: parsed.bytes.byteLength,
+      mimeType: parsed.mimeType,
+      sha: content?.sha || response.data.commit?.sha
+    };
+  }
+  async listHistory(limit = 50) {
+    return {
+      items: await listGithubImageBedHistory(limit)
+    };
+  }
+  async clearHistory() {
+    await clearGithubImageBedHistory();
+    return { items: [] };
+  }
+  async deleteHistoryItem(id) {
+    const item = await findGithubImageBedHistoryItem(id);
+    if (!item) {
+      throw serviceError("\u672A\u627E\u5230\u8FD9\u6761\u4E0A\u4F20\u5386\u53F2\u3002", 404);
+    }
+    const { token } = await this.requireToken();
+    await this.deleteRemoteFile(token, item);
+    await removeGithubImageBedHistoryItem(id);
+    return this.listHistory(100);
+  }
+  async rememberUpload(result) {
+    await appendGithubImageBedHistory({
+      id: crypto.randomUUID(),
+      createdAt: Date.now(),
+      filename: result.filename,
+      path: result.path,
+      url: result.url,
+      htmlUrl: result.htmlUrl,
+      downloadUrl: result.downloadUrl,
+      owner: result.owner,
+      repository: result.repository,
+      branch: result.branch,
+      size: result.size,
+      mimeType: result.mimeType,
+      previewUrl: result.url,
+      sha: result.sha
+    });
+  }
+  async requireToken() {
+    const store = await loadGithubImageBedStore();
+    const token = store.github.token.trim();
+    if (!token) {
+      throw serviceError("\u8BF7\u5148\u4FDD\u5B58 GitHub token\u3002", 400);
+    }
+    return { token };
+  }
+  async getCurrentLogin(token) {
+    const response = await requestGithubJson(token, "/user");
+    const login = response.data.login?.trim();
+    if (!login) {
+      throw serviceError("\u65E0\u6CD5\u8BFB\u53D6 GitHub \u767B\u5F55\u540D\u3002", 502);
+    }
+    return login;
+  }
+  async ensureRepository(token, owner) {
+    const repositoryPath = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(DEFAULT_REPOSITORY)}`;
+    try {
+      const response = await requestGithubJson(token, repositoryPath);
+      if (response.data.private) {
+        throw serviceError(`\u4ED3\u5E93 ${DEFAULT_REPOSITORY} \u5FC5\u987B\u662F\u516C\u5F00\u4ED3\u5E93\uFF0C\u624D\u80FD\u8FD4\u56DE\u516C\u7F51\u56FE\u7247\u94FE\u63A5\u3002`, 400);
+      }
+      return response.data;
+    } catch (error) {
+      const normalized = error;
+      if (normalized.statusCode === 404) {
+        throw serviceError(
+          `\u672A\u627E\u5230\u516C\u5F00\u4ED3\u5E93 ${DEFAULT_REPOSITORY}\u3002\u8BF7\u5148\u5728 GitHub \u521B\u5EFA\u4E00\u4E2A\u516C\u5F00\u4ED3\u5E93\uFF0C\u7136\u540E\u628A\u8FD9\u4E2A\u4ED3\u5E93\u52A0\u5165 token \u7684 Repository access\uFF0C\u518D\u56DE\u6765\u91CD\u8BD5\u3002`,
+          404
+        );
+      }
+      throw error;
+    }
+  }
+  async deleteRemoteFile(token, item) {
+    const owner = item.owner?.trim();
+    const repository = item.repository?.trim() || DEFAULT_REPOSITORY;
+    const branch = item.branch?.trim() || "main";
+    const objectPath = item.path?.trim();
+    if (!owner || !objectPath) {
+      throw serviceError("\u5386\u53F2\u8BB0\u5F55\u7F3A\u5C11 GitHub \u6587\u4EF6\u8DEF\u5F84\uFF0C\u65E0\u6CD5\u5220\u9664\u8FDC\u7AEF\u6587\u4EF6\u3002", 400);
+    }
+    const sha = item.sha?.trim() || await this.readRemoteFileSha(token, owner, repository, objectPath, branch);
+    if (!sha) {
+      throw serviceError("\u65E0\u6CD5\u8BFB\u53D6\u8FDC\u7AEF\u6587\u4EF6 sha\uFF0C\u5220\u9664\u5931\u8D25\u3002", 502);
+    }
+    await requestGithubJson(token, `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repository)}/contents/${encodePath(objectPath)}`, {
+      method: "DELETE",
+      body: {
+        message: `delete ${item.filename || objectPath}`,
+        sha,
+        branch
+      }
+    });
+  }
+  async readRemoteFileSha(token, owner, repository, objectPath, branch) {
+    const response = await requestGithubJson(
+      token,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repository)}/contents/${encodePath(objectPath)}?ref=${encodeURIComponent(branch)}`
+    );
+    const content = Array.isArray(response.data) ? null : response.data;
+    const sha = content?.type === "file" || content?.type === "symlink" ? content.sha?.trim() : content?.sha?.trim();
+    if (!sha) {
+      throw serviceError("\u65E0\u6CD5\u8BFB\u53D6\u8FDC\u7AEF\u6587\u4EF6 sha\u3002", 502);
+    }
+    return sha;
+  }
+}
+export {
+  GithubImageBedService
+};

package/dist/core/services/network-detect-service.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
+import fs from "node:fs/promises";
+import { getServers as getDnsServers } from "node:dns";
 import { execFile } from "node:child_process";
+import { isIP } from "node:net";
 import { promisify } from "node:util";
 import { requestText } from "../providers/http-client.js";
 const execFileAsync = promisify(execFile);
@@ -10,6 +13,18 @@ const PLATFORM_PROBE_HEADERS = {
   "pragma": "no-cache",
   "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36"
 };
+const PUBLIC_IPV4_CANDIDATES = [
+  "https://ifconfig.me/ip",
+  "https://api.ipify.org/",
+  "https://icanhazip.com/",
+  "https://checkip.amazonaws.com/"
+];
+const PUBLIC_IPV6_CANDIDATES = [
+  "https://ifconfig.me/ipv6",
+  "https://api6.ipify.org/",
+  "https://ipv6.icanhazip.com/",
+  "https://ipv6.test-ipv6.com/"
+];
 function parseKeyValueText(input) {
   return Object.fromEntries(
     input.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
@@ -28,8 +43,54 @@ function parseDnsServers(text) {
   }
   return [...servers];
 }
+function parseResolvConfServers(text) {
+  const servers = /* @__PURE__ */ new Set();
+  for (const line of text.split(/\r?\n/)) {
+    const match = line.trim().match(/^nameserver\s+([0-9a-fA-F:.%]+)/i);
+    if (match) {
+      servers.add(match[1]);
+    }
+  }
+  return [...servers];
+}
+function parseWindowsDnsServers(text) {
+  const servers = /* @__PURE__ */ new Set();
+  let collecting = false;
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      collecting = false;
+      continue;
+    }
+    const match = trimmed.match(/^(DNS Servers?|DNS 服务器)[^:]*:\s*(.*)$/i);
+    if (match) {
+      const first = match[2].trim();
+      if (first) {
+        servers.add(first);
+      }
+      collecting = true;
+      continue;
+    }
+    if (collecting && /^[0-9a-fA-F:.%]+$/.test(trimmed)) {
+      servers.add(trimmed);
+      continue;
+    }
+    collecting = false;
+  }
+  return [...servers];
+}
+function normalizeIpAddress(ip) {
+  return ip.trim().replace(/%[0-9A-Za-z._-]+$/, "");
+}
+function collectDnsServer(servers, value) {
+  const normalized = normalizeIpAddress(value);
+  if (isIP(normalized) > 0) {
+    servers.add(normalized);
+  }
+}
 function isPrivateOrReservedIp(ip) {
-  return /^(10|127|169\.254|172\.(1[6-9]|2\d|3[0-1])|192\.168)\./.test(ip) || /^0\./.test(ip) || /^100\.(6[4-9]|[7-9]\d|1\d\d|2[0-3]\d|24[0-7])\./.test(ip) || /^198\.(18|19)\./.test(ip) || /^203\.0\.113\./.test(ip) || /^192\.0\.2\./.test(ip) || /^198\.51\.100\./.test(ip) || /^fc00:/i.test(ip) || /^fd00:/i.test(ip) || /^fe80:/i.test(ip) || /^::1$/.test(ip);
+  const normalizedIp = normalizeIpAddress(ip);
+  return /^(10|127|169\.254|172\.(1[6-9]|2\d|3[0-1])|192\.168)\./.test(normalizedIp) || /^0\./.test(normalizedIp) || /^100\.(6[4-9]|[7-9]\d|1\d\d|2[0-3]\d|24[0-7])\./.test(normalizedIp) || /^198\.(18|19)\./.test(normalizedIp) || /^203\.0\.113\./.test(normalizedIp) || /^192\.0\.2\./.test(normalizedIp) || /^198\.51\.100\./.test(normalizedIp) || /^fc00:/i.test(normalizedIp) || /^fd00:/i.test(normalizedIp) || /^fe80:/i.test(normalizedIp) || /^::1$/.test(normalizedIp);
 }
 function toCountryName(code) {
   if (!code) {
@@ -41,6 +102,37 @@ function toCountryName(code) {
     return code;
   }
 }
+function normalizeProbeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function describeSourceUrl(url) {
+  try {
+    return new URL(url).hostname.replace(/^www\./i, "");
+  } catch {
+    return url;
+  }
+}
+async function probePublicIpCandidate(url, family, proxy, timeoutMs = 4e3) {
+  const label = describeSourceUrl(url);
+  try {
+    const response = await requestText({
+      method: "GET",
+      url,
+      timeoutMs,
+      proxyOverride: proxy
+    });
+    if (response.status < 200 || response.status >= 300) {
+      return { url, label, error: `HTTP ${response.status}` };
+    }
+    const ip = normalizeIpAddress(response.body);
+    if (isIP(ip) !== family) {
+      return { url, label, error: `\u672A\u8FD4\u56DE IPv${family} \u5730\u5740` };
+    }
+    return { url, label, ip };
+  } catch (error) {
+    return { url, label, error: normalizeProbeError(error) };
+  }
+}
 async function runCommand(command, args, timeoutMs = 2500) {
   const result = await execFileAsync(command, args, {
     timeout: timeoutMs,
@@ -50,99 +142,122 @@ async function runCommand(command, args, timeoutMs = 2500) {
 }
 async function readDnsServers() {
   const servers = /* @__PURE__ */ new Set();
-  let source = "\u7CFB\u7EDF DNS";
-  try {
-    const scutil = await runCommand("scutil", ["--dns"], 2500);
-    parseDnsServers(scutil).forEach((item) => servers.add(item));
-    source = "scutil --dns";
-  } catch {
+  const sources = /* @__PURE__ */ new Set();
+  for (const server of getDnsServers()) {
+    collectDnsServer(servers, server);
   }
-  try {
-    const wifiDns = await runCommand("networksetup", ["-getdnsservers", "Wi-Fi"], 2500);
-    for (const line of wifiDns.split(/\r?\n/)) {
-      const value = line.trim();
-      if (value && /^[0-9a-fA-F:.]+$/.test(value)) {
-        servers.add(value);
+  if (servers.size > 0) {
+    sources.add("node:dns");
+  }
+  if (process.platform === "darwin") {
+    try {
+      const scutil = await runCommand("scutil", ["--dns"], 2500);
+      parseDnsServers(scutil).forEach((item) => collectDnsServer(servers, item));
+      if (servers.size > 0) {
+        sources.add("scutil --dns");
+      }
+    } catch {
+    }
+    try {
+      const wifiDns = await runCommand("networksetup", ["-getdnsservers", "Wi-Fi"], 2500);
+      for (const line of wifiDns.split(/\r?\n/)) {
+        const value = line.trim();
+        if (value && /^[0-9a-fA-F:.%]+$/.test(value)) {
+          collectDnsServer(servers, value);
+        }
+      }
+      if (servers.size > 0) {
+        sources.add("networksetup");
       }
+    } catch {
     }
-    if (servers.size > 0) {
-      source = `${source} + networksetup`;
+  } else if (process.platform === "linux") {
+    try {
+      const resolvConf = await fs.readFile("/etc/resolv.conf", "utf8");
+      parseResolvConfServers(resolvConf).forEach((item) => collectDnsServer(servers, item));
+      if (servers.size > 0) {
+        sources.add("/etc/resolv.conf");
+      }
+    } catch {
+    }
+  } else if (process.platform === "win32") {
+    try {
+      const ipconfig = await runCommand("ipconfig", ["/all"], 3e3);
+      parseWindowsDnsServers(ipconfig).forEach((item) => collectDnsServer(servers, item));
+      if (servers.size > 0) {
+        sources.add("ipconfig /all");
+      }
+    } catch {
     }
-  } catch {
   }
   return {
     servers: [...servers],
-    source
+    source: sources.size > 0 ? [...sources].join(" + ") : "\u7CFB\u7EDF DNS"
   };
 }
 async function probePublicIpv4(proxy) {
   const startedAt = performance.now();
-  const response = await requestText({
-    method: "GET",
-    url: "https://ifconfig.me/ip",
-    timeoutMs: 8e3,
-    proxyOverride: proxy
-  });
-  if (response.status < 200 || response.status >= 500) {
-    throw new Error(`\u516C\u7F51 IPv4 \u63A2\u6D4B\u5931\u8D25: HTTP ${response.status}`);
-  }
-  const ip = response.body.trim();
-  let trace = {};
-  try {
-    const traceResponse = await requestText({
-      method: "GET",
-      url: "https://www.cloudflare.com/cdn-cgi/trace",
-      timeoutMs: 8e3,
-      proxyOverride: proxy
-    });
-    trace = parseKeyValueText(traceResponse.body);
-  } catch {
-    trace = {};
+  const sourceLabels = PUBLIC_IPV4_CANDIDATES.map(describeSourceUrl);
+  const results = await Promise.all(
+    PUBLIC_IPV4_CANDIDATES.map((url) => probePublicIpCandidate(url, 4, proxy, 3500))
+  );
+  const matched = results.find((item) => item.ip);
+  if (matched?.ip) {
+    let trace = {};
+    try {
+      const traceResponse = await requestText({
+        method: "GET",
+        url: "https://www.cloudflare.com/cdn-cgi/trace",
+        timeoutMs: 5e3,
+        proxyOverride: proxy
+      });
+      trace = parseKeyValueText(traceResponse.body);
+    } catch {
+      trace = {};
+    }
+    const countryCode = trace.loc;
+    const countryName = toCountryName(countryCode);
+    return {
+      available: true,
+      ip: matched.ip,
+      countryCode,
+      countryName,
+      colo: trace.colo,
+      source: `${matched.label}${trace.loc || trace.colo ? " + cloudflare trace" : ""}`,
+      detail: countryName ? `\u51FA\u53E3\u4F4D\u4E8E ${countryName}${trace.colo ? ` \xB7 ${trace.colo}` : ""}` : "\u68C0\u6D4B\u5230\u516C\u7F51 IPv4 \u51FA\u53E3\u3002",
+      elapsedMs: Math.round(performance.now() - startedAt)
+    };
   }
-  const countryCode = trace.loc;
+  const attemptedSources = results.map((item) => `${item.label}: ${item.error || "\u672A\u8FD4\u56DE\u7ED3\u679C"}`);
   return {
-    ip,
-    countryCode,
-    countryName: toCountryName(countryCode),
-    colo: trace.colo,
-    source: "ifconfig.me + cloudflare trace",
+    available: false,
+    ip: "",
+    source: sourceLabels.join(" / "),
+    detail: attemptedSources.length > 0 ? `\u672A\u83B7\u5F97\u516C\u7F51 IPv4\u3002${attemptedSources.slice(0, 2).join("\uFF1B")}` : "\u672A\u83B7\u5F97\u516C\u7F51 IPv4\u3002",
     elapsedMs: Math.round(performance.now() - startedAt)
   };
 }
 async function probePublicIpv6(proxy) {
   const startedAt = performance.now();
-  const ipv6Candidates = [
-    "https://ifconfig.me/ipv6",
-    "https://ipv6.test-ipv6.com/"
-  ];
-  for (const url of ipv6Candidates) {
-    try {
-      const response = await requestText({
-        method: "GET",
-        url,
-        timeoutMs: 6e3,
-        proxyOverride: proxy
-      });
-      const body = response.body.trim();
-      if (!body) {
-        continue;
-      }
-      if (/^[0-9a-fA-F:]+$/.test(body) && body.includes(":")) {
-        return {
-          available: true,
-          ip: body,
-          source: url,
-          detail: "\u68C0\u6D4B\u5230\u72EC\u7ACB IPv6 \u51FA\u53E3\u3002",
-          elapsedMs: Math.round(performance.now() - startedAt)
-        };
-      }
-    } catch {
-    }
+  const results = await Promise.all(
+    PUBLIC_IPV6_CANDIDATES.map((url) => probePublicIpCandidate(url, 6, proxy, 3e3))
+  );
+  const matched = results.find((item) => item.ip);
+  if (matched?.ip) {
+    return {
+      available: true,
+      ip: matched.ip,
+      source: matched.label,
+      detail: "\u68C0\u6D4B\u5230\u72EC\u7ACB IPv6 \u51FA\u53E3\u3002",
+      elapsedMs: Math.round(performance.now() - startedAt)
+    };
   }
+  const attemptedSources = results.map((item) => `${item.label}: ${item.error || "\u672A\u8FD4\u56DE\u7ED3\u679C"}`);
   return {
     available: false,
-    source: "ifconfig.me / test-ipv6.com",
-    detail: "\u672A\u68C0\u6D4B\u5230\u72EC\u7ACB IPv6 \u51FA\u53E3\uFF0C\u5F53\u524D\u8FDE\u63A5\u53EF\u80FD\u53EA\u8D70 IPv4\u3002"
+    source: PUBLIC_IPV6_CANDIDATES.map(describeSourceUrl).join(" / "),
+    detail: attemptedSources.length > 0 ? `\u672A\u68C0\u6D4B\u5230\u72EC\u7ACB IPv6 \u51FA\u53E3\u3002${attemptedSources.slice(0, 2).join("\uFF1B")}` : "\u672A\u68C0\u6D4B\u5230\u72EC\u7ACB IPv6 \u51FA\u53E3\uFF0C\u5F53\u524D\u8FDE\u63A5\u53EF\u80FD\u53EA\u8D70 IPv4\u3002",
+    elapsedMs: Math.round(performance.now() - startedAt)
   };
 }
 async function probePlatform(url, label, proxy) {
@@ -216,7 +331,7 @@ class NetworkDetectService {
         probePlatform("https://x.com/", "X", proxy)
       ])
     ]);
-    const dnsDetail = dns.servers.length > 0 ? `\u7CFB\u7EDF DNS: ${dns.servers.join(" / ")}` : "\u672A\u8BFB\u53D6\u5230\u7CFB\u7EDF DNS\u3002";
+    const dnsDetail = dns.servers.length > 0 ? `\u7CFB\u7EDF DNS: ${dns.servers.join(" / ")}` : `${dns.source} \u672A\u8BFB\u53D6\u5230\u7CFB\u7EDF DNS\u3002`;
     return {
       checkedAt: Date.now(),
       publicIpv4,

package/dist/core/services/version-service.js

@@ -56,7 +56,7 @@ class VersionService {
     const manifest = await readPackageManifest();
     const registryUrl = `https://registry.npmjs.org/${encodeURIComponent(manifest.name)}/latest`;
     try {
-      const latestVersion = await this.fetchNpmLatestVersion(registryUrl);
+      const latestVersion = process.env.AZT_FORCE_LATEST_VERSION || await this.fetchNpmLatestVersion(registryUrl);
       const needsUpdate = compareSemver(manifest.version, latestVersion) < 0;
       return {
         packageName: manifest.name,

package/dist/core/store/github-image-bed-history-store.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureStateMigrated, getStateDir } from "./state-paths.js";
+const MAX_HISTORY_ITEMS = 100;
+function createEmptyStore() {
+  return {
+    version: 1,
+    items: []
+  };
+}
+function getGithubImageBedHistoryPath() {
+  return path.join(getStateDir(), "github-image-bed-history.json");
+}
+async function readStore() {
+  try {
+    await ensureStateMigrated();
+    const raw = await fs.readFile(getGithubImageBedHistoryPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      version: 1,
+      items: Array.isArray(parsed.items) ? parsed.items.slice(0, MAX_HISTORY_ITEMS) : []
+    };
+  } catch {
+    return createEmptyStore();
+  }
+}
+async function writeStore(store) {
+  await ensureStateMigrated();
+  await fs.mkdir(getStateDir(), { recursive: true });
+  await fs.writeFile(getGithubImageBedHistoryPath(), `${JSON.stringify(store, null, 2)}
+`, "utf8");
+}
+async function listGithubImageBedHistory(limit = 50) {
+  const store = await readStore();
+  return store.items.slice(0, Math.max(1, Math.min(limit, MAX_HISTORY_ITEMS)));
+}
+async function appendGithubImageBedHistory(item) {
+  const store = await readStore();
+  store.items = [item, ...store.items.filter((entry) => entry.id !== item.id)].slice(0, MAX_HISTORY_ITEMS);
+  await writeStore(store);
+  return item;
+}
+async function findGithubImageBedHistoryItem(id) {
+  const store = await readStore();
+  return store.items.find((entry) => entry.id === id) || null;
+}
+async function removeGithubImageBedHistoryItem(id) {
+  const store = await readStore();
+  const target = store.items.find((entry) => entry.id === id) || null;
+  if (!target) {
+    return null;
+  }
+  store.items = store.items.filter((entry) => entry.id !== id);
+  await writeStore(store);
+  return target;
+}
+async function clearGithubImageBedHistory() {
+  await writeStore(createEmptyStore());
+}
+export {
+  appendGithubImageBedHistory,
+  clearGithubImageBedHistory,
+  findGithubImageBedHistoryItem,
+  getGithubImageBedHistoryPath,
+  listGithubImageBedHistory,
+  removeGithubImageBedHistoryItem
+};