@zzclub/pipeline 0.5.1 → 0.9.0

package/src/commands/wechat-export.ts

@@ -54,6 +54,7 @@ ${CSS_DEMO}
   const customCss = optionalArg(parsed, "custom-css");
 
   const config = loadConfig();
+  const wxAccount = config.wx.accounts[account] ?? config.wx.accounts[config.wx.defaultAccount];
   const markdownRenderer = await resolveMarkdownRenderer(config);
   const result = await markdownRenderer.render({
     markdownPath,
@@ -62,6 +63,7 @@ ${CSS_DEMO}
     title,
     previewShellOutPath,
     customCss,
+    themeOverrides: wxAccount?.theme,
   });
 
   printResult(result, renderWechatExport);

package/src/db.test.ts

@@ -0,0 +1,47 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, exists } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { getDb, initDb } from "./db";
+
+describe("db", () => {
+  let workspace: string;
+
+  beforeEach(async () => {
+    workspace = await mkdtemp(join(tmpdir(), "zzhub-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(workspace, { recursive: true, force: true });
+  });
+
+  test("getDb creates database file", () => {
+    const db = getDb(workspace);
+    db.close();
+    expect(exists(join(workspace, "zzhub.db"))).resolves.toBe(true);
+  });
+
+  test("initDb creates topics table", () => {
+    const db = getDb(workspace);
+    initDb(db);
+
+    const tables = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='topics'"
+    ).all();
+
+    expect(tables.length).toBe(1);
+    db.close();
+  });
+
+  test("initDb creates analytics table", () => {
+    const db = getDb(workspace);
+    initDb(db);
+
+    const tables = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='analytics'"
+    ).all();
+
+    expect(tables.length).toBe(1);
+    db.close();
+  });
+});

package/src/db.ts

