needware-cli 1.6.3 → 1.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "needware-cli",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "description": "一个功能强大的 Node.js 命令行工具",
   "type": "module",
   "main": "dist/index.js",

package/skills/ai-integration/SKILL.md

@@ -123,15 +123,19 @@ Examples:
 - `supabase/functions/ai-service/index.ts`
 
 ```typescript
-import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
+import { serve } from "https://deno.land/std@0.190.0/http/server.ts";
 
+// CORS headers for cross-origin requests
 const corsHeaders = {
   "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Headers": "authorization, x-client-info, apikey, content-type",
+  "Access-Control-Allow-Headers":
+    "authorization, x-client-info, apikey, content-type",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Max-Age": "86400",
 };
 
+// Request interface
 interface AIRequest {
-  // Define request parameters based on specific AI functionality
   input: string | object;
   options?: {
     model?: string;
@@ -140,10 +144,13 @@ interface AIRequest {
   };
 }
 
-serve(async (req) => {
-  // Handle CORS preflight request
+const handler = async (req: Request): Promise<Response> => {
+  // Handle CORS preflight requests
   if (req.method === "OPTIONS") {
-    return new Response(null, { headers: corsHeaders });
+    return new Response(null, { 
+      status: 200,
+      headers: corsHeaders 
+    });
   }
 
   try {
@@ -153,27 +160,26 @@ serve(async (req) => {
     if (!requestData.input) {
       return new Response(
         JSON.stringify({ error: "Missing required input parameter" }),
-        { status: 400, headers: { ...corsHeaders, "Content-Type": "application/json" } }
+        { 
+          status: 400, 
+          headers: { "Content-Type": "application/json", ...corsHeaders } 
+        }
       );
     }
 
-    // Get API key (from environment variables)
+    // Get API key from environment variables
     const AI_API_KEY = Deno.env.get("AI_API_KEY");
     if (!AI_API_KEY) {
-      console.error("AI_API_KEY not configured");
-      return new Response(
-        JSON.stringify({ error: "AI service not configured" }),
-        { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } }
-      );
+      throw new Error("AI service not configured");
     }
 
     console.log("Processing AI request...");
 
-    // Call AI service (using Needware AI gateway as example)
+    // Call AI Gateway API
     const response = await fetch("https://ai.gateway.needware.dev/v1/chat/completions", {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${AI_API_KEY}`,
+        "Authorization": `Bearer ${AI_API_KEY}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify({
@@ -185,7 +191,7 @@ serve(async (req) => {
           },
           {
             role: "user",
-            content: typeof requestData.input === 'string' 
+            content: typeof requestData.input === "string" 
               ? requestData.input 
               : JSON.stringify(requestData.input)
           }
@@ -195,7 +201,7 @@ serve(async (req) => {
       }),
     });
 
-    // Handle error response
+    // Handle error responses
     if (!response.ok) {
       const errorText = await response.text();
       console.error("AI service error:", response.status, errorText);
@@ -203,20 +209,24 @@ serve(async (req) => {
       if (response.status === 429) {
         return new Response(
           JSON.stringify({ error: "Request rate too high, please try again later" }),
-          { status: 429, headers: { ...corsHeaders, "Content-Type": "application/json" } }
+          { 
+            status: 429, 
+            headers: { "Content-Type": "application/json", ...corsHeaders } 
+          }
         );
       }
+      
       if (response.status === 402) {
         return new Response(
           JSON.stringify({ error: "AI service quota exhausted" }),
-          { status: 402, headers: { ...corsHeaders, "Content-Type": "application/json" } }
+          { 
+            status: 402, 
+            headers: { "Content-Type": "application/json", ...corsHeaders } 
+          }
         );
       }
       
-      return new Response(
-        JSON.stringify({ error: "AI processing failed" }),
-        { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } }
-      );
+      throw new Error(`AI processing failed: ${errorText}`);
     }
 
     // Parse AI response
@@ -224,32 +234,36 @@ serve(async (req) => {
     const content = data.choices?.[0]?.message?.content;
 
     if (!content) {
-      console.error("No content in AI response");
-      return new Response(
-        JSON.stringify({ error: "No AI response generated" }),
-        { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } }
-      );
+      throw new Error("No AI response generated");
     }
 
     console.log("AI processing completed");
 
-    // Return processing result
     return new Response(
       JSON.stringify({ 
+        success: true,
         result: content,
         model: requestData.options?.model || "google/gemini-2.5-flash"
       }),
-      { headers: { ...corsHeaders, "Content-Type": "application/json" } }
+      { 
+        status: 200,
+        headers: { "Content-Type": "application/json", ...corsHeaders } 
+      }
     );
 
-  } catch (error) {
+  } catch (error: any) {
     console.error("Function execution error:", error);
     return new Response(
-      JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" }),
-      { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } }
+      JSON.stringify({ error: error.message || "Unknown error" }),
+      { 
+        status: 500, 
+        headers: { "Content-Type": "application/json", ...corsHeaders } 
+      }
     );
   }
-});
+};
+
+serve(handler);
 ```
 
 ### Frontend Usage Template (TypeScript)
