@zzclub/pipeline 0.4.0 → 0.9.0

package/src/providers/wechat.ts

@@ -4,7 +4,11 @@ import { PipelineConfig, WxAccountConfig } from "../config";
 
 const TOKEN_PATH = "/api/v1/wx/cgi-bin/token";
 const MATERIAL_PATH = "/api/v1/wx/cgi-bin/material/add_material";
-const DRAFT_PATH = "/api/v1/wx/cgi-bin/draft/add";
+const DRAFT_ADD_PATH = "/api/v1/wx/cgi-bin/draft/add";
+const DRAFT_UPDATE_PATH = "/api/v1/wx/cgi-bin/draft/update";
+const DRAFT_GET_PATH = "/api/v1/wx/cgi-bin/draft/get";
+const DRAFT_DELETE_PATH = "/api/v1/wx/cgi-bin/draft/delete";
+const BATCH_GET_PATH = "/api/v1/wx/cgi-bin/draft/batchget";
 const TOKEN_TIMEOUT = 10000;
 const UPLOAD_TIMEOUT = 60000;
 const DRAFT_TIMEOUT = 30000;
@@ -78,14 +82,19 @@ interface BaseWechatPublishInput {
   photos?: string[];
   timeout?: number;
   config: PipelineConfig;
+  noteId?: string | null;
+  nezusBaseUrl?: string | null;
+  nezusPat?: string | null;
 }
 
 export interface WechatDraftInput extends BaseWechatPublishInput {
   html: string;
+  existingDraftMediaId?: string | null;
 }
 
 export interface WechatNewspicInput extends BaseWechatPublishInput {
   content: string;
+  existingDraftMediaId?: string | null;
 }
 
 function requireValue(name: string, value: string | undefined): string {
@@ -112,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 {
@@ -178,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);
   }
@@ -194,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 {
@@ -326,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}`);
     }
@@ -339,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);
@@ -350,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}`);
   }
@@ -459,15 +489,21 @@ export async function createWechatDraft(input: WechatDraftInput): Promise<Record
   const uploadResult = await uploadPhotos(runtime, accessToken, finalPhotos, uploadTimeout);
   const replacedHtml = replaceImageUrls(input.html, uploadResult.imageUrlMap);
 
-  const response = await requestJson(
-    `${runtime.baseUrl}${DRAFT_PATH}`,
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${runtime.pat}`,
-      },
-      body: {
+  const isUpdate = !!input.existingDraftMediaId;
+  const draftPath = isUpdate ? DRAFT_UPDATE_PATH : DRAFT_ADD_PATH;
+  const draftBody = isUpdate
+    ? {
+        access_token: accessToken,
+        media_id: input.existingDraftMediaId,
+        index: 0,
+        articles: {
+          article_type: "news",
+          title: input.title,
+          content: replacedHtml,
+          thumb_media_id: uploadResult.coverMediaId,
+        },
+      }
+    : {
         access_token: accessToken,
         articles: [
           {
@@ -477,11 +513,34 @@ export async function createWechatDraft(input: WechatDraftInput): Promise<Record
             thumb_media_id: uploadResult.coverMediaId,
           },
         ],
+      };
+
+  const response = await requestJson(
+    `${runtime.baseUrl}${draftPath}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${runtime.pat}`,
       },
+      body: draftBody,
     },
     draftTimeout,
   );
 
+  const draftMediaId = isUpdate ? input.existingDraftMediaId : (response as any)?.data?.media_id || (response as any)?.media_id || null;
+
+  // ── Callback to Nezus to persist media_id ──
+  if (draftMediaId && input.noteId && input.nezusBaseUrl && input.nezusPat) {
+    await notifyNezusPublishResult({
+      nezusBaseUrl: input.nezusBaseUrl,
+      nezusPat: input.nezusPat,
+      noteId: input.noteId,
+      wechatMediaId: draftMediaId,
+      publishType: "article",
+    });
+  }
+
   return {
     account: runtime.accountName,
     articleType: "news",
@@ -489,6 +548,8 @@ export async function createWechatDraft(input: WechatDraftInput): Promise<Record
     photosCount: finalPhotos.length,
     totalUploaded: uploadResult.totalUploaded,
     coverMediaId: uploadResult.coverMediaId,
+    isUpdate,
+    draftMediaId,
     response,
   };
 }
@@ -509,18 +570,26 @@ 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 response = await requestJson(
-    `${runtime.baseUrl}${DRAFT_PATH}`,
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${runtime.pat}`,
-      },
-      body: {
+  const isUpdate = !!input.existingDraftMediaId;
+  const draftPath = isUpdate ? DRAFT_UPDATE_PATH : DRAFT_ADD_PATH;
+  const draftBody = isUpdate
+    ? {
+        access_token: accessToken,
+        media_id: input.existingDraftMediaId,
+        index: 0,
+        articles: {
+          article_type: "newspic",
+          title: input.title,
+          content: input.content,
+          thumb_media_id: uploadResult.coverMediaId,
+          image_info: imageInfo,
+        },
+      }
+    : {
         access_token: accessToken,
         articles: [
           {
@@ -531,11 +600,34 @@ export async function createWechatNewspic(input: WechatNewspicInput): Promise<Re
             image_info: imageInfo,
           },
         ],
+      };
+
+  const response = await requestJson(
+    `${runtime.baseUrl}${draftPath}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${runtime.pat}`,
       },
+      body: draftBody,
     },
     draftTimeout,
   );
 