@@ -0,0 +1,95 @@
+import { Database } from "bun:sqlite";
+import { join } from "path";
+import { existsSync } from "fs";
+import { mkdirSync } from "fs";
+
+const DB_FILE = "zzhub.db";
+
+/**
+ * Get or create SQLite database for workspace.
+ */
+export function getDb(workspace: string): Database {
+  if (!existsSync(workspace)) {
+    mkdirSync(workspace, { recursive: true });
+  }
+
+  const dbPath = join(workspace, DB_FILE);
+  const db = new Database(dbPath);
+
+  // Enable WAL mode for better concurrent performance
+  db.exec("PRAGMA journal_mode = WAL;");
+
+  return db;
+}
+
+/**
+ * Initialize database schema (idempotent).
+ */
+export function initDb(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS topics (
+      topic_id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT,
+      priority TEXT CHECK(priority IN ('high', 'medium', 'low')) DEFAULT 'medium',
+      tags TEXT,
+      notes TEXT,
+      status TEXT CHECK(status IN (
+        'backlog', 'evaluating', 'scheduled', 'in_progress', 'published', 'abandoned'
+      )) DEFAULT 'backlog',
+
+      ai_score INTEGER,
+      ai_reason TEXT,
+
+      scheduled_date TEXT,
+      target_account TEXT,
+
+      run_id TEXT,
+
+      retro_performance TEXT CHECK(retro_performance IN (
+        'excellent', 'good', 'average', 'poor', null
+      )),
+      retro_lessons TEXT,
+      retro_metrics_snapshot TEXT,
+
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_topics_status ON topics(status);
+    CREATE INDEX IF NOT EXISTS idx_topics_priority ON topics(priority);
+    CREATE INDEX IF NOT EXISTS idx_topics_scheduled ON topics(scheduled_date);
+    CREATE INDEX IF NOT EXISTS idx_topics_created ON topics(created_at);
+
+    CREATE TABLE IF NOT EXISTS analytics (
+      run_id TEXT PRIMARY KEY,
+      topic_id TEXT,
+      title TEXT NOT NULL,
+      publish_date TEXT NOT NULL,
+
+      reads INTEGER DEFAULT 0,
+      likes INTEGER DEFAULT 0,
+      favorites INTEGER DEFAULT 0,
+      shares INTEGER DEFAULT 0,
+      comments INTEGER DEFAULT 0,
+
+      notes TEXT,
+      recorded_at TEXT NOT NULL,
+
+      FOREIGN KEY (topic_id) REFERENCES topics(topic_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_analytics_publish_date ON analytics(publish_date);
+    CREATE INDEX IF NOT EXISTS idx_analytics_topic ON analytics(topic_id);
+    CREATE INDEX IF NOT EXISTS idx_analytics_reads ON analytics(reads);
+  `);
+}
+
+/**
+ * Ensure database is initialized for workspace.
+ */
+export function ensureDb(workspace: string): Database {
+  const db = getDb(workspace);
+  initDb(db);
+  return db;
+}

package/src/imgx/assets/templates/wechat-cover-split.html

@@ -136,7 +136,7 @@
 <body>
   <div class="canvas">
     <section class="left">
-      <div class="eyebrow">公众号·早早集市</div>
+      <div class="eyebrow">{{FOOTER_TEXT}}</div>
       <div class="text-block">
         <div class="pretext-lines" id="cover-lines" aria-label="cover text"></div>
       </div>

package/src/imgx/render-card.ts

@@ -30,11 +30,7 @@ const DEFAULT_SIZE = { width: 900, height: 1200 } as const;
 const WECHAT_SPLIT_WINDOW_EXTRA_HEIGHT = 87;
 const PRETEXT_SCREENSHOT_VIRTUAL_TIME_BUDGET_MS = 6_000;
 
-function detectIcon(template: string, _text: string, _line1: string, _line2: string, _line3: string, fallbackIcon: string): string {
-  if (template === "wechat-cover-split") {
-    return join(ICONS_DIR, "logo.png");
-  }
-
+function detectIcon(_template: string, _text: string, _line1: string, _line2: string, _line3: string, fallbackIcon: string): string {
   if (fallbackIcon.length > 0) return fallbackIcon;
   return join(ICONS_DIR, "logo.png");
 }

package/src/plugins.ts

@@ -1,4 +1,5 @@
 import { abandon } from "./commands/abandon";
+import { analytics } from "./commands/analytics";
 import { attachBody } from "./commands/attach-body";
 import { attachBodyImages } from "./commands/attach-body-images";
 import { attachNewspicSpec } from "./commands/attach-newspic-spec";
@@ -16,11 +17,13 @@ import { prepare } from "./commands/prepare";
 import { publish } from "./commands/publish";
 import { reconcile } from "./commands/reconcile";
 import { render } from "./commands/render";
+import { republish } from "./commands/republish";
 import { reset } from "./commands/reset";
 import { review } from "./commands/review";
 import { status } from "./commands/status";
 import { syncBlog } from "./commands/sync-blog";
 import { tasks } from "./commands/tasks";
+import { topic } from "./commands/topic";
 import { wechatExport } from "./commands/wechat-export";
 import { wxDrafts } from "./commands/wx-drafts";
 import { wxDraftDelete } from "./commands/wx-draft-delete";
@@ -64,7 +67,8 @@ export function getCommandPlugins(): CommandPlugin[] {
     {
       name: "ops",
       commands: [
-        { name: "sync-blog", summary: "Copy canonical markdown to the blog repo and publish there", plugin: "ops", handler: syncBlog },
+        { name: "sync-blog", summary: "Copy post.md to blog repo, publish, and record result in state JSON", plugin: "ops", handler: syncBlog },
+        { name: "republish", summary: "Publish completed task to additional accounts/platforms", plugin: "ops", handler: republish },
         { name: "imgx", summary: "Run bundled imgx renderer subcommands", plugin: "ops", handler: imgxCommand },
         { name: "wechat-export", summary: "Render markdown to WeChat HTML with bundled preview styles", plugin: "ops", handler: wechatExport },
         { name: "cos-upload", summary: "Upload a local image to configured COS CDN", plugin: "ops", handler: cosUpload },
@@ -73,6 +77,8 @@ export function getCommandPlugins(): CommandPlugin[] {
         { name: "hermes-metrics", summary: "Show Hermes execution metrics per task", plugin: "ops", handler: hermesMetrics },
         { name: "wx-drafts", summary: "List or get drafts from WeChat draft box", plugin: "ops", handler: wxDrafts },
         { name: "wx-draft-delete", summary: "Delete a draft from WeChat draft box", plugin: "ops", handler: wxDraftDelete },
+        { name: "topic", summary: "Manage topics (add, list, update, schedule, retro, abandon)", plugin: "ops", handler: topic },
+        { name: "analytics", summary: "Record and analyze post-publish metrics", plugin: "ops", handler: analytics },
       ],
     },
   ];

package/src/providers/blog.ts

@@ -84,9 +84,12 @@ export async function publishBlogRoute({
 }: BlogPublishContext): Promise<PublishResult> {
   const postPath = join(state.asset_path, "post.md");
   const postContent = await readFile(postPath, "utf-8");
-  const category = "posts";
+  const category = "nezus";
   const blogRoot = workspacePaths.blogRoot;
-  const blogPostPath = join(blogRoot, "content", category, `${state.metadata.slug}.md`);
+
+  const [year, month] = state.metadata.date.split("-");
+  const blogPostDir = join(blogRoot, "content", category, year, month);
+  const blogPostPath = join(blogPostDir, `${state.metadata.slug}.md`);
 
   const lines = ["---"];
   lines.push(`title: "${state.metadata.title.replace(/"/g, '\\"')}"`);
@@ -120,6 +123,7 @@ export async function publishBlogRoute({
     console.error(`[dry-run] Blog: cd ${blogRoot} && ${config.commands.blogPublish.join(" ")}`);
     return {
       route: "blog",
+      account: "default",
       status: "skipped",
       detail: "dry-run",
       published_at: null,
@@ -128,13 +132,14 @@ export async function publishBlogRoute({
     };
   }
 
-  await mkdir(join(blogRoot, "content", category), { recursive: true });
+  await mkdir(blogPostDir, { recursive: true });
   await writeFile(blogPostPath, blogContent, "utf-8");
   const result = spawnSync(config.commands.blogPublish, { cwd: blogRoot });
 
   if (result.exitCode !== 0) {
     return {
       route: "blog",
+      account: "default",
       status: "failed",
       detail: `blog publish command failed: ${config.commands.blogPublish.join(" ")}`,
       published_at: null,
@@ -145,6 +150,7 @@ export async function publishBlogRoute({
 
   return {
     route: "blog",
+    account: "default",
     status: "success",
     detail: null,
     published_at: new Date().toISOString(),

package/src/providers/index.test.ts

@@ -21,6 +21,6 @@ describe("getPublishProvider", () => {
   });
 
   test("throws for unregistered route", () => {
-    expect(() => getPublishProvider("blog" as never)).toThrow();
+    expect(() => getPublishProvider("nonexistent" as never)).toThrow();
   });
 });

package/src/providers/index.ts

@@ -7,6 +7,7 @@ import {
   prepareBodyForNewspic,
 } from "../text";
 import { resolveMarkdownRenderer } from "../adapter-loader";
+import { publishBlogRoute } from "./blog";
 import { createWechatDraft, createWechatNewspic, extractImageUrls, mergePhotoLists } from "./wechat";
 
 export interface PublishRouteContext {
@@ -14,6 +15,7 @@ export interface PublishRouteContext {
   dryRun: boolean;
   config: PipelineConfig;
   workspacePaths: ResolvedWorkspacePaths;
+  accountOverride?: string;
 }
 
 export type PublishProvider = (ctx: PublishRouteContext) => Promise<PublishResult>;
@@ -23,6 +25,7 @@ async function publishWechatArticleRoute({
   dryRun,
   config,
   workspacePaths,
+  accountOverride,
 }: PublishRouteContext): Promise<PublishResult> {
   const postPath = join(state.asset_path, "post.md");
   let exportPostPath = postPath;
@@ -51,11 +54,14 @@ async function publishWechatArticleRoute({
     }
   }
 
+  const account = accountOverride || state.route.account;
+
   if (dryRun) {
     console.error(`[dry-run] Zotepad export: ${exportPostPath}`);
     console.error(`[dry-run] Wechat draft: ${state.metadata.title}`);
     return {
       route: "wechat-article",
+      account,
       status: "skipped",
       detail: "dry-run",
       published_at: null,
@@ -66,16 +72,17 @@ async function publishWechatArticleRoute({
 
   try {
     const markdownRenderer = await resolveMarkdownRenderer(config);
-    const wxAccount = config.wx.accounts[state.route.account] ?? config.wx.accounts[config.wx.defaultAccount];
+    const wxAccount = config.wx.accounts[account] ?? config.wx.accounts[config.wx.defaultAccount];
     const { html } = await markdownRenderer.render({
       markdownPath: exportPostPath,
       outPath: workspacePaths.zotepadExportHtml,
-      account: state.route.account,
+      account,
       title: state.metadata.title,
       customCss: wxAccount?.customCss ?? null,
+      themeOverrides: wxAccount?.theme,
     });
     await createWechatDraft({
-      account: state.route.account,
+      account,
       title: state.metadata.title,
       html,
       photos,
@@ -83,11 +90,12 @@ async function publishWechatArticleRoute({
       existingDraftMediaId: state.intent.existing_draft_media_id,
       noteId: state.intent.note_id,
       nezusBaseUrl: process.env.ZZHUB_WX_BASE_URL || config.wx.baseUrl,
-      nezusPat: process.env.ZZCLUB_PAT || config.wx.accounts[state.route.account]?.pat || config.wx.accounts[config.wx.defaultAccount]?.pat,
+      nezusPat: process.env.ZZCLUB_PAT || config.wx.accounts[account]?.pat || config.wx.accounts[config.wx.defaultAccount]?.pat,
     });
   } catch (error) {
     return {
       route: "wechat-article",
+      account,
       status: "failed",
       detail: error instanceof Error ? error.message : String(error),
       published_at: null,
@@ -98,6 +106,7 @@ async function publishWechatArticleRoute({
 
   return {
     route: "wechat-article",
+    account,
     status: "success",
     detail: null,
     published_at: new Date().toISOString(),
@@ -110,6 +119,7 @@ async function publishWechatNewspicRoute({
   state,
   dryRun,
   config,
+  accountOverride,
 }: PublishRouteContext): Promise<PublishResult> {
   const postPath = join(state.asset_path, "post.md");
   const postContent = await readFile(postPath, "utf-8");
@@ -129,11 +139,14 @@ async function publishWechatNewspicRoute({
   const renderPhotos = assets.map((asset) => asset.path);
   const photos = mergePhotoLists(renderPhotos, bodyImageUrls);
 
+  const account = accountOverride || state.route.account;
+
   if (dryRun) {
     console.error(`[dry-run] Wechat newspic: ${state.metadata.title}`);
     console.error(`[dry-run] Content file: ${cleanPath}`);
     return {
       route: "wechat-newspic",
+      account,
       status: "skipped",
       detail: "dry-run",
       published_at: null,
@@ -144,7 +157,7 @@ async function publishWechatNewspicRoute({
 
   try {
     await createWechatNewspic({
-      account: state.route.account,
+      account,
       title: state.metadata.title,
       content: cleanContent,
       photos,
@@ -152,11 +165,12 @@ async function publishWechatNewspicRoute({
       existingDraftMediaId: state.intent.existing_draft_media_id,
       noteId: state.intent.note_id,
       nezusBaseUrl: process.env.ZZHUB_WX_BASE_URL || config.wx.baseUrl,
-      nezusPat: process.env.ZZCLUB_PAT || config.wx.accounts[state.route.account]?.pat || config.wx.accounts[config.wx.defaultAccount]?.pat,
+      nezusPat: process.env.ZZCLUB_PAT || config.wx.accounts[account]?.pat || config.wx.accounts[config.wx.defaultAccount]?.pat,
     });
   } catch (error) {
     return {
       route: "wechat-newspic",
+      account,
       status: "failed",
       detail: error instanceof Error ? error.message : String(error),
       published_at: null,
@@ -167,6 +181,7 @@ async function publishWechatNewspicRoute({
 
   return {
     route: "wechat-newspic",
+    account,
     status: "success",
     detail: null,
     published_at: new Date().toISOString(),
@@ -175,9 +190,10 @@ async function publishWechatNewspicRoute({
   };
 }
 
-const PUBLISH_PROVIDERS: Partial<Record<RoutePrimary, PublishProvider>> = {
+const PUBLISH_PROVIDERS: Record<RoutePrimary, PublishProvider> = {
   "wechat-article": publishWechatArticleRoute,
   "wechat-newspic": publishWechatNewspicRoute,
+  "blog": publishBlogRoute,
 };
 
 export function getPublishProvider(route: RoutePrimary): PublishProvider {

package/src/providers/publish-core.ts

@@ -0,0 +1,124 @@
+/**
+ * publish-core.ts — Shared publish execution logic.
+ *
+ * Used by both `publish` (normal flow) and `republish` (add-on).
+ */
+
+import type { PipelineConfig, ResolvedWorkspacePaths } from "../config";
+import type { PublishResult, PublishTarget, WorkflowState } from "../state";
+import { getPublishProvider, type PublishRouteContext } from "./index";
+
+export interface PublishTargetError {
+  route: string;
+  account: string;
+  error: string;
+}
+
+export interface ExecutePublishTargetsParams {
+  state: WorkflowState;
+  targets: PublishTarget[];
+  dryRun: boolean;
+  config: PipelineConfig;
+  workspacePaths: ResolvedWorkspacePaths;
+}
+
+export interface ExecutePublishTargetsResult {
+  results: PublishResult[];
+  errors: PublishTargetError[];
+}
+
+/**
+ * Deduplicate targets by route+account.
+ */
+export function dedupeTargets(targets: PublishTarget[]): PublishTarget[] {
+  const seen = new Set<string>();
+  const result: PublishTarget[] = [];
+  for (const target of targets) {
+    const key = `${target.route}@${target.account}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(target);
+    }
+  }
+  return result;
+}
+
+/**
+ * Filter out targets that already have a successful publish result
+ * at the current content_version + render_version.
+ */
+export function filterIdempotent(
+  targets: PublishTarget[],
+  existingResults: PublishResult[],
+  contentVersion: number,
+  renderVersion: number,
+): PublishTarget[] {
+  return targets.filter((target) => {
+    const existing = existingResults.find(
+      (r) =>
+        r.route === target.route &&
+        r.account === target.account &&
+        r.status === "success" &&
+        r.content_version === contentVersion &&
+        r.render_version === renderVersion,
+    );
+    return !existing;
+  });
+}
+
+/**
+ * Execute publish for a list of targets in parallel.
+ */
+export async function executePublishTargets(
+  params: ExecutePublishTargetsParams,
+): Promise<ExecutePublishTargetsResult> {
+  const { state, targets, dryRun, config, workspacePaths } = params;
+
+  const deduped = dedupeTargets(targets);
+  const filtered = filterIdempotent(
+    deduped,
+    state.publish.results,
+    state.artifacts.content_version,
+    state.artifacts.render_version,
+  );
+
+  const results: PublishResult[] = [];
+  const errors: PublishTargetError[] = [];
+
+  // Execute in parallel
+  const promises = filtered.map(async (target) => {
+    const provider = getPublishProvider(target.route);
+    const ctx: PublishRouteContext = {
+      state,
+      dryRun,
+      config,
+      workspacePaths,
+      accountOverride: target.account,
+    };
+
+    try {
+      const result = await provider(ctx);
+      return { result, error: null };
+    } catch (err) {
+      const error: PublishTargetError = {
+        route: target.route,
+        account: target.account,
+        error: err instanceof Error ? err.message : String(err),
+      };
+      return { result: null, error };
+    }
+  });
+
+  const outcomes = await Promise.all(promises);
+
+  for (const { result, error } of outcomes) {
+    if (result) {
+      results.push(result);
+    }
+    if (error) {
+      errors.push(error);
+    }
+  }
+
+  return { results, errors };
+}

package/src/providers/wechat.ts

@@ -121,7 +121,8 @@ function fillWxAccountConfig(source?: WxAccountConfig): WxAccountConfig {
     appId: source?.appId ?? "",
     appSecret: source?.appSecret ?? "",
     customCss: source?.customCss ?? null,
-  };
+    theme: source?.theme ?? { editorVars: {}, exportTheme: {} },
+  } as WxAccountConfig;
 }
 
 function trimTrailingSlash(value: string): string {
@@ -187,12 +188,17 @@ export function mergePhotoLists(...lists: string[][]): string[] {
 
 export function extractImageUrls(input: string): string[] {
   const urls = new Set<string>();
-  const markdownImageRegex = /!\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+  // Handle both standard ![alt](url) and angle-bracket ![alt](<url>) syntax.
+  // Angle brackets allow URLs with spaces per CommonMark spec.
+  // Match markdown images: ![alt](url) and ![alt](<url with spaces>)
+  // Second alternative uses lazy match so titles like ![alt](url "title") still work.
+  const markdownImageRegex = /!\[[^\]]*\]\((?:<([^>]+)>|([^)]+?))(?:\s+"[^"]*")?\)/g;
   const htmlImageRegex = /<img[^>]+src=["']([^"']+)["'][^>]*>/g;
   let match = markdownImageRegex.exec(input);
   while (match) {
-    if (match[1]) {
-      urls.add(match[1]);
+    const url = match[1] || match[2];
+    if (url) {
+      urls.add(url);
     }
     match = markdownImageRegex.exec(input);
   }
@@ -203,7 +209,12 @@ export function extractImageUrls(input: string): string[] {
     }
     match = htmlImageRegex.exec(input);
   }
-  return [...urls];
+  // Filter out URLs that look like HTML fragments (unescaped code block content
+  // that was incorrectly matched by the image regex patterns).
+  return [...urls].filter((url) => {
+    if (url.startsWith('<') || url.includes('/>')) return false;
+    return true;
+  });
 }
 
 export function replaceImageUrls(html: string, imageUrlMap: Record<string, string>): string {
@@ -335,7 +346,8 @@ async function resolvePhotoPayload(
   }
 
   if (photoUrl.startsWith("http://") || photoUrl.startsWith("https://")) {
-    const response = await fetch(photoUrl);
+    const safeUrl = photoUrl.includes(" ") ? photoUrl.replace(/ /g, "%20") : photoUrl;
+    const response = await fetch(safeUrl);
     if (!response.ok) {
       throw new Error(`Failed to download image: HTTP ${response.status}`);
     }
@@ -348,8 +360,9 @@ async function resolvePhotoPayload(
   }
 
   if (photoUrl.startsWith("file://")) {
-    const url = new URL(photoUrl);
-    return resolveFilePayload(url.pathname, index);
+    const safeUrl = photoUrl.replace(/ /g, "%20");
+    const url = new URL(safeUrl);
+    return resolveFilePayload(decodeURIComponent(url.pathname), index);
   }
 
   return resolveFilePayload(photoUrl, index);
@@ -359,6 +372,14 @@ function resolveFilePayload(
   filePath: string,
   index: number,
 ): { blob: Blob; filename: string } {
+  // Detect HTML fragments incorrectly extracted as image URLs (defense-in-depth)
+  if (filePath.startsWith("<") && (filePath.includes("style=") || filePath.includes("</") || filePath.includes("/>"))) {
+    throw new Error(
+      `Image URL appears to be HTML content, not a valid file path or URL. ` +
+      `This usually means extractImageUrls matched unescaped HTML from a code block. ` +
+      `Got: ${filePath.slice(0, 120)}`,
+    );
+  }
   if (!existsSync(filePath)) {
     throw new Error(`File not found: ${filePath}`);
   }
@@ -549,7 +570,8 @@ export async function createWechatNewspic(input: WechatNewspicInput): Promise<Re
   const uploadResult = await uploadPhotos(runtime, accessToken, finalPhotos, uploadTimeout);
 
   const imageInfo = {
-    image_list: uploadResult.uploadedMedia.map((item) => ({ image_media_id: item.mediaId })),
+    image_list: uploadResult.uploadedMedia
+      .map((item) => ({ image_media_id: item.mediaId })),
   };
 
   const isUpdate = !!input.existingDraftMediaId;

package/src/routes.ts

@@ -148,7 +148,7 @@ const VISUAL_PARAMS: Record<string, AccountVisualParams> = {
     footer: "公众号 · 古一软件",
     bg: "#faf5f8",
     highlight: "#ca6093",
-    fallback_icon: "assets/icons/logo.png",
+    fallback_icon: "assets/icons/ancientone-logo.png",
   },
 };