@astro-minimax/cli 0.5.0 → 0.7.1

package/template/functions/api/notify/comment.ts

@@ -1,22 +1,23 @@
 /// <reference types="@cloudflare/workers-types" />
-import { createNotifier } from '@astro-minimax/notify';
+import { getNotifier } from '@astro-minimax/notify';
 
 interface WalineComment {
-  objectId?: string;
-  url: string;
-  nick: string;
-  mail: string;
+  objectId?: string | number;
+  url?: string;
+  nick?: string;
+  mail?: string;
   link?: string;
-  comment: string;
+  comment?: string;
+  rawComment?: string;
   ip?: string;
   ua?: string;
   insertedAt?: string;
+  createdAt?: string;
+  updatedAt?: string;
   status?: string;
-}
-
-interface WalineWebhookPayload {
-  type: 'new_comment' | 'new_reply';
-  data: WalineComment;
+  type?: string;
+  user_id?: number;
+  rid?: string | number;
 }
 
 interface FunctionEnv {
@@ -33,77 +34,148 @@ interface FunctionEnv {
 export const onRequest: PagesFunction<FunctionEnv> = async (context) => {
   const { env, request } = context;
 
-  if (!env.NOTIFY_TELEGRAM_BOT_TOKEN && !env.NOTIFY_WEBHOOK_URL && !env.NOTIFY_RESEND_API_KEY) {
-    return new Response(JSON.stringify({ error: 'No notification providers configured' }), {
-      status: 400,
-      headers: { 'Content-Type': 'application/json' },
+  try {
+    if (!env.NOTIFY_TELEGRAM_BOT_TOKEN && !env.NOTIFY_WEBHOOK_URL && !env.NOTIFY_RESEND_API_KEY) {
+      console.warn('[notify/comment] No providers configured');
+      return jsonError('No notification providers configured', 400);
+    }
+
+    let rawData: unknown;
+    try {
+      rawData = await request.json();
+    } catch (parseError) {
+      console.error('[notify/comment] Failed to parse JSON:', parseError);
+      return jsonError('Invalid JSON payload', 400);
+    }
+
+    console.log('[notify/comment] Raw payload:', JSON.stringify(rawData).slice(0, 500));
+
+    const { commentData, eventType } = parseWalinePayload(rawData);
+    
+    if (!commentData) {
+      console.error('[notify/comment] Could not extract comment data from payload');
+      return jsonError('Invalid payload structure', 400);
+    }
+
+    const siteUrl = env.SITE_URL || 'https://your-blog.pages.dev';
+    const urlPath = getStringValue(commentData.url) || '';
+    const postUrl = urlPath.startsWith('http') 
+      ? urlPath 
+      : `${siteUrl}${urlPath}`;
+
+    const author = getStringValue(commentData.nick) || '匿名用户';
+    const content = getStringValue(commentData.rawComment) || getStringValue(commentData.comment) || '';
+    const postTitle = extractPostTitle(urlPath);
+
+    console.log('[notify/comment] Processing:', { urlPath, author, postTitle });
+
+    const notifier = getNotifier({
+      telegram: env.NOTIFY_TELEGRAM_BOT_TOKEN && env.NOTIFY_TELEGRAM_CHAT_ID ? {
+        botToken: env.NOTIFY_TELEGRAM_BOT_TOKEN,
+        chatId: env.NOTIFY_TELEGRAM_CHAT_ID,
+      } : undefined,
+      webhook: env.NOTIFY_WEBHOOK_URL ? {
+        url: env.NOTIFY_WEBHOOK_URL,
+      } : undefined,
+      email: env.NOTIFY_RESEND_API_KEY && env.NOTIFY_RESEND_FROM && env.NOTIFY_RESEND_TO ? {
+        provider: 'resend',
+        apiKey: env.NOTIFY_RESEND_API_KEY,
+        from: env.NOTIFY_RESEND_FROM,
+        to: env.NOTIFY_RESEND_TO,
+      } : undefined,
     });
-  }
 
-  let payload: WalineWebhookPayload;
-  try {
-    payload = await request.json() as WalineWebhookPayload;
-  } catch {
-    return new Response(JSON.stringify({ error: 'Invalid JSON payload' }), {
-      status: 400,
-      headers: { 'Content-Type': 'application/json' },
+    const result = await notifier.comment({
+      author,
+      content,
+      postTitle,
+      postUrl,
     });
-  }
 
-  if (payload.type !== 'new_comment' && payload.type !== 'new_reply') {
-    return new Response(JSON.stringify({ error: 'Unsupported event type' }), {
-      status: 400,
+    console.log('[notify/comment] Result:', { success: result.success, channels: result.results.length });
+
+    return new Response(JSON.stringify({
+      success: result.success,
+      event: eventType,
+      channels: result.results.map(r => ({
+        channel: r.channel,
+        success: r.success,
+      })),
+    }), {
+      status: 200,
       headers: { 'Content-Type': 'application/json' },
     });
+  } catch (error) {
+    console.error('[notify/comment] Unexpected error:', error);
+    return jsonError(
+      error instanceof Error ? error.message : 'Unknown error',
+      500
+    );
   }
+};
 
-  const { data } = payload;
-  const siteUrl = env.SITE_URL || 'https://your-blog.pages.dev';
-  
-  const postUrl = data.url.startsWith('http') 
-    ? data.url 
-    : `${siteUrl}${data.url}`;
-
-  const notifier = createNotifier({
-    telegram: env.NOTIFY_TELEGRAM_BOT_TOKEN && env.NOTIFY_TELEGRAM_CHAT_ID ? {
-      botToken: env.NOTIFY_TELEGRAM_BOT_TOKEN,
-      chatId: env.NOTIFY_TELEGRAM_CHAT_ID,
-    } : undefined,
-    webhook: env.NOTIFY_WEBHOOK_URL ? {
-      url: env.NOTIFY_WEBHOOK_URL,
-    } : undefined,
-    email: env.NOTIFY_RESEND_API_KEY && env.NOTIFY_RESEND_FROM && env.NOTIFY_RESEND_TO ? {
-      provider: 'resend',
-      apiKey: env.NOTIFY_RESEND_API_KEY,
-      from: env.NOTIFY_RESEND_FROM,
-      to: env.NOTIFY_RESEND_TO,
-    } : undefined,
-  });
+function parseWalinePayload(raw: unknown): { commentData: WalineComment | null; eventType: string } {
+  if (!raw || typeof raw !== 'object') {
+    return { commentData: null, eventType: 'unknown' };
+  }
 
-  const result = await notifier.comment({
-    author: data.nick,
-    content: data.comment,
-    postTitle: extractPostTitle(data.url),
-    postUrl,
-  });
+  const data = raw as Record<string, unknown>;
+
+  // Waline format: { type: 'new_comment', data: { comment: {...} } }
+  if (data.type === 'new_comment' || data.type === 'new_reply') {
+    const dataObj = data.data as Record<string, unknown> | undefined;
+    // Check if data contains a 'comment' field (Waline's nested structure)
+    if (dataObj && dataObj.comment && typeof dataObj.comment === 'object') {
+      return { 
+        commentData: dataObj.comment as WalineComment, 
+        eventType: data.type as string 
+      };
+    }
+    // Fallback: data is the comment object directly
+    return { 
+      commentData: dataObj as WalineComment, 
+      eventType: data.type as string 
+    };
+  }
+
+  // Direct comment object format
+  if (data.url || data.nick || data.comment || data.mail) {
+    const type = data.rid ? 'new_reply' : 'new_comment';
+    return { 
+      commentData: data as WalineComment, 
+      eventType: type 
+    };
+  }
 
-  return new Response(JSON.stringify({
-    success: result.success,
-    event: 'comment',
-    channels: result.results.map(r => ({
-      channel: r.channel,
-      success: r.success,
-    })),
-  }), {
-    status: 200,
+  return { commentData: null, eventType: 'unknown' };
+}
+
+function getStringValue(value: unknown): string | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value === 'string') return value;
+  return String(value);
+}
+
+function jsonError(message: string, status: number): Response {
+  return new Response(JSON.stringify({ error: message }), {
+    status,
     headers: { 'Content-Type': 'application/json' },
   });
-};
+}
 
 function extractPostTitle(url: string): string {
-  const match = url.match(/\/posts\/([^/]+)/);
-  if (match) {
-    return decodeURIComponent(match[1].replace(/-/g, ' '));
+  if (!url || typeof url !== 'string') {
+    return '博客文章';
+  }
+  
+  // Match /posts/xxx, /zh/posts/xxx, or /post/xxx formats
+  const match = url.match(/\/(?:[a-z]{2}\/)?posts?\/([^/]+)/);
+  if (match && match[1]) {
+    try {
+      return decodeURIComponent(match[1].replace(/-/g, ' '));
+    } catch {
+      return match[1].replace(/-/g, ' ');
+    }
   }
   return '博客文章';
 }

package/template/functions/api/notify/debug.ts

@@ -0,0 +1,41 @@
+/// <reference types="@cloudflare/workers-types" />
+
+interface DebugEnv {
+  [key: string]: unknown;
+}
+
+export const onRequest: PagesFunction<DebugEnv> = async (context) => {
+  const { request } = context;
+  
+  const headers: Record<string, string> = {};
+  request.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  
+  let body = null;
+  let bodyError = null;
+  try {
+    body = await request.json();
+  } catch (e) {
+    bodyError = e instanceof Error ? e.message : String(e);
+  }
+  
+  const debug = {
+    timestamp: new Date().toISOString(),
+    method: request.method,
+    url: request.url,
+    headers,
+    body,
+    bodyError,
+  };
+  
+  console.log('[notify/debug] Request received:', JSON.stringify(debug, null, 2));
+  
+  return new Response(JSON.stringify(debug, null, 2), {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*',
+    },
+  });
+};

package/template/functions/api/notify/status.ts

@@ -0,0 +1,97 @@
+/// <reference types="@cloudflare/workers-types" />
+
+interface NotifyStatusEnv {
+  NOTIFY_TELEGRAM_BOT_TOKEN?: string;
+  NOTIFY_TELEGRAM_CHAT_ID?: string;
+  NOTIFY_WEBHOOK_URL?: string;
+  NOTIFY_RESEND_API_KEY?: string;
+  NOTIFY_RESEND_FROM?: string;
+  NOTIFY_RESEND_TO?: string;
+  SITE_URL?: string;
+  [key: string]: unknown;
+}
+
+interface ProviderStatus {
+  configured: boolean;
+  missingFields?: string[];
+}
+
+interface NotifyStatusResponse {
+  timestamp: string;
+  environment: 'production' | 'preview' | 'unknown';
+  providers: {
+    telegram: ProviderStatus;
+    email: ProviderStatus;
+    webhook: ProviderStatus;
+  };
+  siteUrl: {
+    configured: boolean;
+    value?: string;
+  };
+  summary: {
+    totalProviders: number;
+    configuredProviders: number;
+    hasAnyProvider: boolean;
+  };
+}
+
+export const onRequest: PagesFunction<NotifyStatusEnv> = async (context) => {
+  const env = context.env;
+  
+  const telegramMissing = [
+    !env.NOTIFY_TELEGRAM_BOT_TOKEN && 'NOTIFY_TELEGRAM_BOT_TOKEN',
+    !env.NOTIFY_TELEGRAM_CHAT_ID && 'NOTIFY_TELEGRAM_CHAT_ID',
+  ].filter(Boolean) as string[];
+  
+  const emailMissing = [
+    !env.NOTIFY_RESEND_API_KEY && 'NOTIFY_RESEND_API_KEY',
+    !env.NOTIFY_RESEND_FROM && 'NOTIFY_RESEND_FROM',
+    !env.NOTIFY_RESEND_TO && 'NOTIFY_RESEND_TO',
+  ].filter(Boolean) as string[];
+  
+  const webhookMissing = [
+    !env.NOTIFY_WEBHOOK_URL && 'NOTIFY_WEBHOOK_URL',
+  ].filter(Boolean) as string[];
+  
+  const environment = context.request.headers.get('x-cf-env') || 'unknown';
+  
+  const providers = {
+    telegram: {
+      configured: telegramMissing.length === 0,
+      missingFields: telegramMissing.length > 0 ? telegramMissing : undefined,
+    },
+    email: {
+      configured: emailMissing.length === 0,
+      missingFields: emailMissing.length > 0 ? emailMissing : undefined,
+    },
+    webhook: {
+      configured: webhookMissing.length === 0,
+      missingFields: webhookMissing.length > 0 ? webhookMissing : undefined,
+    },
+  };
+  
+  const configuredProviders = Object.values(providers).filter(p => p.configured).length;
+  
+  const response: NotifyStatusResponse = {
+    timestamp: new Date().toISOString(),
+    environment: environment as 'production' | 'preview' | 'unknown',
+    providers,
+    siteUrl: {
+      configured: !!env.SITE_URL,
+      value: env.SITE_URL ? '[CONFIGURED]' : undefined,
+    },
+    summary: {
+      totalProviders: 3,
+      configuredProviders,
+      hasAnyProvider: configuredProviders > 0,
+    },
+  };
+  
+  return new Response(JSON.stringify(response, null, 2), {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json',
+      'Cache-Control': 'no-store, no-cache, must-revalidate',
+    },
+  });
+};

package/template/functions/api/notify/test-ai-chat.ts

@@ -0,0 +1,67 @@
+/// <reference types="@cloudflare/workers-types" />
+
+import { notifyAiChat } from '@astro-minimax/ai/server';
+
+interface TestEnv {
+  NOTIFY_TELEGRAM_BOT_TOKEN?: string;
+  NOTIFY_TELEGRAM_CHAT_ID?: string;
+  NOTIFY_WEBHOOK_URL?: string;
+  NOTIFY_RESEND_API_KEY?: string;
+  NOTIFY_RESEND_FROM?: string;
+  NOTIFY_RESEND_TO?: string;
+  SITE_URL?: string;
+  [key: string]: unknown;
+}
+
+export const onRequest: PagesFunction<TestEnv> = async (context) => {
+  const env = context.env;
+  
+  const result = await notifyAiChat({
+    env,
+    sessionId: `test-${Date.now()}`,
+    messages: [
+      { id: '1', role: 'user', parts: [{ type: 'text', text: '这是一条测试消息' }] }
+    ],
+    aiResponse: '这是一条测试 AI 回复',
+    referencedArticles: [
+      { title: '测试文章', url: '/posts/test' }
+    ],
+    model: {
+      name: 'test-model',
+      provider: 'test',
+    },
+    usage: {
+      total: 150,
+      input: 100,
+      output: 50,
+    },
+    timing: {
+      total: 1000,
+      keywordExtraction: 100,
+      search: 200,
+      evidenceAnalysis: 100,
+      generation: 600,
+    },
+  });
+  
+  return new Response(JSON.stringify({
+    success: !!result,
+    result: result ? {
+      event: result.event,
+      success: result.success,
+      channels: result.results.map(r => ({
+        channel: r.channel,
+        success: r.success,
+        error: r.error,
+      })),
+    } : null,
+    envCheck: {
+      hasTelegram: !!env.NOTIFY_TELEGRAM_BOT_TOKEN,
+      hasChatId: !!env.NOTIFY_TELEGRAM_CHAT_ID,
+      hasResend: !!env.NOTIFY_RESEND_API_KEY,
+    },
+  }, null, 2), {
+    status: 200,
+    headers: { 'Content-Type': 'application/json' },
+  });
+};

package/template/package.json

@@ -5,29 +5,32 @@
   "scripts": {
     "dev": "astro dev",
     "dev:ai": "pnpm exec astro-ai-dev",
-    "dev:full": "concurrently -n \"astro,ai\" -c \"blue,green\" \"astro dev\" \"pnpm exec astro-ai-dev\"",
     "build": "astro check && astro build && pagefind --site dist && cp -r dist/pagefind public/",
     "preview": "wrangler pages dev dist",
     "preview:astro": "astro preview",
     "lint": "eslint .",
-    "tools:summarize": "tsx tools/summarize.ts",
-    "tools:generate-related": "tsx tools/generate-related.ts",
-    "tools:translate": "tsx tools/translate.ts",
-    "tools:vectorize": "tsx tools/vectorize.ts",
-    "tools:cover": "tsx tools/generate-cover.ts",
-    "tools:tags": "tsx tools/generate-tags.ts",
-    "ai:process": "tsx tools/ai-process.ts",
-    "context:build": "tsx tools/build-author-context.ts",
-    "voice:build": "tsx tools/build-voice-profile.ts",
-    "profile:generate": "tsx tools/generate-author-profile.ts"
+    "cli": "astro-minimax",
+    "ai:process": "astro-minimax ai process",
+    "ai:seo": "astro-minimax ai seo",
+    "ai:summary": "astro-minimax ai summary",
+    "ai:eval": "astro-minimax ai eval",
+    "profile:build": "astro-minimax profile build",
+    "profile:context": "astro-minimax profile context",
+    "profile:voice": "astro-minimax profile voice",
+    "profile:report": "astro-minimax profile report",
+    "post:new": "astro-minimax post new",
+    "post:list": "astro-minimax post list",
+    "post:stats": "astro-minimax post stats",
+    "data:status": "astro-minimax data status",
+    "data:clear": "astro-minimax data clear"
   },
   "dependencies": {
     "@ai-sdk/openai-compatible": "^2.0.35",
     "@ai-sdk/react": "^3.0.118",
-    "@astro-minimax/ai": "^0.1.0",
-    "@astro-minimax/core": "^0.1.0",
-    "@astro-minimax/notify": "^0.1.0",
-    "@astro-minimax/viz": "^0.1.4",
+    "@astro-minimax/ai": "^0.5.0",
+    "@astro-minimax/core": "^0.5.0",
+    "@astro-minimax/notify": "^0.5.0",
+    "@astro-minimax/viz": "^0.5.0",
     "@astrojs/mdx": "^5.0.0",
     "@astrojs/preact": "^5.0.0",
     "@astrojs/rss": "^4.0.17",
@@ -44,34 +47,28 @@
     "mermaid": "^11.12.3",
     "preact": "^10.29.0",
     "rehype-katex": "^7.0.1",
-    "remark-collapse": "^0.1.2",
     "remark-emoji": "^5.0.2",
     "remark-github-alerts": "^0.1.1",
     "remark-markmap": "^1.1.5",
     "remark-math": "^6.0.0",
-    "remark-toc": "^9.0.0",
     "satori": "^0.18.0",
     "sharp": "^0.34.5",
     "slugify": "^1.6.6",
     "tailwindcss": "^4.2.1"
   },
   "devDependencies": {
+    "@astro-minimax/cli": "^0.6.0",
     "@astrojs/check": "^0.9.6",
     "@cloudflare/workers-types": "^4.20260313.1",
     "@pagefind/default-ui": "^1.4.0",
-    "@shikijs/transformers": "^4.0.0",
+    "@shikijs/transformers": "^4.0.2",
     "@types/lodash.kebabcase": "^4.1.9",
-    "@types/mdast": "^4.0.4",
-    "concurrently": "^9.1.2",
     "eslint": "^9.39.3",
     "eslint-plugin-astro": "^1.6.0",
-    "globals": "^16.2.0",
+    "globals": "^16.5.0",
     "pagefind": "^1.4.0",
-    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.39.0",
-    "undici": "^7.24.1",
-    "unist-util-visit": "^5.1.0",
+    "typescript-eslint": "^8.56.1",
     "wrangler": "^4.73.0"
   }
 }

package/template/src/config.ts

@@ -87,6 +87,17 @@ export const SITE: SiteConfig = {
   //   src: "https://your-umami-instance.com/script.js",
   // },
 
+  // Search provider: 'pagefind' (default, static) or 'docsearch' (Algolia)
+  // search: {
+  //   provider: 'docsearch',
+  //   docsearch: {
+  //     appId: 'YOUR_ALGOLIA_APP_ID',
+  //     apiKey: 'YOUR_ALGOLIA_SEARCH_API_KEY',
+  //     indexName: 'YOUR_INDEX_NAME',
+  //     placeholder: 'Search docs...',
+  //   },
+  // },
+
   copyright: {
     license: "CC BY-NC-SA 4.0",
     licenseUrl: "https://creativecommons.org/licenses/by-nc-sa/4.0/",

package/template/src/content.config.ts

@@ -1,27 +1,40 @@
 import { defineCollection } from "astro:content";
 import { z } from "astro/zod";
 import { glob } from "astro/loaders";
+import { SITE } from "@/config";
+
+export const BLOG_PATH = "src/data/blog";
 
 const blog = defineCollection({
   loader: glob({
     pattern: "**/[^_]*.{md,mdx}",
-    base: "./src/data/blog",
-    generateId: ({ entry }) => entry.replace(/\.(md|mdx)$/, ""),
-  }),
-  schema: z.object({
-    title: z.string(),
-    description: z.string(),
-    pubDatetime: z.date(),
-    modDatetime: z.date().optional().nullable(),
-    author: z.string().optional(),
-    tags: z.array(z.string()).default(["others"]),
-    category: z.string().optional(),
-    series: z.object({ name: z.string(), order: z.number() }).optional(),
-    featured: z.boolean().optional(),
-    draft: z.boolean().optional(),
-    ogImage: z.string().optional(),
-    canonicalURL: z.string().optional(),
+    base: `./${BLOG_PATH}`,
+    generateId: ({ entry }) => {
+      return entry.replace(/\.(md|mdx)$/, "");
+    },
   }),
+  schema: ({ image }) =>
+    z.object({
+      author: z.string().default(SITE.author),
+      pubDatetime: z.date(),
+      modDatetime: z.date().optional().nullable(),
+      title: z.string(),
+      featured: z.boolean().optional(),
+      draft: z.boolean().optional(),
+      tags: z.array(z.string()).default(["others"]),
+      category: z.string().optional(),
+      series: z
+        .object({
+          name: z.string(),
+          order: z.number(),
+        })
+        .optional(),
+      ogImage: image().or(z.string()).optional(),
+      description: z.string(),
+      canonicalURL: z.string().optional(),
+      hideEditPost: z.boolean().optional(),
+      timezone: z.string().optional(),
+    }),
 });
 
 export const collections = { blog };

package/template/src/env.d.ts

@@ -1,9 +1,4 @@
 /// <reference types="astro/content" />
-declare module "remark-collapse" {
-  import type { Plugin } from "unified";
-  const plugin: Plugin;
-  export default plugin;
-}
 declare module "remark-github-alerts" {
   import type { Plugin } from "unified";
   const plugin: Plugin;

package/index.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-import { cpSync, mkdirSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve, basename } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = fileURLToPath(new URL(".", import.meta.url));
-const templateDir = join(__dirname, "template");
-
-const projectName = process.argv[2];
-if (!projectName) {
-  console.error("Usage: astro-minimax <project-name>");
-  console.error("       npx @astro-minimax/cli <project-name>");
-  process.exit(1);
-}
-
-const targetDir = resolve(process.cwd(), projectName);
-
-if (existsSync(targetDir)) {
-  console.error(`Directory "${projectName}" already exists.`);
-  process.exit(1);
-}
-
-mkdirSync(targetDir, { recursive: true });
-cpSync(templateDir, targetDir, { recursive: true });
-
-const pkgPath = join(targetDir, "package.json");
-const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-pkg.name = basename(targetDir);
-writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-
-console.log(`\n  ✅ Created "${projectName}" successfully!\n`);
-console.log("  Next steps:\n");
-console.log(`    cd ${projectName}`);
-console.log("    pnpm install");
-console.log("    pnpm dev\n");
-console.log("  Docs: https://github.com/souloss/astro-minimax\n");