@@ -515,42 +529,59 @@ Use this template when users need image analysis functionality.
 
 ```typescript
 // supabase/functions/analyze-image/index.ts
-import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
+import { serve } from "https://deno.land/std@0.190.0/http/server.ts";
 
+// CORS headers for cross-origin requests
 const corsHeaders = {
   "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Headers": "authorization, x-client-info, apikey, content-type",
+  "Access-Control-Allow-Headers":
+    "authorization, x-client-info, apikey, content-type",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Max-Age": "86400",
 };
 
-serve(async (req) => {
+// Request interface
+interface ImageAnalysisRequest {
+  image: string;
+  prompt?: string;
+}
+
+const handler = async (req: Request): Promise<Response> => {
+  // Handle CORS preflight requests
   if (req.method === "OPTIONS") {
-    return new Response(null, { headers: corsHeaders });
+    return new Response(null, { 
+      status: 200,
+      headers: corsHeaders 
+    });
   }
 
   try {
-    const { image, prompt } = await req.json();
+    const { image, prompt }: ImageAnalysisRequest = await req.json();
 
+    // Validate input
     if (!image) {
       return new Response(
         JSON.stringify({ error: "No image provided" }),
-        { status: 400, headers: { ...corsHeaders, "Content-Type": "application/json" } }
+        { 
+          status: 400, 
+          headers: { "Content-Type": "application/json", ...corsHeaders } 
+        }
       );
     }
 
+    // Get AI API key from environment
     const AI_API_KEY = Deno.env.get("AI_API_KEY");
     if (!AI_API_KEY) {
-      return new Response(
-        JSON.stringify({ error: "AI service not configured" }),
-        { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } }
-      );
+      throw new Error("AI service not configured");
     }
 
     console.log("Analyzing image...");
 
+    // Call AI Gateway API
     const response = await fetch("https://ai.gateway.needware.dev/v1/chat/completions", {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${AI_API_KEY}`,
+        "Authorization": `Bearer ${AI_API_KEY}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify({
@@ -582,16 +613,13 @@ serve(async (req) => {
     if (!response.ok) {
       const errorText = await response.text();
       console.error("AI service error:", response.status, errorText);
-      return new Response(
-        JSON.stringify({ error: "Image analysis failed" }),
-        { status: response.status, headers: { ...corsHeaders, "Content-Type": "application/json" } }
-      );
+      throw new Error(`Image analysis failed: ${errorText}`);
     }
 
     const data = await response.json();
     const analysis = data.choices?.[0]?.message?.content;
 
-    // If expecting structured JSON, try to parse
+    // Try to parse structured JSON from response
     let structuredResult;
     try {
       const jsonMatch = analysis.match(/```json\n?([\s\S]*?)\n?```/) || analysis.match(/\{[\s\S]*\}/);
@@ -608,20 +636,29 @@ serve(async (req) => {
 
     return new Response(
       JSON.stringify({ 
+        success: true,
         result: structuredResult || analysis,
         model: "google/gemini-2.5-flash"
       }),
-      { headers: { ...corsHeaders, "Content-Type": "application/json" } }
+      { 
+        status: 200,
+        headers: { "Content-Type": "application/json", ...corsHeaders } 
+      }
     );
 
-  } catch (error) {
+  } catch (error: any) {
     console.error("Image analysis error:", error);
     return new Response(
-      JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" }),
-      { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } }
+      JSON.stringify({ error: error.message || "Unknown error" }),
+      { 
+        status: 500, 
+        headers: { "Content-Type": "application/json", ...corsHeaders } 
+      }
     );
   }
-});
+};
+
+serve(handler);
 ```
 
 ## Implementation Checklist

package/skills/supabase-integration/SKILL.md

@@ -341,48 +341,87 @@ Create functions in `/supabase/functions/<function-name>/index.ts`
 - **Runtime**: Deno with TypeScript support
 - **Import Supabase**: `import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'`
 - **Environment Variables**: `Deno.env.get('VARIABLE_NAME')`