+  const draftMediaId = isUpdate ? input.existingDraftMediaId : (response as any)?.data?.media_id || (response as any)?.media_id || null;
+
+  // ── Callback to Nezus to persist media_id ──
+  if (draftMediaId && input.noteId && input.nezusBaseUrl && input.nezusPat) {
+    await notifyNezusPublishResult({
+      nezusBaseUrl: input.nezusBaseUrl,
+      nezusPat: input.nezusPat,
+      noteId: input.noteId,
+      wechatMediaId: draftMediaId,
+      publishType: "newspic",
+    });
+  }
+
   return {
     account: runtime.accountName,
     articleType: "newspic",
@@ -543,6 +635,146 @@ export async function createWechatNewspic(input: WechatNewspicInput): Promise<Re
     photosCount: finalPhotos.length,
     totalUploaded: uploadResult.totalUploaded,
     coverMediaId: uploadResult.coverMediaId,
+    isUpdate,
+    draftMediaId,
+    response,
+  };
+}
+
+// ── Nezus callback ────────────────────────────────────────────────
+
+async function notifyNezusPublishResult(params: {
+  nezusBaseUrl: string;
+  nezusPat: string;
+  noteId: string;
+  wechatMediaId: string;
+  publishType: string;
+}): Promise<void> {
+  try {
+    await requestJson(
+      `${params.nezusBaseUrl}/api/v1/notes/${params.noteId}/publish-result`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${params.nezusPat}`,
+        },
+        body: {
+          wechatMediaId: params.wechatMediaId,
+          publishType: params.publishType,
+        },
+      },
+      10000,
+    );
+    console.error(`[nezus] publish-result callback OK for note ${params.noteId}`);
+  } catch (err) {
+    // Non-fatal: the draft was created successfully even if the callback failed
+    console.error(`[nezus] publish-result callback failed for note ${params.noteId}:`, err);
+  }
+}
+
+// ── Draft management ──────────────────────────────────────────────
+
+export interface WxDraftListInput {
+  account?: string;
+  limit?: number;
+  offset?: number;
+  config: PipelineConfig;
+}
+
+export interface WxDraftGetInput {
+  account?: string;
+  mediaId: string;
+  config: PipelineConfig;
+}
+
+export interface WxDraftDeleteInput {
+  account?: string;
+  mediaId: string;
+  config: PipelineConfig;
+}
+
+export async function getWxDraftList(input: WxDraftListInput): Promise<Record<string, unknown>> {
+  const runtime = getWxRuntimeConfig(input.config, input.account);
+  const tokenTimeout = resolveTimeout(TOKEN_TIMEOUT, runtime.timeout);
+  const accessToken = await fetchAccessToken(runtime, tokenTimeout);
+
+  const response = await requestJson(
+    `${runtime.baseUrl}${BATCH_GET_PATH}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${runtime.pat}`,
+      },
+      body: {
+        access_token: accessToken,
+        offset: input.offset ?? 0,
+        count: input.limit ?? 20,
+        no_content: true,
+      },
+    },
+    resolveTimeout(30000, runtime.timeout),
+  );
+
+  return {
+    account: runtime.accountName,
+    response,
+  };
+}
+
+export async function getWxDraft(input: WxDraftGetInput): Promise<Record<string, unknown>> {
+  const runtime = getWxRuntimeConfig(input.config, input.account);
+  const tokenTimeout = resolveTimeout(TOKEN_TIMEOUT, runtime.timeout);
+  const accessToken = await fetchAccessToken(runtime, tokenTimeout);
+
+  const response = await requestJson(
+    `${runtime.baseUrl}${DRAFT_GET_PATH}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${runtime.pat}`,
+      },
+      body: {
+        access_token: accessToken,
+        media_id: input.mediaId,
+      },
+    },
+    resolveTimeout(30000, runtime.timeout),
+  );
+
+  return {
+    account: runtime.accountName,
+    mediaId: input.mediaId,
+    response,
+  };
+}
+
+export async function deleteWxDraft(input: WxDraftDeleteInput): Promise<Record<string, unknown>> {
+  const runtime = getWxRuntimeConfig(input.config, input.account);
+  const tokenTimeout = resolveTimeout(TOKEN_TIMEOUT, runtime.timeout);
+  const accessToken = await fetchAccessToken(runtime, tokenTimeout);
+
+  const response = await requestJson(
+    `${runtime.baseUrl}${DRAFT_DELETE_PATH}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${runtime.pat}`,
+      },
+      body: {
+        access_token: accessToken,
+        media_id: input.mediaId,
+      },
+    },
+    resolveTimeout(30000, runtime.timeout),
+  );
+
+  return {
+    account: runtime.accountName,
+    mediaId: input.mediaId,
     response,
   };
 }

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",
   },
 };
 

package/src/schema/analytics.test.ts

@@ -0,0 +1,54 @@
+import { describe, test, expect } from "bun:test";
+import { AnalyticsSchema } from "./analytics";
+
+describe("AnalyticsSchema", () => {
+  test("parses minimal analytics", () => {
+    const input = {
+      run_id: "run_001",
+      title: "Test Article",
+      publish_date: "2026-06-11",
+      recorded_at: "2026-06-11T10:00:00Z",
+    };
+
+    const result = AnalyticsSchema.parse(input);
+    expect(result.run_id).toBe("run_001");
+    expect(result.reads).toBe(0);
+    expect(result.likes).toBe(0);
+  });
+
+  test("parses full analytics", () => {
+    const input = {
+      run_id: "run_002",
+      topic_id: "topic_001",
+      title: "AI Tools",
+      publish_date: "2026-06-11",
+      reads: 1500,
+      likes: 45,
+      favorites: 23,
+      shares: 12,
+      comments: 8,
+      notes: "Good performance",
+      recorded_at: "2026-06-11T10:00:00Z",
+    };
+
+    const result = AnalyticsSchema.parse(input);
+    expect(result.reads).toBe(1500);
+    expect(result.topic_id).toBe("topic_001");
+  });
+
+  test("defaults metrics to 0", () => {
+    const input = {
+      run_id: "run_003",
+      title: "Test",
+      publish_date: "2026-06-11",
+      recorded_at: "2026-06-11T10:00:00Z",
+    };
+
+    const result = AnalyticsSchema.parse(input);
+    expect(result.reads).toBe(0);
+    expect(result.likes).toBe(0);
+    expect(result.favorites).toBe(0);
+    expect(result.shares).toBe(0);
+    expect(result.comments).toBe(0);
+  });
+});

package/src/schema/analytics.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+export const AnalyticsSchema = z.object({
+  run_id: z.string(),
+  topic_id: z.string().nullable().default(null),
+  title: z.string(),
+  publish_date: z.string(),
+
+  reads: z.number().int().default(0),
+  likes: z.number().int().default(0),
+  favorites: z.number().int().default(0),
+  shares: z.number().int().default(0),
+  comments: z.number().int().default(0),
+
+  notes: z.string().nullable().default(null),
+  recorded_at: z.string(),
+});
+
+export type Analytics = z.infer<typeof AnalyticsSchema>;

package/src/schema/config.ts

@@ -32,11 +32,33 @@ function withObjectDefault<T extends z.ZodObject<any>>(schema: T) {
 
 // ── Sub-schemas ───────────────────────────────────────────────────
 
+const WechatExportThemeOverridesSchema = z.object({
+  containerStyle: z.string().optional(),
+  footerText: z.string().optional(),
+  footerStyle: z.string().optional(),
+  fontFamily: z.string().optional(),
+  bodyColor: z.string().optional(),
+  mutedColor: z.string().optional(),
+  primaryColor: z.string().optional(),
+  dividerColor: z.string().optional(),
+  blockquoteBorderColor: z.string().optional(),
+  bodyLineHeight: z.string().optional(),
+  bodyLetterSpacing: z.string().optional(),
+});
+
+const WechatThemeOverridesSchema = withObjectDefault(
+  z.object({
+    editorVars: z.record(z.string(), z.string()).default({}),
+    exportTheme: withObjectDefault(WechatExportThemeOverridesSchema),
+  }),
+);
+
 const WxAccountConfigSchema = z.object({
   pat: z.string().default(""),
   appId: z.string().default(""),
   appSecret: z.string().default(""),
   customCss: z.string().nullable().default(null),
+  theme: WechatThemeOverridesSchema,
 });
 
 const WxConfigSchema = withObjectDefault(
@@ -52,7 +74,7 @@ const WxConfigSchema = withObjectDefault(
     defaultAccount: trimmedNonEmptyString("default"),
     accounts: z
       .record(z.string(), WxAccountConfigSchema)
-      .default({ default: { pat: "", appId: "", appSecret: "", customCss: null } }),
+      .default({ default: { pat: "", appId: "", appSecret: "", customCss: null, theme: { editorVars: {}, exportTheme: {} } } }),
   }),
 );
 
@@ -127,6 +149,8 @@ export type PipelineCommandConfig = z.infer<typeof PipelineCommandConfigSchema>;
 export type CosConfig = z.infer<typeof CosConfigSchema>;
 export type PluginsConfig = z.infer<typeof PluginsConfigSchema>;
 export type ImgxConfig = z.infer<typeof ImgxConfigSchema>;
+export type WechatExportThemeOverrides = z.infer<typeof WechatExportThemeOverridesSchema>;
+export type WechatThemeOverrides = z.infer<typeof WechatThemeOverridesSchema>;
 
 // ── Schema instances for reuse ────────────────────────────────────
 

package/src/schema/state.ts

@@ -260,6 +260,7 @@ const ImagesSchema = withObjectDefault(
 
 const PublishResultSchema = z.object({
   route: RoutePrimarySchema,
+  account: trimmedString("default"),
   status: PublishResultStatusSchema,
   detail: z.string().nullable().default(null),
   published_at: z.string().nullable().default(null),
@@ -273,6 +274,11 @@ const PublishResultsSchema = withObjectDefault(
   }),
 );
 
+const PublishTargetSchema = z.object({
+  route: RoutePrimarySchema,
+  account: trimmedString("default"),
+});
+
 const ContentReviewSchema = withObjectDefault(
   z.object({
     status: ContentReviewStatusSchema,
@@ -303,6 +309,8 @@ const IntentSchema = withObjectDefault(
     style_hint: z.string().nullable().default(null),
     newspic_render: NewspicRenderSpecSchema.nullable().default(null),
     requires: IntentRequiresSchema,
+    existing_draft_media_id: z.string().nullable().default(null),
+    note_id: z.string().nullable().default(null),
   }),
 );
 
@@ -327,6 +335,7 @@ export const WorkflowStateSchema = z.object({
   artifacts: ArtifactsSchema,
   images: ImagesSchema,
   publish: PublishResultsSchema,
+  publish_targets: z.array(PublishTargetSchema).default([]),
   content_review: ContentReviewSchema,
   redo_hint: z.string().nullable().default(null),
 });
@@ -368,6 +377,7 @@ export type Images = z.infer<typeof ImagesSchema>;
 export type PublishResultStatus = z.infer<typeof PublishResultStatusSchema>;
 export type PublishResult = z.infer<typeof PublishResultSchema>;
 export type PublishResults = z.infer<typeof PublishResultsSchema>;
+export type PublishTarget = z.infer<typeof PublishTargetSchema>;
 export type ContentReviewStatus = z.infer<typeof ContentReviewStatusSchema>;
 export type ContentReview = z.infer<typeof ContentReviewSchema>;
 export type HandoffResearchPolicy = z.infer<typeof HandoffResearchPolicySchema>;

package/src/schema/topic.test.ts

@@ -0,0 +1,69 @@
+import { describe, test, expect } from "bun:test";
+import { TopicSchema } from "./topic";
+
+describe("TopicSchema", () => {
+  test("parses minimal topic", () => {
+    const input = {
+      topic_id: "topic_001",
+      title: "Test Topic",
+      created_at: "2026-06-11T00:00:00Z",
+      updated_at: "2026-06-11T00:00:00Z",
+    };
+
+    const result = TopicSchema.parse(input);
+    expect(result.topic_id).toBe("topic_001");
+    expect(result.status).toBe("backlog");
+    expect(result.priority).toBe("medium");
+  });
+
+  test("parses full topic", () => {
+    const input = {
+      topic_id: "topic_002",
+      title: "AI Tools",
+      description: "About AI tools",
+      priority: "high",
+      tags: ["AI", "tools"],
+      notes: "Some notes",
+      status: "scheduled",
+      ai_score: 85,
+      ai_reason: "Good topic",
+      scheduled_date: "2026-06-15",
+      target_account: "default",
+      run_id: "run_001",
+      retro_performance: "good",
+      retro_lessons: "Learned something",
+      retro_metrics_snapshot: { reads: 1500 },
+      created_at: "2026-06-11T00:00:00Z",
+      updated_at: "2026-06-11T00:00:00Z",
+    };
+
+    const result = TopicSchema.parse(input);
+    expect(result.priority).toBe("high");
+    expect(result.tags).toEqual(["AI", "tools"]);
+    expect(result.ai_score).toBe(85);
+  });
+
+  test("rejects invalid priority", () => {
+    const input = {
+      topic_id: "topic_003",
+      title: "Test",
+      priority: "urgent",
+      created_at: "2026-06-11T00:00:00Z",
+      updated_at: "2026-06-11T00:00:00Z",
+    };
+
+    expect(() => TopicSchema.parse(input)).toThrow();
+  });
+
+  test("rejects invalid ai_score", () => {
+    const input = {
+      topic_id: "topic_004",
+      title: "Test",
+      ai_score: 150,
+      created_at: "2026-06-11T00:00:00Z",
+      updated_at: "2026-06-11T00:00:00Z",
+    };
+
+    expect(() => TopicSchema.parse(input)).toThrow();
+  });
+});