+- **Standard Library**: Use Deno standard library version 0.190.0 or higher
+
+### Edge Function Best Practices
+
+- ✅ Always include CORS headers for cross-origin requests
+- ✅ Handle OPTIONS requests for CORS preflight
+- ✅ Define TypeScript interfaces for request/response types
+- ✅ Use try-catch for comprehensive error handling
+- ✅ Log errors with `console.error()` for debugging
+- ✅ Return consistent response format with status codes
+- ✅ Validate input data before processing
+- ✅ Use environment variables for sensitive data
 
 ### Edge Function Example
 
 ```typescript
-import { serve } from 'https://deno.land/std@0.168.0/http/server.ts';
-import { createClient } from 'https://esm.sh/@supabase/supabase-js@2';
+import { serve } from "https://deno.land/std@0.190.0/http/server.ts";
+import { createClient } from "https://esm.sh/@supabase/supabase-js@2";
+
+// CORS headers for cross-origin requests
+const corsHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Headers":
+    "authorization, x-client-info, apikey, content-type",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Max-Age": "86400",
+};
+
+// Request interface
+interface UserQueryRequest {
+  name: string;
+}
+
+const handler = async (req: Request): Promise<Response> => {
+  // Handle CORS preflight requests
+  if (req.method === "OPTIONS") {
+    return new Response(null, { 
+      status: 200,
+      headers: corsHeaders 
+    });
+  }
 
-serve(async (req) => {
   try {
-    const { name } = await req.json();
-    
+    const { name }: UserQueryRequest = await req.json();
+
     // Create Supabase client
     const supabaseClient = createClient(
-      Deno.env.get('SUPABASE_URL') ?? '',
-      Deno.env.get('SUPABASE_ANON_KEY') ?? ''
+      Deno.env.get("SUPABASE_URL") ?? "",
+      Deno.env.get("SUPABASE_ANON_KEY") ?? ""
     );
-    
+
     // Execute business logic
     const { data, error } = await supabaseClient
-      .from('users')
-      .select('*')
-      .eq('name', name);
-    
-    if (error) throw error;
-    
+      .from("users")
+      .select("*")
+      .eq("name", name);
+
+    if (error) {
+      throw new Error(error.message);
+    }
+
     return new Response(
-      JSON.stringify({ data }),
-      { 
-        headers: { 'Content-Type': 'application/json' },
-        status: 200 
+      JSON.stringify({ success: true, data }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json", ...corsHeaders },
       }
     );
-  } catch (error) {
+  } catch (error: any) {
+    console.error("Error querying users:", error);
     return new Response(
       JSON.stringify({ error: error.message }),
-      { 
-        headers: { 'Content-Type': 'application/json' },
-        status: 400 
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json", ...corsHeaders },
       }
     );
   }
-});
+};
+
+serve(handler);
 ```
 
 ### Invoking from Client
@@ -391,16 +430,38 @@ serve(async (req) => {
 const { data, error } = await supabase.functions.invoke('function-name', {
   body: { name: 'John' }
 });
+
+if (error) {
+  console.error('Function invocation error:', error);
+} else {
+  console.log('Response:', data);
+}
 ```
 
 ### Common Use Cases
 
-- Webhook handlers
-- Scheduled jobs
-- Third-party API calls
-- Complex business logic
-- Payment processing
-- Email sending
+- **Webhook handlers**: Process incoming webhooks from third-party services
+- **Scheduled jobs**: Execute periodic tasks (with cron triggers)
+- **Third-party API calls**: Integrate with external services
+- **Complex business logic**: Server-side computations and validations
+- **Payment processing**: Handle payment transactions securely
+- **Email sending**: Send transactional emails (e.g., with Resend)
+- **Authentication flows**: Custom authentication logic
+- **Data transformations**: Process and transform data before storage
+
+### Environment Variables in Edge Functions
+
+Store sensitive data in environment variables (managed via Needware `add-secret` tool):
+
+```typescript
+// Common environment variables
+const SUPABASE_URL = Deno.env.get("SUPABASE_URL");
+const SUPABASE_ANON_KEY = Deno.env.get("SUPABASE_ANON_KEY");
+const SUPABASE_SERVICE_ROLE_KEY = Deno.env.get("SUPABASE_SERVICE_ROLE_KEY");
+const CUSTOM_API_KEY = Deno.env.get("CUSTOM_API_KEY");
+```
+
+**Note**: Use `add-secret` tool to securely add environment variables to your Edge Functions.
 
 ## Security